/**
 * Session recovery — resilience layer that wraps model calls with
 * context-overflow recovery, timeout backoff, and 5xx/overload fallback.
 *
 * Integrates with the existing model-fallback chain and provides an audit
 * trail for every recovery action taken.
 */
import type { Logger } from '../types';
export type RecoveryAction = 'compaction_retry' | 'timeout_backoff' | 'overload_backoff' | 'provider_fallback' | 'context_window_fallback';
export interface RecoveryEvent {
    timestamp: number;
    sessionId: string;
    action: RecoveryAction;
    model?: string;
    detail: string;
    success: boolean;
}
export interface SessionRecoveryPolicy {
    /** Maximum retries on context overflow (after compaction). Default: 2 */
    maxContextRetries: number;
    /** Maximum retries on timeout with exponential backoff. Default: 3 */
    maxTimeoutRetries: number;
    /** Initial backoff in ms for timeout retries. Default: 1000 */
    initialBackoffMs: number;
    /** Maximum backoff in ms. Default: 30000 */
    maxBackoffMs: number;
    /** Maximum retries on 5xx/overload. Default: 3 */
    maxOverloadRetries: number;
}
export interface RecoveryCallbacks {
    /** Called when context overflow is detected — should compact/prune and return true if recovery succeeded. */
    onContextOverflow?: () => Promise<boolean>;
    /** Called to log/audit recovery events. */
    onRecoveryEvent?: (event: RecoveryEvent) => void;
}
export declare class SessionRecoveryManager {
    private policy;
    private logger;
    private events;
    constructor(logger: Logger, policy?: Partial<SessionRecoveryPolicy>);
    /**
     * Get all recovery events recorded during this session.
     */
    getEvents(): readonly RecoveryEvent[];
    /**
     * Clear recorded events (e.g. on session reset).
     */
    clearEvents(): void;
    /**
     * Wrap a model call with recovery logic.
     *
     * The `execute` callback is called repeatedly with increasing delay on
     * transient failures. For context-overflow errors, `callbacks.onContextOverflow`
     * is called first to attempt in-place recovery (compaction/pruning).
     */
    withRecovery<T>(sessionId: string, modelId: string | undefined, execute: () => Promise<T>, callbacks?: RecoveryCallbacks): Promise<T>;
    private record;
}
//# sourceMappingURL=session-recovery.d.ts.map