/**
 * AgentController class that uses the agent-loop directly.
 * No transport abstraction - calls streamSimple via the loop.
 */
import { type ImageContent, type Model, type Transport } from '../ai/types.js';
import { AgentEngine, type AgentEngineOptions } from './agent-engine.js';
import type { AgentLoopEvent, AgentMessage, AgentState, ThinkingLevel, ToolDefinition } from './core-types.js';
export interface AgentControllerOptions {
    initialState?: Partial<AgentState>;
    runtime?: AgentEngine | AgentEngineOptions;
    /**
     * Steering mode: "all" = send all steering messages at once, "one-at-a-time" = one per turn
     */
    steeringMode?: 'all' | 'one-at-a-time';
    /**
     * Follow-up mode: "all" = send all follow-up messages at once, "one-at-a-time" = one per turn
     */
    followUpMode?: 'all' | 'one-at-a-time';
}
export declare class AgentController {
    private _state;
    private listeners;
    private _messageQueue;
    private _runState;
    private _runtime;
    constructor(opts?: AgentControllerOptions);
    get sessionId(): string | undefined;
    set sessionId(value: string | undefined);
    get transport(): Transport;
    setTransport(value: Transport): void;
    get maxRetryDelayMs(): number | undefined;
    set maxRetryDelayMs(value: number | undefined);
    get streamFn(): import("./core-types.js").StreamFn | undefined;
    set streamFn(value: import("./core-types.js").StreamFn | undefined);
    /**
     * Per-call speed mode. Set by the embedded runtime's submit() from
     * `AgentSubmitOptions.speed`; cleared after the run. Forwarded into
     * `AgentLoopConfig.speed` and read by the ShortcutXL stream impl as
     * the `speed` field on the proxy request body. See spec.md §7-A.
     */
    get speed(): 'fast' | 'standard' | undefined;
    set speed(value: 'fast' | 'standard' | undefined);
    get state(): AgentState;
    subscribe(fn: (e: AgentLoopEvent) => void): () => void;
    setSystemPrompt(v: string): void;
    setModel(m: Model<any>): void;
    setThinkingLevel(l: ThinkingLevel): void;
    setSteeringMode(mode: 'all' | 'one-at-a-time'): void;
    getSteeringMode(): 'all' | 'one-at-a-time';
    setFollowUpMode(mode: 'all' | 'one-at-a-time'): void;
    getFollowUpMode(): 'all' | 'one-at-a-time';
    setTools(t: ToolDefinition[]): void;
    replaceMessages(ms: AgentMessage[]): void;
    appendMessage(m: AgentMessage): void;
    /**
     * Queue a steering message to interrupt the agent mid-run.
     * Delivered after current tool execution, skips remaining tools.
     */
    steer(m: AgentMessage): void;
    /**
     * Queue a follow-up message to be processed after the agent finishes.
     * Delivered only when agent has no more tool calls or steering messages.
     */
    followUp(m: AgentMessage): void;
    clearSteeringQueue(): void;
    clearFollowUpQueue(): void;
    clearAllQueues(): void;
    hasQueuedMessages(): boolean;
    clearMessages(): void;
    abort(): void;
    waitForIdle(): Promise<void>;
    reset(): void;
    /** Send a prompt with an AgentMessage */
    prompt(message: AgentMessage | AgentMessage[]): Promise<void>;
    prompt(input: string, images?: ImageContent[]): Promise<void>;
    /**
     * Continue from current context (used for retries and resuming queued messages).
     */
    continue(): Promise<void>;
    private _executeTurn;
    private emit;
}
//# sourceMappingURL=agent-controller.d.ts.map