@caupulican/pi-adaptative 0.81.2 → 0.81.3

package/dist/core/agent-session.js

@@ -15,7 +15,7 @@
 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,6 +24,7 @@ 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";
@@ -116,52 +117,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 +160,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 +172,21 @@ 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;
     _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 +204,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 +288,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 +298,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(),
@@ -367,12 +343,21 @@ export class AgentSession {
             addSpawnedUsage: (usage, opts) => this.addSpawnedUsage(usage, opts),
             runIsolatedCompletion: (opts) => this.runIsolatedCompletion(opts),
         });
+        this._billingFailover = new BillingFailoverController({
+            agent: this.agent,
+            modelRegistry: this._modelRegistry,
+            exhausted: new ExhaustedProviderRegistry(),
+            subscriptionHop: this.settingsManager.getFailoverSettings().subscriptionHop,
+            emit: (event) => this._emit(event),
+        });
         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(),
             getAgentDir: () => this._agentDir,
             getReflectionSignal: () => this._reflectionAbort.signal,
             getBaseSystemPrompt: () => this._baseSystemPrompt,
@@ -407,7 +392,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 +407,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 +1516,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 +1528,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 +2177,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 +2375,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 +2395,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 +2505,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 +2533,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 +2550,7 @@ 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 });
                 if (!classified.retryable)
                     throw error;
                 await sleepAbortable(computeRetryDelayMs(policy, attempt, { retryAfterMs: classified.retryAfterMs }), signal);
@@ -2854,6 +2839,7 @@ export class AgentSession {
         return classifyFailure({
             message: message.errorMessage,
             contextOverflow: isContextOverflow(message, contextWindow),
+            provider: message.provider,
         }).retryable;
     }
     /**