@wenathlan/devthink 2.0.14 → 2.0.19

package/dist/recovery.d.ts

@@ -1,621 +0,0 @@
-/**
- * @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