/**
 * Auto-retry controller for AgentSession.
 *
 * Owns the retry lifecycle for transient assistant errors (overloaded, rate
 * limit, server/network/transport failures): deciding whether an error is
 * retryable, arming the retry promise synchronously on agent_end, backing off
 * exponentially, and re-driving the agent via continue(). Context-overflow
 * errors are intentionally excluded here — those are handled by compaction.
 */
import type { AgentEvent, AgentMessage } from "@kolisachint/hoocode-agent-core";
import type { AssistantMessage, Model } from "@kolisachint/hoocode-ai";
import type { AgentSessionEvent } from "./agent-session.js";
/** Narrow dependencies the retry controller needs from AgentSession. */
export interface AutoRetryDeps {
    getRetrySettings(): {
        enabled: boolean;
        maxRetries: number;
        baseDelayMs: number;
    };
    getModel(): Model<any> | undefined;
    getAgentMessages(): AgentMessage[];
    setAgentMessages(messages: AgentMessage[]): void;
    /** Fire-and-forget continue() on the agent (errors surface on the next agent_end). */
    continueAgent(): void;
    waitForAgentIdle(): Promise<void>;
    emit(event: AgentSessionEvent): void;
}
export declare class AutoRetryController {
    private readonly deps;
    private _abortController;
    private _attempt;
    private _promise;
    private _resolve;
    constructor(deps: AutoRetryDeps);
    /** Current retry attempt (0 if not retrying) */
    get attempt(): number;
    /** Whether a retry is currently in progress */
    get isRetrying(): boolean;
    /**
     * Check if an error is retryable (overloaded, rate limit, server errors).
     * Context overflow errors are NOT retryable (handled by compaction instead).
     */
    isRetryableError(message: AssistantMessage): boolean;
    /**
     * Create the retry promise synchronously when an agent_end carries a
     * retryable error. Agent.emit() runs handlers synchronously and prompt()
     * calls waitForRetry() as soon as agent.prompt() resolves; arming the promise
     * here (rather than inside async event processing) ensures waitForRetry()
     * never misses an in-flight retry.
     */
    createPromiseForAgentEnd(event: AgentEvent): void;
    private _findLastAssistantInMessages;
    /**
     * Reset the attempt counter after a successful assistant response.
     * Callers invoke this only for non-error responses; it emits a success event
     * when a retry was in progress.
     */
    onSuccessfulAssistantResponse(): void;
    /** Resolve the pending retry promise */
    resolve(): void;
    /**
     * Handle retryable errors with exponential backoff.
     * @returns true if retry was initiated, false if max retries exceeded or disabled
     */
    handleRetryableError(message: AssistantMessage): Promise<boolean>;
    /**
     * Cancel in-progress retry.
     */
    abort(): void;
    /**
     * Wait for any in-progress retry to complete.
     * Returns immediately if no retry is in progress.
     */
    waitForRetry(): Promise<void>;
}
//# sourceMappingURL=agent-session-retry.d.ts.map