import type { AgentEvent } from "@kenkaiiii/gg-agent";
import type { SubAgentSnapshot } from "./subagent-manager.js";
export interface BusEventMap {
    text_delta: {
        text: string;
    };
    thinking_delta: {
        text: string;
    };
    tool_call_start: {
        toolCallId: string;
        name: string;
        args: Record<string, unknown>;
    };
    tool_call_update: {
        toolCallId: string;
        update: unknown;
    };
    tool_call_end: {
        toolCallId: string;
        result: string;
        isError: boolean;
        durationMs: number;
        /** Tool-specific extras (e.g. screenshot/read image previews). */
        details?: unknown;
        /** Consecutive count for a repeated schema-validation failure; see AgentToolCallEndEvent. */
        invalidArgAttempt?: number;
    };
    turn_end: {
        turn: number;
        stopReason: string;
        usage: {
            inputTokens: number;
            outputTokens: number;
            cacheRead?: number;
            cacheWrite?: number;
        };
    };
    /** Step boundary: every message for this turn is in the array. Hosts persist here. */
    checkpoint: {
        turn: number;
    };
    agent_done: {
        totalTurns: number;
        totalUsage: {
            inputTokens: number;
            outputTokens: number;
            cacheRead?: number;
            cacheWrite?: number;
        };
    };
    max_turns: {
        totalTurns: number;
        maxTurns: number;
    };
    /** Turn budget was exhausted but extended because the run showed progress. */
    turn_budget_extended: {
        turn: number;
        grantedTurns: number;
        extension: number;
    };
    truncated: {
        reason: "max_tokens" | "refusal" | "provider_error" | "empty_response";
        continued: boolean;
    };
    error: {
        error: Error;
    };
    server_tool_call: {
        id: string;
        name: string;
        input: unknown;
    };
    server_tool_result: {
        toolUseId: string;
        resultType: string;
        data: unknown;
    };
    hook: {
        kind: "ideal" | "verification" | "loop_break" | "regrounding";
        coverageExpected?: string[];
        coverageMissing?: string[];
    };
    /** A pre-final hook would fire if the agent stopped right now: the Ideal
     *  review, or the verification gate. Emitted as soon as the run crosses the
     *  gate — i.e. BEFORE the candidate final answer streams — so a client can
     *  hold that answer back instead of painting a draft the hook then discards. */
    hook_armed: {
        kind: "ideal" | "verification";
        armed: boolean;
    };
    subagent_state: SubAgentSnapshot;
    /** Queued user steering was consumed into the run at a turn boundary.
     *  `count` is the remaining depth. Lets clients clear the "queued" affordance
     *  the moment the agent picks a message up, instead of holding it until
     *  run_end — the message is already in the loop long before the run ends. */
    queue_drained: {
        count: number;
    };
    session_start: {
        sessionId: string;
    };
    model_change: {
        provider: string;
        model: string;
        supportsVideo?: boolean;
    };
    compaction_start: {
        messageCount: number;
    };
    compaction_end: {
        compacted: boolean;
        originalCount: number;
        newCount: number;
        selectionStrategy?: "query_aware" | "fallback";
        selectedMessages?: number;
        selectedTokens?: number;
        droppedMessages?: number;
        queryTerms?: number;
        selectionFallback?: string;
    };
    branch_created: {
        leafId: string;
        messagesKept: number;
    };
    user_input: {
        content: string;
    };
    slash_command: {
        name: string;
        args: string;
    };
}
type EventKey = keyof BusEventMap;
type EventHandler<K extends EventKey> = (payload: BusEventMap[K]) => void;
export declare class EventBus {
    private listeners;
    on<K extends EventKey>(event: K, handler: EventHandler<K>): () => void;
    off<K extends EventKey>(event: K, handler: EventHandler<K>): void;
    emit<K extends EventKey>(event: K, payload: BusEventMap[K]): void;
    once<K extends EventKey>(event: K, handler: EventHandler<K>): () => void;
    /** Remove all listeners, freeing closures that may retain large scopes. */
    removeAllListeners(): void;
    forwardAgentEvent(event: AgentEvent): void;
}
export {};
//# sourceMappingURL=event-bus.d.ts.map