@wenathlan/devthink 2.0.12 → 2.0.14

package/dist/recovery.d.ts

@@ -0,0 +1,621 @@
+/**
+ * @fileoverview recovery.ts - ONDA 4 - Plugin Core (merged)
+ * @module auth/recovery
+ * @description Complete production-ready auto-recovery engine for the
+ *              provider plugin with Gemini CLI bypass.
+ *
+ *              Responsibilities:
+ *              - Internal LRU cache for thinking signatures (avoids revalidation
+ *                and preserves integrity)
+ *              - Error detectors: invalid thinking block signature, tool_use
+ *                without thinking, session boundary, tool failures
+ *              - Recovery strategies: continue, undo guidance, keep_thinking
+ *                preservation and injection of preserved thinking across turns
+ *              - Detection utilities, recovery plan building, transform helpers
+ *              - withAutoRecovery wrapper with exponential backoff + jitter
+ *              - Simple context-based API ported from the v4/v5 lineage:
+ *                RecoveryContext, getRecoveryStrategy, module-level signature
+ *                preservation cache, buildRecoveryMessage,
+ *                transformMessagesForRecovery, recoverToolResultMissing /
+ *                recoverThinkingOrder / recoverThinkingDisabled,
+ *                contextErrorRecovery, sessionRecovery, toast integration
+ *
+ *              Zero external dependencies: only node:* builtins + global fetch.
+ *              Compatible with Models 2026 and the official Gemini CLI spoof.
+ *
+ * @author ONDA 4 - Plugin Core
+ * @license MIT
+ * @since 2026
+ */
+import { GEMINI_CLI_OAUTH_CLIENT_ID as GEMINI_CLI_CLIENT_ID, GEMINI_CLI_OAUTH_CLIENT_SECRET as GEMINI_CLI_CLIENT_SECRET, PROJECT_FALLBACK } from "./constants.js";
+export { GEMINI_CLI_CLIENT_ID, GEMINI_CLI_CLIENT_SECRET, PROJECT_FALLBACK };
+/**
+ * Client-Metadata header string for the Gemini CLI bypass. v2.1.16: the local
+ * literal was byte-identical to constants.CLIENT_METADATA_STRING
+ * ("ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI")
+ * — the export now aliases the owner constant so the value has one source.
+ */
+export declare const X_CLIENT_METADATA_RAW: "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI";
+import { MODELS_2026_LEGACY as MODELS_2026 } from "./models.js";
+import type { ModelId2026 } from "./models.js";
+import { fnv1a32 } from "./core.js";
+export { MODELS_2026 };
+export type { ModelId2026 };
+export type Role = "user" | "assistant" | "system" | "tool";
+export interface ThinkingBlock {
+    type: "thinking";
+    thinking: string;
+    signature?: string;
+    redacted_thinking?: string;
+    _preserved?: boolean;
+    _injected?: boolean;
+}
+export interface TextBlock {
+    type: "text";
+    text: string;
+}
+export interface ToolUseBlock {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: unknown;
+    _missingThinking?: boolean;
+}
+export interface ToolResultBlock {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string | Array<{
+        type: string;
+        text?: string;
+    }>;
+    is_error?: boolean;
+}
+export type ContentBlock = ThinkingBlock | TextBlock | ToolUseBlock | ToolResultBlock | Record<string, unknown>;
+export interface ChatMessage {
+    role: Role;
+    content: string | ContentBlock[];
+    _sessionId?: string;
+    _timestamp?: number;
+}
+export type ChatMessages = ChatMessage[];
+export type RecoveryErrorCode = "INVALID_THINKING_SIGNATURE" | "TOOL_USE_WITHOUT_THINKING" | "SESSION_BOUNDARY" | "TOOL_FAILURE" | "CONTEXT_OVERFLOW" | "RATE_LIMIT" | "UNKNOWN";
+export interface DetectedError {
+    code: RecoveryErrorCode;
+    message: string;
+    details?: Record<string, unknown>;
+    recoverable: boolean;
+    index?: number;
+    blockIndex?: number;
+}
+export interface DetectionReport {
+    errors: DetectedError[];
+    hasInvalidSignature: boolean;
+    hasMissingThinking: boolean;
+    hasSessionBoundary: boolean;
+    hasToolFailure: boolean;
+    shouldRecover: boolean;
+}
+export type RecoveryStrategy = "STRIP_INVALID_SIGNATURE" | "INJECT_PRESERVED_THINKING" | "KEEP_THINKING_PRESERVE" | "CONTINUE_RESUME" | "UNDO_GUIDANCE" | "RETRY_WITH_BACKOFF" | "REBUILD_MESSAGES" | "RESET_THINKING_CACHE";
+export interface RecoveryAction {
+    strategy: RecoveryStrategy;
+    reason: string;
+    priority: number;
+    payload?: Record<string, unknown>;
+}
+export interface RecoveryPlan {
+    id: string;
+    createdAt: number;
+    errors: DetectedError[];
+    actions: RecoveryAction[];
+    transformedMessages?: ChatMessages;
+    keepThinking?: string | null;
+    preservedSignature?: string | null;
+    shouldRetry: boolean;
+    retryDelayMs?: number;
+    metadata?: Record<string, unknown>;
+}
+export type ExecutorFn<T = unknown> = (messages: ChatMessages, opts?: {
+    signal?: AbortSignal | undefined;
+    attempt?: number | undefined;
+    plan?: RecoveryPlan | undefined;
+}) => Promise<T>;
+export interface AutoRecoveryOptions {
+    maxAttempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    jitter?: boolean;
+    failFastOnNonRecoverable?: boolean;
+    modelId?: ModelId2026 | string;
+    sessionId?: string;
+    preservationStore?: ThinkingPreservationStore;
+    signatureCache?: ThinkingSignatureCache;
+    onRecoveryAttempt?: (attempt: number, plan: RecoveryPlan, delayMs: number) => void;
+    onDetectedErrors?: (report: DetectionReport) => void;
+    signal?: AbortSignal;
+    logger?: Pick<Console, "debug" | "info" | "warn" | "error">;
+}
+/**
+ * Zero-dependency, production-ready generic LRUCache.
+ * - O(1) get/set through an ordered Map
+ * - Automatic LRU eviction
+ * - Stats for observability
+ */
+export declare class LRUCache<K, V> {
+    private readonly capacity;
+    private readonly cache;
+    private hits;
+    private misses;
+    private evictions;
+    constructor(capacity: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    get size(): number;
+    get cap(): number;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    toArray(): Array<[K, V]>;
+    toMRUArray(): Array<[K, V]>;
+    stats(): {
+        size: number;
+        capacity: number;
+        hits: number;
+        misses: number;
+        evictions: number;
+        hitRate: number;
+    };
+}
+export interface ThinkingSignatureEntry {
+    signature: string;
+    thinkingHash: string;
+    thinkingPreview: string;
+    modelId: string;
+    createdAt: number;
+    lastUsedAt: number;
+    useCount: number;
+    valid: boolean;
+    length: number;
+}
+export declare function hashThinkingContent(thinking: string): string;
+export declare function isBase64ishSig(sig: string): boolean;
+export declare function isValidThinkingSignature(signature: unknown): boolean;
+export declare class ThinkingSignatureCache {
+    private readonly lru;
+    private readonly hashToSig;
+    constructor(capacity?: number);
+    /**
+     * Stores a valid signature associated with thinking content.
+     */
+    store(thinking: string, signature: string, modelId?: string): ThinkingSignatureEntry | null;
+    getBySignature(signature: string): ThinkingSignatureEntry | undefined;
+    getByThinking(thinking: string): ThinkingSignatureEntry | undefined;
+    getByHash(hash: string): ThinkingSignatureEntry | undefined;
+    hasValid(thinking: string, signature: string): boolean;
+    /**
+     * Tries to recover a valid signature for preserved thinking content.
+     */
+    tryRestore(thinking: string): string | null;
+    invalidate(signature: string): void;
+    sweepInvalid(): number;
+    size(): number;
+    stats(): {
+        size: number;
+        capacity: number;
+        hits: number;
+        misses: number;
+        evictions: number;
+        hitRate: number;
+    };
+    clear(): void;
+    recentValidSignatures(limit?: number): ThinkingSignatureEntry[];
+}
+export declare function getGlobalSignatureCache(): ThinkingSignatureCache;
+export declare function resetGlobalSignatureCache(): void;
+export interface PreservedThinking {
+    id: string;
+    sessionId: string;
+    thinking: string;
+    signature: string | null;
+    modelId: string;
+    messageIndex: number;
+    createdAt: number;
+    lastInjectedAt?: number;
+    injectCount: number;
+}
+export declare class ThinkingPreservationStore {
+    private readonly store;
+    private readonly history;
+    constructor(capacity?: number);
+    preserve(sessionId: string, thinking: string, signature: string | null, modelId: string, messageIndex: number): PreservedThinking;
+    get(sessionId: string): PreservedThinking | undefined;
+    getHistory(sessionId: string): PreservedThinking[];
+    markInjected(sessionId: string): void;
+    clear(sessionId?: string): void;
+    /**
+     * Returns the latest injectable thinking entry, when one exists.
+     */
+    getInjectable(sessionId: string): PreservedThinking | null;
+}
+export declare function getGlobalPreservationStore(): ThinkingPreservationStore;
+export declare function resetGlobalPreservationStore(): void;
+export declare const DETECTOR_PATTERNS: {
+    invalidSignature: RegExp[];
+    missingThinkingForToolUse: RegExp[];
+    sessionBoundary: RegExp[];
+    toolFailure: RegExp[];
+    contextOverflow: RegExp[];
+    rateLimit: RegExp[];
+};
+/**
+ * Detector: thinking block carrying an invalid signature
+ */
+export declare function detectInvalidSignatureBlocks(messages: ChatMessages): DetectedError[];
+/**
+ * Detector: tool_use without preceding thinking while thinking mode is active
+ */
+export declare function detectToolUseWithoutThinking(messages: ChatMessages, modelId?: string): DetectedError[];
+/**
+ * Detector: session boundary / context overflow derived from error and messages
+ */
+export declare function detectSessionBoundary(error: unknown, messages?: ChatMessages): DetectedError[];
+/**
+ * Detector: tool_result failures flagged with is_error
+ */
+export declare function detectToolFailures(messages: ChatMessages): DetectedError[];
+/**
+ * Detector: raw API error (HTTP / JSON) mentioning an invalid signature
+ */
+export declare function detectInvalidSignatureFromError(error: unknown): DetectedError[];
+/**
+ * Complete detection orchestrator
+ */
+export declare function detectAllErrors(error: unknown, messages: ChatMessages, modelId?: string): DetectionReport;
+export interface BuildPlanOptions {
+    sessionId?: string;
+    modelId?: string;
+    preservationStore?: ThinkingPreservationStore;
+    signatureCache?: ThinkingSignatureCache;
+    messages: ChatMessages;
+}
+export declare function buildRecoveryPlan(report: DetectionReport, opts: BuildPlanOptions): RecoveryPlan;
+export declare function cloneMessages(messages: ChatMessages): ChatMessages;
+/**
+ * Removes thinking blocks carrying invalid signatures.
+ * Restores from cache when possible; otherwise strips the block.
+ */
+export declare function stripInvalidSignatures(messages: ChatMessages, signatureCache?: ThinkingSignatureCache): {
+    messages: ChatMessages;
+    removedCount: number;
+    restoredCount: number;
+};
+/**
+ * Guarantees every assistant message with tool_use has preceding thinking.
+ * Injects preserved thinking, or a minimal synthetic block, when missing.
+ */
+export declare function ensureThinkingBeforeToolUse(messages: ChatMessages, preservedThinking: string | null, preservedSignature: string | null, opts?: {
+    syntheticFallback?: boolean;
+    modelId?: string;
+}): {
+    messages: ChatMessages;
+    injectedCount: number;
+};
+/**
+ * Injects preserved thinking across turns (keep_thinking strategy).
+ * Never overwrites existing assistant thinking - only preserves it.
+ */
+export declare function injectPreservedThinking(messages: ChatMessages, preserved: PreservedThinking | null, signatureCache?: ThinkingSignatureCache): {
+    messages: ChatMessages;
+    injected: boolean;
+};
+/**
+ * "continue" message for session-boundary recovery.
+ * Tuned for the Gemini CLI bypass - keeps the ideType UNSPECIFIED fingerprint.
+ */
+export declare function buildContinueMessage(opts?: {
+    sessionId?: string | undefined;
+    modelId?: string | undefined;
+    truncatedCount?: number | undefined;
+    includePreserved?: boolean | undefined;
+}): ChatMessage;
+/**
+ * Undo-guidance message emitted when a tool fails.
+ */
+export declare function buildUndoGuidanceMessage(failures: DetectedError[], opts?: {
+    sessionId?: string;
+}): ChatMessage;
+/**
+ * Compacting rebuild for session boundary / context overflow.
+ * Keeps the system prompt, the last N messages, and a mid-history summary.
+ */
+export declare function rebuildMessagesCompacted(messages: ChatMessages, opts?: {
+    keepLast?: number;
+    keepSystem?: boolean;
+}): {
+    messages: ChatMessages;
+    compactedCount: number;
+};
+/**
+ * Master retry transformer - applies a recovery plan.
+ */
+export declare function transformMessagesForRetry(originalMessages: ChatMessages, plan: RecoveryPlan, opts?: {
+    sessionId?: string;
+    signatureCache?: ThinkingSignatureCache;
+    preservationStore?: ThinkingPreservationStore;
+}): ChatMessages;
+export declare function preserveThinkingFromMessages(messages: ChatMessages, opts: {
+    sessionId: string;
+    modelId: string;
+    signatureCache?: ThinkingSignatureCache;
+    preservationStore?: ThinkingPreservationStore;
+}): number;
+export declare function preserveThinkingFromResponse(response: unknown, opts: {
+    sessionId: string;
+    modelId: string;
+    signatureCache?: ThinkingSignatureCache;
+    preservationStore?: ThinkingPreservationStore;
+}): number;
+export declare function exponentialBackoff(attempt: number, baseMs: number, maxMs: number, jitter: boolean): number;
+export declare function sleepMs(ms: number, signal?: AbortSignal): Promise<void>;
+export declare class AutoRecoveryExhaustedError extends Error {
+    readonly attempts: number;
+    readonly lastPlan?: RecoveryPlan | undefined;
+    readonly lastError: unknown;
+    constructor(message: string, lastError: unknown, attempts: number, lastPlan?: RecoveryPlan);
+}
+/**
+ * Wrapper principal com auto-recovery completo.
+ *
+ * Flow:
+ *  1. Executes the executor with the original messages
+ *  2. On error or invalid response, runs the detectors
+ *  3. When recoverable, builds a RecoveryPlan, transforms messages, backs off, retries
+ *  4. Preserves valid thinking after success (keep_thinking)
+ *
+ * Zero-dep, apenas node:* + fetch global.
+ *
+ * @example
+ * const result = await withAutoRecovery(
+ *   async (msgs) => callAntigravity(msgs),
+ *   originalMessages,
+ *   { maxAttempts: 4, modelId: "antigravity-claude-opus-4-6-thinking", sessionId: "sess_123" }
+ * );
+ */
+export declare function withAutoRecovery<T>(executor: ExecutorFn<T>, messages: ChatMessages, opts?: AutoRecoveryOptions): Promise<T>;
+export interface RecoveryFacadeOptions {
+    sessionId: string;
+    modelId: string;
+    maxAttempts?: number;
+}
+/**
+ * Builds a preconfigured wrapper for the provider plugin.
+ * Comes wired with the global LRU caches and preservation store.
+ */
+export declare function createRecoveryFacade(opts: RecoveryFacadeOptions): {
+    signatureCache: ThinkingSignatureCache;
+    preservationStore: ThinkingPreservationStore;
+    /**
+     * Detects errors in the current messages (without executing)
+     */
+    detect(messages: ChatMessages, error?: unknown): DetectionReport;
+    /**
+     * Builds a plan without executing.
+     */
+    plan(report: DetectionReport, messages: ChatMessages): RecoveryPlan;
+    /**
+     * Transforms messages according to a plan.
+     */
+    transform(messages: ChatMessages, plan: RecoveryPlan): ChatMessages;
+    /**
+     * Executes with auto-recovery.
+     */
+    exec<T>(executor: ExecutorFn<T>, messages: ChatMessages, extra?: Partial<AutoRecoveryOptions>): Promise<T>;
+    /**
+     * Preserves thinking manually.
+     */
+    preserve(messages: ChatMessages): number;
+    clear(): void;
+};
+export declare function buildUserPromptIdShort(input: string, seed?: string): string;
+export declare function buildSessionIdFromCwd(cwd?: string): string;
+export declare const RecoveryConstants: {
+    readonly GEMINI_CLI_CLIENT_ID: string;
+    readonly GEMINI_CLI_CLIENT_SECRET: string;
+    readonly GEMINI_CLI_USER_AGENT: "GeminiCLI/0.57.0 (linux; x64; GitHub) google-api-nodejs-client/9.15.1";
+    readonly X_GOOG_API_CLIENT: "gl-node/22.19.0";
+    readonly X_CLIENT_METADATA_RAW: "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI";
+    readonly PROJECT_FALLBACK: "rising-fact-p41fc";
+    readonly MODELS_2026: readonly ["antigravity-gemini-3-pro", "antigravity-gemini-3.1-pro", "antigravity-gemini-3-flash", "antigravity-claude-sonnet-4-6", "antigravity-claude-opus-4-6-thinking", "gemini-2.5-flash", "gemini-2.5-pro", "gemini-3-flash-preview", "gemini-3-pro-preview", "gemini-3.1-pro-preview", "gemini-3.1-pro-preview-customtools"];
+    readonly DETECTOR_PATTERNS: {
+        invalidSignature: RegExp[];
+        missingThinkingForToolUse: RegExp[];
+        sessionBoundary: RegExp[];
+        toolFailure: RegExp[];
+        contextOverflow: RegExp[];
+        rateLimit: RegExp[];
+    };
+};
+export declare const Recovery: {
+    readonly LRUCache: typeof LRUCache;
+    readonly ThinkingSignatureCache: typeof ThinkingSignatureCache;
+    readonly getGlobalSignatureCache: typeof getGlobalSignatureCache;
+    readonly resetGlobalSignatureCache: typeof resetGlobalSignatureCache;
+    readonly ThinkingPreservationStore: typeof ThinkingPreservationStore;
+    readonly getGlobalPreservationStore: typeof getGlobalPreservationStore;
+    readonly resetGlobalPreservationStore: typeof resetGlobalPreservationStore;
+    readonly isValidThinkingSignature: typeof isValidThinkingSignature;
+    readonly isBase64ishSig: typeof isBase64ishSig;
+    readonly hashThinkingContent: typeof hashThinkingContent;
+    readonly fnv1a32: typeof fnv1a32;
+    readonly detectInvalidSignatureBlocks: typeof detectInvalidSignatureBlocks;
+    readonly detectToolUseWithoutThinking: typeof detectToolUseWithoutThinking;
+    readonly detectSessionBoundary: typeof detectSessionBoundary;
+    readonly detectToolFailures: typeof detectToolFailures;
+    readonly detectInvalidSignatureFromError: typeof detectInvalidSignatureFromError;
+    readonly detectAllErrors: typeof detectAllErrors;
+    readonly DETECTOR_PATTERNS: {
+        invalidSignature: RegExp[];
+        missingThinkingForToolUse: RegExp[];
+        sessionBoundary: RegExp[];
+        toolFailure: RegExp[];
+        contextOverflow: RegExp[];
+        rateLimit: RegExp[];
+    };
+    readonly buildRecoveryPlan: typeof buildRecoveryPlan;
+    readonly cloneMessages: typeof cloneMessages;
+    readonly stripInvalidSignatures: typeof stripInvalidSignatures;
+    readonly ensureThinkingBeforeToolUse: typeof ensureThinkingBeforeToolUse;
+    readonly injectPreservedThinking: typeof injectPreservedThinking;
+    readonly buildContinueMessage: typeof buildContinueMessage;
+    readonly buildUndoGuidanceMessage: typeof buildUndoGuidanceMessage;
+    readonly rebuildMessagesCompacted: typeof rebuildMessagesCompacted;
+    readonly transformMessagesForRetry: typeof transformMessagesForRetry;
+    readonly preserveThinkingFromMessages: typeof preserveThinkingFromMessages;
+    readonly preserveThinkingFromResponse: typeof preserveThinkingFromResponse;
+    readonly exponentialBackoff: typeof exponentialBackoff;
+    readonly sleepMs: typeof sleepMs;
+    readonly withAutoRecovery: typeof withAutoRecovery;
+    readonly AutoRecoveryExhaustedError: typeof AutoRecoveryExhaustedError;
+    readonly createRecoveryFacade: typeof createRecoveryFacade;
+    readonly detectErrorType: typeof detectErrorType;
+    readonly detectError: typeof detectError;
+    readonly isRecoverable: typeof isRecoverable;
+    readonly getRecoveryStrategy: typeof getRecoveryStrategy;
+    readonly preserveThinkingSignature: typeof preserveThinkingSignature;
+    readonly getPreservedSignature: typeof getPreservedSignature;
+    readonly buildRecoveryMessage: typeof buildRecoveryMessage;
+    readonly transformMessagesForRecovery: typeof transformMessagesForRecovery;
+    readonly withAutoRecoverySimple: typeof withAutoRecoverySimple;
+    readonly recoverToolResultMissing: typeof recoverToolResultMissing;
+    readonly recoverThinkingOrder: typeof recoverThinkingOrder;
+    readonly recoverThinkingDisabled: typeof recoverThinkingDisabled;
+    readonly sessionRecovery: typeof sessionRecovery;
+    readonly contextErrorRecovery: typeof contextErrorRecovery;
+    readonly toast: typeof toast;
+    readonly buildUserPromptIdShort: typeof buildUserPromptIdShort;
+    readonly buildSessionIdFromCwd: typeof buildSessionIdFromCwd;
+    readonly RecoveryConstants: {
+        readonly GEMINI_CLI_CLIENT_ID: string;
+        readonly GEMINI_CLI_CLIENT_SECRET: string;
+        readonly GEMINI_CLI_USER_AGENT: "GeminiCLI/0.57.0 (linux; x64; GitHub) google-api-nodejs-client/9.15.1";
+        readonly X_GOOG_API_CLIENT: "gl-node/22.19.0";
+        readonly X_CLIENT_METADATA_RAW: "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI";
+        readonly PROJECT_FALLBACK: "rising-fact-p41fc";
+        readonly MODELS_2026: readonly ["antigravity-gemini-3-pro", "antigravity-gemini-3.1-pro", "antigravity-gemini-3-flash", "antigravity-claude-sonnet-4-6", "antigravity-claude-opus-4-6-thinking", "gemini-2.5-flash", "gemini-2.5-pro", "gemini-3-flash-preview", "gemini-3-pro-preview", "gemini-3.1-pro-preview", "gemini-3.1-pro-preview-customtools"];
+        readonly DETECTOR_PATTERNS: {
+            invalidSignature: RegExp[];
+            missingThinkingForToolUse: RegExp[];
+            sessionBoundary: RegExp[];
+            toolFailure: RegExp[];
+            contextOverflow: RegExp[];
+            rateLimit: RegExp[];
+        };
+    };
+};
+export default Recovery;
+/**
+ * Coarse error taxonomy used by the simple recovery API. Extends the v4/v5
+ * union with the "session_boundary" and "tool_failure" kinds from the v2/v3
+ * lineage so every historical value remains representable.
+ */
+export type RecoveryErrorType = "invalid_thinking_signature" | "tool_use_without_thinking" | "session_boundary" | "tool_failure" | "tool_result_missing" | "thinking_block_order" | "thinking_disabled_violation" | "prompt_too_long" | "tool_pairing" | "unknown";
+/** Legacy alias kept for source compatibility with the v4/v5 exports. */
+export type errorType = RecoveryErrorType;
+/** Context passed through the simple recovery helpers. */
+export type RecoveryContext = {
+    errorType: RecoveryErrorType;
+    message: string;
+    lastThinking?: {
+        text: string;
+        signature?: string;
+    };
+    toolUseId?: string;
+    sessionId?: string;
+};
+/** Strategy returned by getRecoveryStrategy (lowercase taxonomy of the lineage). */
+export type SimpleRecoveryStrategy = "continue" | "undo_guidance" | "keep_thinking" | "inject_preserved";
+/**
+ * Classifies an thrown error into a RecoveryErrorType using message matching.
+ */
+export declare function detectErrorType(err: any, _lastPayload?: any): RecoveryErrorType;
+/**
+ * String-based detector from the v4/v5 lineage (used by plugin integrations).
+ */
+export declare function detectError(msg: string): RecoveryErrorType;
+/** Reports whether an error type can be recovered automatically. */
+export declare function isRecoverable(t: RecoveryErrorType): boolean;
+/**
+ * Maps an error type onto the simple strategy taxonomy.
+ */
+export declare function getRecoveryStrategy(errorType: RecoveryErrorType): SimpleRecoveryStrategy;
+/**
+ * Module-level preservation: stores a thinking signature keyed by a hash of
+ * the first 200 chars of the thinking text.
+ */
+export declare function preserveThinkingSignature(thinkingText: string, signature: string): void;
+/**
+ * Recovers a previously preserved signature for the given thinking text.
+ */
+export declare function getPreservedSignature(thinkingText: string): string | undefined;
+/**
+ * Builds a human-readable auto-recovery message for a recovery context.
+ */
+export declare function buildRecoveryMessage(ctx: RecoveryContext): string;
+/**
+ * Transforms messages according to the strategy derived from the context.
+ * Loose typing on purpose: operates on arbitrary provider message shapes.
+ */
+export declare function transformMessagesForRecovery(messages: any[], ctx: RecoveryContext): any[];
+/**
+ * Retry wrapper variant from the v4/v5 lineage: callback receives only the
+ * attempt number, retries use exponential backoff plus 0-80ms jitter, and
+ * non-recoverable error types abort early after the first attempt.
+ */
+export declare function withAutoRecoverySimple<T>(fn: (attempt: number) => Promise<T>, maxRetries?: number): Promise<T>;
+/**
+ * Hardening pass: injects empty tool results for missing tool_use pairs.
+ * Heuristic kept intentionally conservative - returns a shallow copy.
+ */
+export declare function recoverToolResultMissing(messages: any[]): any[];
+/**
+ * Ensures thinking blocks appear before text by splitting combined messages
+ * into ordered parts: [{thought:true,...},{text}].
+ */
+export declare function recoverThinkingOrder(messages: any[]): any[];
+/** Strips thinking fields when thinking is disabled server-side. */
+export declare function recoverThinkingDisabled(messages: any[]): any[];
+/**
+ * Session-level recovery dispatcher used by plugin integrations.
+ */
+export declare function sessionRecovery(error: RecoveryErrorType, messages: any[]): any[];
+/**
+ * Human-readable guidance for context-related errors
+ * ("prompt_too_long", "tool_pairing").
+ */
+export declare function contextErrorRecovery(error: RecoveryErrorType): string;
+/** Registers a custom toast sink; pass null to restore the default. */
+export declare function setToastSink(sink: ((msg: string) => void) | null): void;
+/** Emits a toast-style notification for recovery events. */
+export declare function toast(msg: string): void;
+/**
+ * Classifies an error into a coarse recoverable type:
+ * quota | auth | signature | network | unknown.
+ */
+export declare function detectFetchErrorType(e: any): string;
+/**
+ * Rebuilds messages for one recovery retry: strips invalid thinking signatures
+ * (restoring valid ones from the recovery cache when possible).
+ */
+export declare function fetchSessionRecovery(errType: string, messages?: any[]): any[];
+/**
+ * Persists a validated thinking signature into the recovery module caches
+ * (global LRU signature cache + per-session preservation store) so later
+ * retries can re-inject reasoning before tool_use blocks.
+ */
+export declare function preserveValidatedSignature(thinking: string, signature: string, ctx?: {
+    sessionId?: string;
+    modelId?: string;
+}): void;
+//# sourceMappingURL=recovery.d.ts.map