@caupulican/pi-adaptative 0.81.2 → 0.81.4

package/dist/core/agent-session.js

@@ -1,21 +1,7 @@
-/**
- * AgentSession - Core abstraction for agent lifecycle and session management.
- *
- * This class is shared between all run modes (interactive, print, rpc).
- * It encapsulates:
- * - Agent state access
- * - Event subscription with automatic session persistence
- * - Model and thinking level management
- * - Compaction (manual and auto)
- * - Bash execution
- * - Session switching and branching
- *
- * Modes use this class and add their own I/O layer on top.
- */
 import { readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { classifyFailure, compactToolResultDetailsForRetention, computeRetryDelayMs, createCustomMessage, DEFAULT_RETRY_POLICY, RetryController, sleepAbortable, withStreamIdleWatchdog, } from "@caupulican/pi-agent-core";
-import { calculateContextTokens, compact, estimateContextTokens, getLatestCompactionEntry, prepareCompaction, shouldCompact, } from "@caupulican/pi-agent-core/node";
+import { calculateContextTokens, compact, createDeterministicCompaction, estimateContextTokens, getLatestCompactionEntry, prepareCompaction, runCompactionLoop, shouldCompact, } from "@caupulican/pi-agent-core/node";
 import { cleanupSessionResources, isContextOverflow, streamSimple } from "@caupulican/pi-ai";
 import { getAgentDir } from "../config.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
@@ -24,11 +10,13 @@ import { buildForegroundEnvelope, formatForegroundEnvelopeObservation } from "./
 import { AutonomyTelemetry } from "./autonomy-telemetry.js";
 import { BackgroundLaneController } from "./background-lane-controller.js";
 import { BashExecutionController } from "./bash-execution-controller.js";
+import { BillingFailoverController, ExhaustedProviderRegistry } from "./billing-failover-controller.js";
 import { CompactionSupport } from "./compaction-support.js";
 import { buildContextCompositionReport, formatContextCompositionDashboard, } from "./context/context-composition.js";
 import { ContextPipeline } from "./context-pipeline.js";
 import { downgradeReasoning, estimateTurnCostUsd, evaluateCostGuard } from "./cost-guard.js";
 import { appendWorkerResultSnapshot, getWorkerResultSnapshots } from "./delegation/session-worker-result.js";
+import { FailureCorpusRecorder } from "./failure-corpus.js";
 import { GatewayRegistry } from "./gateways/channel-provider.js";
 import { GoalLoopController } from "./goal-loop-controller.js";
 import { buildGoalRuntimeSnapshot, } from "./goals/goal-runtime-snapshot.js";
@@ -116,52 +104,34 @@ export class AgentSession {
     _unsubscribeAgent;
     _eventListeners = [];
     _extensionsChangedListeners = [];
-    /** Tracks pending steering messages for UI display. Removed when delivered. */
     _steeringMessages = [];
-    /** Tracks pending follow-up messages for UI display. Removed when delivered. */
     _followUpMessages = [];
-    /** Tracks extension slash commands queued while the agent is streaming. */
     _queuedExtensionCommands = [];
-    /** Messages queued to be included with the next user prompt as context ("asides"). */
     _pendingNextTurnMessages = [];
-    /** Serializes prompt() submissions made while streaming so queued steering/follow-ups keep user-typed FIFO order. */
     _streamingPromptSubmissionTail = Promise.resolve();
     /**
      * The last tool set requested via setActiveToolsByName BEFORE model-capability filtering, so
      * switching from a small-window model back to a large one restores the full requested set.
      */
     _requestedActiveToolNames;
-    // Compaction/context hygiene state
     _compactionAbortController = undefined;
     _autoCompactionAbortController = undefined;
     _overflowRecoveryAttempted = false;
     _unboundToolGrantWarnings = [];
-    // Branch summarization state
     _branchSummaryAbortController = undefined;
-    // Auto-retry driver — owns the attempt counter and abortable backoff (reliability kernel).
     _retryController;
-    // Bash execution state
-    /** User-facing model + thinking-level selection (see model-selection-controller.ts). */
     _modelSelection;
-    /** Standalone bash-command execution (see bash-execution-controller.ts); owns the bash abort
-     * controller and the streaming-deferred pending-message queue. */
     _bash;
-    /** Resource-profile tool/extension gating + reload-time profile model re-apply (see profile-filter-controller.ts). */
     _profileFilter;
-    /** Agent tool-call gate: escalation, autonomy gating, extension hooks, untrusted boundary (see tool-gate-controller.ts). */
     _toolGate;
-    // Extension system
     _extensionRunner;
     _turnIndex = 0;
-    /** G7: per-turn foreground CapabilityEnvelope auto-built for visibility (observe-only; not enforced). */
     _currentForegroundEnvelope;
     _resourceLoader;
     _customTools;
     _cwd;
     _agentDir;
     _collectWorkspaceSources;
-    /** Owns the cached per-server OllamaRuntime instances and the local-model router readiness gate
-     * (see local-runtime-controller.ts). */
     _localRuntimeController;
     /** Assembles the session's base system prompt from live session state (see
      * system-prompt-builder.ts); owns the paired _baseSystemPromptOptions. */
@@ -177,7 +147,6 @@ export class AgentSession {
      * latest retrieval/prompt-inclusion reports, the reload-safe MemoryManager, the recall
      * effectiveness tracker, and the extension-contributed pending providers. */
     _memory;
-    /** Summarizer model/auth/settings resolution (see compaction-support.ts). */
     _compactionSupport;
     /** Per-turn context-shaping subsystem (see context-pipeline.ts); owns the latest
      * audit/policy/correlation/enforcement/gc reports, the brain-curation sidecar + its skip reasons,
@@ -190,28 +159,22 @@ export class AgentSession {
     _toolProfileFilter;
     _isExplicitModel;
     _isExplicitThinking;
-    /** R8: registry for deployment-supplied gateway channels + schedulers (lifecycle driven by the host runner). */
     _gatewayRegistry = new GatewayRegistry();
-    /** Cache for getSpawnedUsage(), keyed by session entry count (Bug #22 — avoid O(N) per render frame). */
     /** Usage/cost/stats accounting, /context estimate, and session export (see session-analytics.ts);
      * owns the spawned-usage and daily-usage memo caches. */
     _analytics;
-    /** In-file session-tree branch switching + fork-selector reads (see session-tree-navigator.ts). */
     _treeNavigator;
-    /** Latest proactive cost-guard decision (#34), for the host UI to surface. Undefined when disabled. */
     _lastCostGuardDecision;
-    /** One-shot latch so the cost guard downgrades reasoning once per over-threshold episode, not every call. */
     _costGuardDowngraded = false;
     /** Per-turn model-router subsystem (see model-router-controller.ts); owns the transient route/intent,
      * the cheap-turn session buffer, the escalation/retry flags, and the sticky last-decision/skip-reason
      * used by the status report. Its parallel routed drive path delegates every turn back to
      * {@link _runAgentPrompt} so the drive loop stays host-side. */
     _modelRouter;
-    /** Lazily-built skill curator (#32) over `<agentDir>/skills`. */
+    _billingFailover;
+    _failureCorpus;
     _skillCuratorInstance;
-    /** Set on dispose so in-flight background reflection bails instead of writing to a dead session (Bug #21). */
     _disposed = false;
-    /** Aborts in-flight background reflection completions on dispose (Bug #21). */
     _reflectionAbort = new AbortController();
     /** Native reflection engine + learning-apply/rollback path (see reflection-controller.ts); owns no
      * session state, applies durable writes through the bundled memory tool and the session log. */
@@ -229,7 +192,6 @@ export class AgentSession {
     _extensionShutdownHandler;
     _extensionErrorListener;
     _extensionErrorUnsubscriber;
-    // Model registry for API key resolution
     _modelRegistry;
     /** Tool-registry assembly + the self-modification-safe extension reload (see runtime-builder.ts);
      * owns the base/wrapped tool definitions, the live tool registry, and the per-tool prompt
@@ -314,6 +276,7 @@ export class AgentSession {
             getLearningDecisionSnapshots: () => this.getLearningDecisionSnapshots(),
             getLearningAuditRecords: () => this.getLearningAuditRecords(),
         });
+        this._modelRegistry = config.modelRegistry;
         this._backgroundLanes = new BackgroundLaneController({
             isDisposed: () => this._disposed,
             isChildSession: () => this._isChildSession,
@@ -323,6 +286,7 @@ export class AgentSession {
             getSessionManager: () => this.sessionManager,
             getSettingsManager: () => this.settingsManager,
             getModelRegistry: () => this._modelRegistry,
+            isModelExhausted: (model) => this._billingFailover.isExhausted(`${model.provider}/${model.id}`),
             getModel: () => this.model ?? undefined,
             getCapabilityEnvelope: () => this.capabilityEnvelope,
             getModelCapabilityProfile: () => this.getModelCapabilityProfile(),
@@ -353,6 +317,12 @@ export class AgentSession {
             getModelRegistry: () => this._modelRegistry,
             isRawStream: () => this._isRawStreamSimple(this.agent.streamFn),
             getRequiredRequestAuth: (model) => this._getRequiredRequestAuth(model),
+            isModelExhausted: (ref) => this._billingFailover.isExhausted(ref),
+            getStoredFitnessReport: (ref) => this.getStoredFitnessReports().find((entry) => entry.model === ref)?.report,
+            // Live context is an over-estimate of the span to summarize (includes the kept tail) —
+            // conservative in the safe direction for the summarizer capacity check.
+            estimateSummarizationInputTokens: () => this._pipeline.estimateCurrentContextTokens(this.agent.state.messages),
+            emitWarning: (message) => this._emit({ type: "warning", message }),
         });
         this._pipeline = new ContextPipeline({
             getTurnIndex: () => this._turnIndex,
@@ -367,12 +337,25 @@ export class AgentSession {
             addSpawnedUsage: (usage, opts) => this.addSpawnedUsage(usage, opts),
             runIsolatedCompletion: (opts) => this.runIsolatedCompletion(opts),
         });
+        this._failureCorpus = new FailureCorpusRecorder({
+            filePath: join(this._agentDir, "state", "failure-corpus.jsonl"),
+        });
+        this._billingFailover = new BillingFailoverController({
+            agent: this.agent,
+            modelRegistry: this._modelRegistry,
+            exhausted: new ExhaustedProviderRegistry(),
+            subscriptionHop: this.settingsManager.getFailoverSettings().subscriptionHop,
+            emit: (event) => this._emit(event),
+            recordFailure: (args) => this._failureCorpus.record(args),
+        });
         this._modelRouter = new ModelRouterController({
             getAgent: () => this.agent,
             getModel: () => this.model ?? undefined,
             getSettingsManager: () => this.settingsManager,
             getSessionManager: () => this.sessionManager,
             getModelRegistry: () => this._modelRegistry,
+            isModelExhausted: (model) => this._billingFailover.isExhausted(`${model.provider}/${model.id}`),
+            getFailoverStatus: () => ({ ...this._billingFailover.getStatus(), failureStats: this._failureCorpus.stats() }),
             getAgentDir: () => this._agentDir,
             getReflectionSignal: () => this._reflectionAbort.signal,
             getBaseSystemPrompt: () => this._baseSystemPrompt,
@@ -407,7 +390,6 @@ export class AgentSession {
             getGoalRuntimeSnapshot: (settings) => this.getGoalRuntimeSnapshot(settings),
             prompt: (text, options) => this.prompt(text, options),
         });
-        this._modelRegistry = config.modelRegistry;
         this._extensionRunnerRef = config.extensionRunnerRef;
         this._initialActiveToolNames = config.initialActiveToolNames;
         this._allowedToolNames = config.allowedToolNames ? new Set(config.allowedToolNames) : undefined;
@@ -423,9 +405,11 @@ export class AgentSession {
         this._runtimeBuilder = new RuntimeBuilder({
             getAgent: () => this.agent,
             getCwd: () => this._cwd,
+            getAgentDir: () => this._agentDir,
             getSessionManager: () => this.sessionManager,
             getSettingsManager: () => this.settingsManager,
             getModelRegistry: () => this._modelRegistry,
+            isModelExhausted: (model) => this._billingFailover.isExhausted(`${model.provider}/${model.id}`),
             getResourceLoader: () => this._resourceLoader,
             getExtensionRunner: () => this._extensionRunner,
             setExtensionRunner: (runner) => {
@@ -1530,7 +1514,6 @@ export class AgentSession {
     async _ensureRouteModelReady(resolved) {
         return this._localRuntimeController.ensureRouteModelReady(resolved);
     }
-    /** Model-router status + config diagnostics report. Delegates to {@link ModelRouterController}. */
     getModelRouterStatus(formatLabel) {
         return this._modelRouter.getStatus(formatLabel);
     }
@@ -1543,6 +1526,8 @@ export class AgentSession {
         if (this._isRetryableError(msg) && (await this._prepareRetry(msg))) {
             return true;
         }
+        if (await this._billingFailover.handleAssistantError(msg))
+            return false;
         if (msg.stopReason === "error" && this._retryController.attempt > 0) {
             this._emit({
                 type: "auto_retry_end",
@@ -2190,7 +2175,7 @@ export class AgentSession {
             else {
                 // Generate compaction result
                 const compactionSignal = this._compactionAbortController.signal;
-                const result = await this._compactWithRetry(() => compact(preparation, compactionModel, apiKey, headers, customInstructions, compactionSignal, compactionThinkingLevel, this.agent.streamFn, this._buildCompactionPreDigest()), compactionSignal);
+                const result = await this._compactWithRetry(() => compact(preparation, compactionModel, apiKey, headers, customInstructions, compactionSignal, compactionThinkingLevel, this.agent.streamFn, this._buildCompactionPreDigest()), compactionSignal, compactionModel.provider);
                 summary = result.summary;
                 firstKeptEntryId = result.firstKeptEntryId;
                 tokensBefore = result.tokensBefore;
@@ -2388,10 +2373,16 @@ export class AgentSession {
      */
     async _runAutoCompaction(reason, willRetry) {
         const settings = this._getAdaptedCompactionSettings();
+        const model = this.model;
         this._emit({ type: "compaction_start", reason });
+        const hadQueuedMessages = this.agent.hasQueuedMessages();
         this._autoCompactionAbortController = new AbortController();
+        const signal = this._autoCompactionAbortController.signal;
+        let fromExtension = false;
+        let lastCompaction;
+        let extensionCancelled = false;
         try {
-            if (!this.model) {
+            if (!model) {
                 this._emit({
                     type: "compaction_end",
                     reason,
@@ -2402,113 +2393,107 @@ export class AgentSession {
                 });
                 return false;
             }
-            // Summarize with the configured/default compaction model. If its auth turns out unusable at
-            // request time (e.g. expired token), fall back to the session model — the one manual /compact
-            // demonstrably works with — before giving up.
-            const resolvedCompaction = await this._resolveCompactionModelAndAuth(this._resolveCompactionModel(this.model), this.model);
-            if (resolvedCompaction.failure) {
-                this._emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: false,
-                    willRetry: false,
-                    errorMessage: `Auto-compaction failed: ${resolvedCompaction.failure}`,
-                });
-                return false;
-            }
-            const compactionModel = resolvedCompaction.model;
-            const compactionThinkingLevel = this._resolveCompactionThinkingLevel(compactionModel, this.model);
-            const apiKey = resolvedCompaction.apiKey;
-            const headers = resolvedCompaction.headers;
-            const pathEntries = this.sessionManager.getBranch();
-            const preparation = prepareCompaction(pathEntries, settings);
-            if (!preparation) {
-                const lastEntry = pathEntries[pathEntries.length - 1];
+            const contextWindow = model.contextWindow;
+            const triggerThreshold = Math.max(0, contextWindow - settings.reserveTokens);
+            const margin = Math.max(0, Math.floor(0.01 * contextWindow));
+            let measureReads = 0;
+            const outcome = await runCompactionLoop({
+                getBranch: () => this.sessionManager.getBranch(),
+                measureLiveTokens: () => {
+                    const measured = this._pipeline.estimateCurrentContextTokens(this.agent.state.messages);
+                    return measureReads++ === 0 ? Math.max(measured, triggerThreshold + 1) : measured;
+                },
+                getTriggerThreshold: () => triggerThreshold,
+                getMargin: () => margin,
+                getBaseKeepRecentTokens: () => settings.keepRecentTokens,
+                resolveModelAndAuth: async (modelTier) => this._resolveCompactionModelAndAuth(modelTier === "session" ? model : this._resolveCompactionModel(model), model),
+                summarizeAndVerify: async (params, compactModel, apiKey, headers, branchEntries) => {
+                    fromExtension = false;
+                    const adaptedSettings = { ...settings, keepRecentTokens: params.keepRecentTokens };
+                    const preparation = prepareCompaction(branchEntries, adaptedSettings);
+                    if (!preparation) {
+                        throw new Error("already compacted");
+                    }
+                    const compactionThinkingLevel = this._resolveCompactionThinkingLevel(compactModel, model);
+                    if (this._extensionRunner.hasHandlers("session_before_compact")) {
+                        const extensionResult = (await this._extensionRunner.emit({
+                            type: "session_before_compact",
+                            preparation,
+                            branchEntries,
+                            customInstructions: undefined,
+                            signal,
+                        }));
+                        if (extensionResult?.cancel) {
+                            extensionCancelled = true;
+                            throw new Error("auto-compaction-cancelled");
+                        }
+                        if (extensionResult?.compaction) {
+                            fromExtension = true;
+                            return { result: extensionResult.compaction };
+                        }
+                    }
+                    const compactResult = await this._compactWithRetry(() => compact(preparation, compactModel, apiKey, headers, undefined, signal, compactionThinkingLevel, this.agent.streamFn, this._buildCompactionPreDigest(), { chunked: params.chunked }), signal, compactModel.provider);
+                    return { result: compactResult };
+                },
+                buildDeterministicCheckpoint: async () => {
+                    const branch = this.sessionManager.getBranch();
+                    const preparation = prepareCompaction(branch, {
+                        ...settings,
+                    });
+                    if (!preparation) {
+                        throw new Error("already compacted");
+                    }
+                    fromExtension = false;
+                    return { result: createDeterministicCompaction(preparation) };
+                },
+                apply: async (result) => {
+                    lastCompaction = result;
+                    this.sessionManager.appendCompaction(result.summary, result.firstKeptEntryId, result.tokensBefore, result.details, fromExtension);
+                    this.agent.state.messages = this.sessionManager.buildSessionContext().messages;
+                    const newEntries = this.sessionManager.getEntries();
+                    const savedCompactionEntry = newEntries.find((entry) => entry.type === "compaction" && entry.summary === result.summary);
+                    if (this._extensionRunner && savedCompactionEntry) {
+                        await this._extensionRunner.emit({
+                            type: "session_compact",
+                            compactionEntry: savedCompactionEntry,
+                            fromExtension,
+                        });
+                    }
+                },
+                onTransition: ({ cycle, cause }) => {
+                    this._emit({
+                        type: "warning",
+                        message: `auto-compaction cycle ${cycle}: ${cause} — retrying from step 0`,
+                    });
+                },
+                signal,
+            });
+            if (outcome.kind === "skip") {
                 this._emit({
                     type: "compaction_end",
                     reason,
                     result: undefined,
                     aborted: false,
                     willRetry: false,
-                    skipReason: lastEntry?.type === "compaction" ? "already compacted" : "nothing to compact (session too small)",
+                    skipReason: outcome.reason,
                 });
-                return false;
+                return hadQueuedMessages || this.agent.hasQueuedMessages();
             }
-            let extensionCompaction;
-            let fromExtension = false;
-            if (this._extensionRunner.hasHandlers("session_before_compact")) {
-                const extensionResult = (await this._extensionRunner.emit({
-                    type: "session_before_compact",
-                    preparation,
-                    branchEntries: pathEntries,
-                    customInstructions: undefined,
-                    signal: this._autoCompactionAbortController.signal,
-                }));
-                if (extensionResult?.cancel) {
-                    this._emit({
-                        type: "compaction_end",
-                        reason,
-                        result: undefined,
-                        aborted: true,
-                        willRetry: false,
-                    });
+            if (outcome.kind === "failed") {
+                if (outcome.reason === "aborted") {
+                    this._emit({ type: "compaction_end", reason, result: undefined, aborted: true, willRetry: false });
                     return false;
                 }
-                if (extensionResult?.compaction) {
-                    extensionCompaction = extensionResult.compaction;
-                    fromExtension = true;
-                }
+                throw new Error(outcome.reason);
             }
-            let summary;
-            let firstKeptEntryId;
-            let tokensBefore;
-            let details;
-            if (extensionCompaction) {
-                // Extension provided compaction content
-                summary = extensionCompaction.summary;
-                firstKeptEntryId = extensionCompaction.firstKeptEntryId;
-                tokensBefore = extensionCompaction.tokensBefore;
-                details = extensionCompaction.details;
-            }
-            else {
-                // Generate compaction result
-                const autoCompactionSignal = this._autoCompactionAbortController.signal;
-                const compactResult = await this._compactWithRetry(() => compact(preparation, compactionModel, apiKey, headers, undefined, autoCompactionSignal, compactionThinkingLevel, this.agent.streamFn, this._buildCompactionPreDigest()), autoCompactionSignal);
-                summary = compactResult.summary;
-                firstKeptEntryId = compactResult.firstKeptEntryId;
-                tokensBefore = compactResult.tokensBefore;
-                details = compactResult.details;
-            }
-            if (this._autoCompactionAbortController.signal.aborted) {
-                this._emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: true,
-                    willRetry: false,
-                });
+            if (extensionCancelled || signal.aborted) {
+                this._emit({ type: "compaction_end", reason, result: undefined, aborted: true, willRetry: false });
                 return false;
             }
-            this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension);
-            const newEntries = this.sessionManager.getEntries();
-            const sessionContext = this.sessionManager.buildSessionContext();
-            this.agent.state.messages = sessionContext.messages;
-            // Get the saved compaction entry for the extension event
-            const savedCompactionEntry = newEntries.find((e) => e.type === "compaction" && e.summary === summary);
-            if (this._extensionRunner && savedCompactionEntry) {
-                await this._extensionRunner.emit({
-                    type: "session_compact",
-                    compactionEntry: savedCompactionEntry,
-                    fromExtension,
-                });
+            const result = outcome.kind === "success" ? outcome.result : lastCompaction;
+            if (!result) {
+                throw new Error("Auto-compaction succeeded without a result");
             }
-            const result = {
-                summary,
-                firstKeptEntryId,
-                tokensBefore,
-                details,
-            };
             this._emit({ type: "compaction_end", reason, result, aborted: false, willRetry });
             if (willRetry) {
                 const messages = this.agent.state.messages;
@@ -2518,9 +2503,7 @@ export class AgentSession {
                 }
                 return true;
             }
-            // Auto-compaction can complete while follow-up/steering/custom messages are waiting.
-            // Continue once so queued messages are delivered.
-            return this.agent.hasQueuedMessages();
+            return hadQueuedMessages || this.agent.hasQueuedMessages();
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
@@ -2548,7 +2531,7 @@ export class AgentSession {
      * same failure via auto-retry. Caller aborts are never retried; sleepAbortable rejects
      * with the abort reason if the signal fires mid-backoff.
      */
-    async _compactWithRetry(run, signal) {
+    async _compactWithRetry(run, signal, provider) {
         const retrySettings = this.settingsManager.getRetrySettings();
         const maxAttempts = retrySettings.enabled ? Math.max(1, retrySettings.maxRetries + 1) : 1;
         const policy = {
@@ -2565,7 +2548,8 @@ export class AgentSession {
                 if (signal.aborted || attempt >= maxAttempts)
                     throw error;
                 const message = error instanceof Error ? error.message : String(error);
-                const classified = classifyFailure({ message });
+                const classified = classifyFailure({ message, provider });
+                this._failureCorpus.record({ provider, message, classified });
                 if (!classified.retryable)
                     throw error;
                 await sleepAbortable(computeRetryDelayMs(policy, attempt, { retryAfterMs: classified.retryAfterMs }), signal);
@@ -2851,10 +2835,18 @@ export class AgentSession {
         if (message.stopReason !== "error" || !message.errorMessage)
             return false;
         const contextWindow = this.model?.contextWindow ?? 0;
-        return classifyFailure({
+        const classified = classifyFailure({
             message: message.errorMessage,
             contextOverflow: isContextOverflow(message, contextWindow),
-        }).retryable;
+            provider: message.provider,
+        });
+        this._failureCorpus.record({
+            provider: message.provider,
+            modelId: message.model,
+            message: message.errorMessage,
+            classified,
+        });
+        return classified.retryable;
     }
     /**
      * Prepare a retryable error for continuation with exponential backoff.