import type { AgentSession } from "../../core/agent-session.ts";
import { AgentSessionRuntime, type CreateAgentSessionRuntimeFactory } from "../../core/agent-session-runtime.ts";
import type { RpcClient } from "../rpc/rpc-client.ts";
import type { RpcExtensionUIRequest, RpcExtensionUIResponse } from "../rpc/rpc-types.ts";
import type { RpcSlashCommand } from "../rpc/rpc-types.ts";
import type { ActivityWatchdogDiagnostic } from "./activity-watchdog.ts";
import type { EngineKeybindingState, InteractiveEngineCommand, InteractiveEngineMessage } from "./protocol.ts";
import { type RemoteCommandsListener } from "./remote-command-catalog.ts";
export declare class IsolatedInteractiveRuntime extends AgentSessionRuntime {
    private readonly client;
    private readonly patchedSessions;
    private streaming;
    private compacting;
    private bashRunning;
    private steeringMessages;
    private followUpMessages;
    private engineCallbackActive;
    private readonly diagnosticListeners;
    private remoteModels;
    private remoteScopedModels;
    private pendingDiagnostics;
    private lastDiagnostic;
    private autoCompactionEnabled;
    private autoRetryEnabled;
    private remoteSessionName;
    private remoteSessionFile;
    private restartPromise;
    private readonly remoteCommands;
    constructor(localRuntime: AgentSessionRuntime, createRuntime: CreateAgentSessionRuntimeFactory, client: RpcClient);
    get session(): AgentSession;
    initializeFromEngine(): Promise<void>;
    onDiagnostic(listener: (diagnostic: ActivityWatchdogDiagnostic) => void): () => void;
    onEngineMessage(listener: (message: InteractiveEngineMessage) => void): () => void;
    onKeybindingState(listener: (state: EngineKeybindingState) => void): () => void;
    sendEngineCommand(command: InteractiveEngineCommand): void;
    getRemoteCommands(): readonly RpcSlashCommand[];
    onRemoteCommandsChanged(listener: RemoteCommandsListener): () => void;
    invokeRemoteShortcut(key: string): Promise<void>;
    waitUntilBound(): Promise<void>;
    getEnginePid(): number | undefined;
    getEngineGeneration(): number;
    isRecovering(): boolean;
    synchronize(): Promise<void>;
    setEngineCallbackActive(active: boolean): void;
    interruptBlockedCallback(): boolean;
    setExtensionUIHandler(handler: (request: RpcExtensionUIRequest) => Promise<RpcExtensionUIResponse | undefined>): () => void;
    emitDiagnostic(diagnostic: ActivityWatchdogDiagnostic): void;
    switchSession(sessionPath: string): Promise<{
        cancelled: boolean;
    }>;
    newSession(options?: {
        parentSession?: string;
    }): Promise<{
        cancelled: boolean;
    }>;
    importFromJsonl(inputPath: string, cwdOverride?: string): Promise<{
        cancelled: boolean;
    }>;
    fork(entryId: string, options?: {
        position?: "before" | "at";
    }): Promise<{
        cancelled: boolean;
        selectedText?: string;
    }>;
    dispose(): Promise<void>;
    private patchSession;
    private abortAndRecover;
    private dispatchBestEffort;
    private resetUnpersistedSessionView;
    private patchSessionManager;
    private refreshSessionView;
    private patchModelCatalog;
    private observeEvent;
}
//# sourceMappingURL=isolated-runtime.d.ts.map