import { OmpRpcFrameDecoder, type OmpRpcCommand } from './rpc-protocol';
import { createOmpRpcEventState } from './rpc-events';
import type { OmpSessionLaunch } from './rpc-session';
import type { CommandSpec, OutputEvent } from '../types';
export interface OmpRpcSpawnEvidence {
    readonly pid: number;
    readonly processGroupId: number | null;
    readonly terminationStrategy: 'process-group' | 'process-tree';
}
export interface OmpRpcSessionEvidence {
    readonly phase: 'ready' | 'terminal';
    readonly sessionId: string | null;
    readonly sessionFile: string | null;
    readonly selectedProvider: string;
    readonly selectedModel: string;
    readonly thinkingLevel: string;
}
export interface OmpRpcTaskRequest {
    readonly commandSpec: CommandSpec;
    readonly prompt: string;
    readonly expectedVersion: string;
    readonly session: OmpSessionLaunch;
    readonly signal: AbortSignal;
    readonly timeoutMs: number;
    readonly abortGraceMs: number;
    readonly exitGraceMs: number;
}
export interface OmpRpcTaskHooks {
    readonly onSpawn: (evidence: OmpRpcSpawnEvidence) => Promise<void>;
    readonly onEvent: (event: OutputEvent) => Promise<void>;
    readonly onSession: (evidence: OmpRpcSessionEvidence) => Promise<void>;
}
export interface OmpRpcTaskResult {
    readonly events: readonly OutputEvent[];
    readonly text: string;
    readonly session: OmpRpcSessionEvidence;
    readonly stopReason: string;
    readonly exitCode: number | null;
    readonly signal: string | null;
}
export declare const UNKNOWN_SESSION_EVIDENCE: Omit<OmpRpcSessionEvidence, 'phase'>;
type UiResponder = (id: string) => OmpRpcCommand;
export declare const UI_RESPONDERS: Readonly<Record<string, UiResponder>>;
export declare class OmpRpcTaskFailure extends Error {
    readonly stopReason: string;
    constructor(stopReason: string, message: string);
}
export interface PendingCommand {
    readonly resolve: (frame: Record<string, unknown>) => void;
    readonly reject: (error: Error) => void;
}
export interface DriverState {
    readonly decoder: OmpRpcFrameDecoder;
    readonly eventState: ReturnType<typeof createOmpRpcEventState>;
    readonly pending: Map<string, PendingCommand>;
    readonly lifetimeRequestIds: Set<string>;
    queuedFrames: number;
    readonly events: OutputEvent[];
    readonly textParts: string[];
    stderrTail: string;
    negotiatedV2: boolean;
    readyReceived: boolean;
    promptSent: boolean;
    terminal: boolean;
    settled: boolean;
    abortStopReason: string | null;
    pendingStopReason: string | null;
    terminationStarted: boolean;
    sessionEvidence: Omit<OmpRpcSessionEvidence, 'phase'>;
    processExit: {
        exitCode: number | null;
        signal: string | null;
    } | null;
    chain: Promise<void>;
}
export declare function createDriverState(): DriverState;
export declare function sessionFieldsFromRecord(record: Record<string, unknown>): Partial<Pick<OmpRpcSessionEvidence, 'sessionId' | 'sessionFile'>>;
export declare function sessionEvidenceFromState(stateResponse: Record<string, unknown> | null): Omit<OmpRpcSessionEvidence, 'phase'>;
export {};
//# sourceMappingURL=rpc-driver-state.d.ts.map