import type { ProviderChildHealthSnapshot } from '../../shared/snapshot.js';
import { ActiveRuntimeRun } from './active-runtime.js';
import { type RunningChildProcess } from './child-process.js';
import { ProviderControllerSlot } from './controller-slot.js';
import { type AgentRuntime, type AgentRuntimeCloseOptions, type AgentRuntimeDrainInput, type AgentRuntimeFollowupInput, type AgentRuntimeFollowupResult, type AgentRuntimeHealth, type AgentRuntimeInput, type AgentRuntimeResult } from './contract.js';
interface ControllerAgentRuntimeOptions {
    providerChildIdleTimeoutMs?: number;
}
export interface ProviderTurnController {
    completion: Promise<unknown>;
    acceptStderrChunk(chunk: string): Promise<void>;
    acceptStdoutChunk(chunk: string): Promise<void>;
    isQuiescent?(): boolean;
    kill(signal?: NodeJS.Signals): void;
    snapshot(): ProviderChildHealthSnapshot;
    waitForQuiescent(signal?: AbortSignal): Promise<void>;
}
export declare abstract class ControllerAgentRuntime<C extends ProviderTurnController> implements AgentRuntime {
    private readonly options;
    abstract readonly env: Record<string, string> | undefined;
    abstract readonly kind: string;
    protected readonly slot: ProviderControllerSlot<C>;
    protected readonly activeRun: ActiveRuntimeRun;
    private providerChildIdleReset?;
    private providerChildQuiescentWait?;
    constructor(options?: ControllerAgentRuntimeOptions);
    abstract run(input: AgentRuntimeInput): Promise<AgentRuntimeResult>;
    abstract appendToActiveRun(input: AgentRuntimeFollowupInput): Promise<AgentRuntimeFollowupResult>;
    close(options?: AgentRuntimeCloseOptions): Promise<void>;
    health(): AgentRuntimeHealth;
    requestDrain(input: AgentRuntimeDrainInput): Promise<void>;
    /**
     * Only controllers that implement `isQuiescent` (Claude background tasks)
     * participate in config-reload quiescence. Others return `undefined` so the
     * host keeps active-item-only reload deferral.
     */
    isProviderQuiescent(): boolean | undefined;
    waitForProviderQuiescent(signal?: AbortSignal): Promise<void>;
    protected spawnController(spawn: {
        args: string[];
        command: string;
        label: string;
    }, input: AgentRuntimeInput, create: (child: RunningChildProcess) => C): C;
    protected runTurnLifecycle(input: AgentRuntimeInput, options: {
        abort?(signal?: NodeJS.Signals): Promise<void> | void;
        beforeFinishRun?(): void;
        failurePayload?(error: unknown): Promise<Record<string, unknown>>;
        label: string;
        startedPayload: Record<string, unknown>;
        turn(): Promise<AgentRuntimeResult>;
    }): Promise<AgentRuntimeResult>;
    private cancelProviderChildIdleReset;
    private scheduleProviderChildIdleReset;
}
export {};
//# sourceMappingURL=provider-runtime.d.ts.map