@caupulican/pi-adaptative 0.81.4 → 0.81.6

package/dist/core/agent-session.js

@@ -589,6 +589,19 @@ export class AgentSession {
     _resolveCompactionModel(sessionModel) {
         return this._compactionSupport.resolveModel(sessionModel);
     }
+    /**
+     * One bounded diagnostic clause for compaction retry warnings: which summarizer selection won
+     * (and why) plus the input-size estimate the capacity check consumed — the two facts every
+     * gate-failure post-mortem has needed (2026-07-06 field incidents).
+     */
+    _describeCompactionSummarizer() {
+        const reason = this._compactionSupport.getLastSelectionReason() ?? "unresolved";
+        const estimate = this._pipeline.estimateCurrentContextTokens(this.agent.state.messages);
+        return `summarizer: ${reason}, ~${Math.ceil(estimate / 1000)}k est input`;
+    }
+    _getLastCompactionSelectionReason() {
+        return this._compactionSupport.getLastSelectionReason();
+    }
     _resolveCompactionThinkingLevel(compactionModel, sessionModel) {
         return this._compactionSupport.resolveThinkingLevel(this.thinkingLevel, compactionModel, sessionModel);
     }
@@ -1523,10 +1536,19 @@ export class AgentSession {
         if (!msg) {
             return false;
         }
-        if (this._isRetryableError(msg) && (await this._prepareRetry(msg))) {
+        const classified = this._classifyAssistantError(msg);
+        if (classified) {
+            this._failureCorpus.record({
+                provider: msg.provider,
+                modelId: msg.model,
+                message: msg.errorMessage ?? "",
+                classified,
+            });
+        }
+        if (classified?.retryable && (await this._prepareRetry(msg))) {
             return true;
         }
-        if (await this._billingFailover.handleAssistantError(msg))
+        if (await this._billingFailover.handleAssistantError(msg, classified))
             return false;
         if (msg.stopReason === "error" && this._retryController.attempt > 0) {
             this._emit({
@@ -2129,15 +2151,17 @@ export class AgentSession {
             if (!this.model) {
                 throw new Error(formatNoModelSelectedMessage());
             }
-            const compactionModel = this._resolveCompactionModel(this.model);
-            const compactionThinkingLevel = this._resolveCompactionThinkingLevel(compactionModel, this.model);
-            const { apiKey, headers } = await this._getCompactionRequestAuth(compactionModel);
-            const pathEntries = this.sessionManager.getBranch();
+            const sessionModel = this.model;
+            const selectedCompactionModel = this._resolveCompactionModel(sessionModel);
+            if (this._isRawStreamSimple(this.agent.streamFn)) {
+                await this._getCompactionRequestAuth(selectedCompactionModel);
+            }
+            const selectionReason = this._getLastCompactionSelectionReason() ?? "unknown";
             const settings = this._getAdaptedCompactionSettings();
-            const preparation = prepareCompaction(pathEntries, settings);
-            if (!preparation) {
-                // Check why we can't compact
-                const lastEntry = pathEntries[pathEntries.length - 1];
+            const initialBranch = this.sessionManager.getBranch();
+            const initialPreparation = prepareCompaction(initialBranch, settings);
+            if (!initialPreparation) {
+                const lastEntry = initialBranch[initialBranch.length - 1];
                 if (lastEntry?.type === "compaction") {
                     throw new Error("Already compacted");
                 }
@@ -2148,69 +2172,108 @@ export class AgentSession {
             if (this._extensionRunner.hasHandlers("session_before_compact")) {
                 const result = (await this._extensionRunner.emit({
                     type: "session_before_compact",
-                    preparation,
-                    branchEntries: pathEntries,
+                    preparation: initialPreparation,
+                    branchEntries: initialBranch,
                     customInstructions,
                     signal: this._compactionAbortController.signal,
                 }));
-                if (result?.cancel) {
+                if (result?.cancel)
                     throw new Error("Compaction cancelled");
-                }
                 if (result?.compaction) {
                     extensionCompaction = result.compaction;
                     fromExtension = true;
                 }
             }
-            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 compactionSignal = this._compactionAbortController.signal;
-                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;
-                details = result.details;
-            }
-            if (this._compactionAbortController.signal.aborted) {
-                throw new Error("Compaction cancelled");
-            }
-            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,
+                this.sessionManager.appendCompaction(extensionCompaction.summary, extensionCompaction.firstKeptEntryId, extensionCompaction.tokensBefore, extensionCompaction.details, true);
+                this.agent.state.messages = this.sessionManager.buildSessionContext().messages;
+                const savedCompactionEntry = this.sessionManager
+                    .getEntries()
+                    .find((entry) => entry.type === "compaction" && entry.summary === extensionCompaction.summary);
+                if (this._extensionRunner && savedCompactionEntry) {
+                    await this._extensionRunner.emit({
+                        type: "session_compact",
+                        compactionEntry: savedCompactionEntry,
+                        fromExtension: true,
+                    });
+                }
+                this._emit({
+                    type: "compaction_end",
+                    reason: "manual",
+                    result: extensionCompaction,
+                    aborted: false,
+                    willRetry: false,
                 });
+                return extensionCompaction;
             }
-            const compactionResult = {
-                summary,
-                firstKeptEntryId,
-                tokensBefore,
-                details,
-            };
+            let appliedResult;
+            const signal = this._compactionAbortController.signal;
+            const outcome = await runCompactionLoop({
+                measureLiveTokens: () => Math.max(this._estimateCurrentContextTokens(this.agent.state.messages), 1),
+                getTriggerThreshold: () => 0,
+                getMargin: () => 0,
+                getBranch: () => this.sessionManager.getBranch(),
+                getBaseKeepRecentTokens: () => settings.keepRecentTokens,
+                resolveModelAndAuth: async (modelTier) => {
+                    const model = modelTier === "cheap" ? selectedCompactionModel : sessionModel;
+                    const { apiKey, headers } = await this._resolveCompactionModelAndAuth(model, sessionModel);
+                    return { model, apiKey, headers };
+                },
+                summarizeAndVerify: async (params, model, apiKey, headers, branch) => {
+                    const preparation = prepareCompaction(branch, {
+                        ...settings,
+                        keepRecentTokens: params.keepRecentTokens,
+                    }, { allowTrailingCompactionAsPrevious: true });
+                    if (!preparation)
+                        throw new Error("Nothing to compact (session too small)");
+                    if (extensionCompaction)
+                        return { result: extensionCompaction };
+                    const compactionThinkingLevel = this._resolveCompactionThinkingLevel(model, sessionModel);
+                    const result = await this._compactWithRetry(() => compact(preparation, model, apiKey, headers, customInstructions, signal, compactionThinkingLevel, this.agent.streamFn, this._buildCompactionPreDigest(), { chunked: params.chunked }), signal, model.provider);
+                    return { result };
+                },
+                buildDeterministicCheckpoint: () => ({ result: createDeterministicCompaction(initialPreparation) }),
+                apply: async (result) => {
+                    if (signal.aborted)
+                        throw new Error("Compaction cancelled");
+                    this.sessionManager.appendCompaction(result.summary, result.firstKeptEntryId, result.tokensBefore, result.details, fromExtension);
+                    this.agent.state.messages = this.sessionManager.buildSessionContext().messages;
+                    const savedCompactionEntry = this.sessionManager
+                        .getEntries()
+                        .find((entry) => entry.type === "compaction" && entry.summary === result.summary);
+                    if (this._extensionRunner && savedCompactionEntry) {
+                        await this._extensionRunner.emit({
+                            type: "session_compact",
+                            compactionEntry: savedCompactionEntry,
+                            fromExtension,
+                        });
+                    }
+                    appliedResult = result;
+                },
+                verifyPostApplyEffect: () => false,
+                onTransition: ({ cycle, cause }) => {
+                    this._emit({
+                        type: "warning",
+                        message: `manual compaction cycle ${cycle}: ${cause} — retrying from step 0 (${this._describeCompactionSummarizer()})`,
+                    });
+                },
+                signal,
+            });
+            if (outcome.kind === "failed") {
+                if (outcome.reason === "aborted")
+                    throw new Error("Compaction cancelled");
+                throw new Error(`manual compaction failed after retry ladder using ${selectedCompactionModel.provider}/${selectedCompactionModel.id} (${selectionReason}); first failure: ${outcome.reason}`);
+            }
+            if (outcome.kind === "skip" || !appliedResult)
+                throw new Error(outcome.kind === "skip" ? outcome.reason : "Compaction failed");
             this._emit({
                 type: "compaction_end",
                 reason: "manual",
-                result: compactionResult,
+                result: appliedResult,
                 aborted: false,
                 willRetry: false,
             });
-            return compactionResult;
+            return appliedResult;
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -2463,7 +2526,7 @@ export class AgentSession {
                 onTransition: ({ cycle, cause }) => {
                     this._emit({
                         type: "warning",
-                        message: `auto-compaction cycle ${cycle}: ${cause} — retrying from step 0`,
+                        message: `auto-compaction cycle ${cycle}: ${cause} — retrying from step 0 (${this._describeCompactionSummarizer()})`,
                     });
                 },
                 signal,
@@ -2831,22 +2894,18 @@ export class AgentSession {
      * are terminal; context overflow is handled by compaction, not retry. The verdict comes from the
      * reliability kernel's classifier, fed the host-computed context-overflow flag.
      */
-    _isRetryableError(message) {
+    _classifyAssistantError(message) {
         if (message.stopReason !== "error" || !message.errorMessage)
-            return false;
+            return undefined;
         const contextWindow = this.model?.contextWindow ?? 0;
-        const classified = classifyFailure({
+        return classifyFailure({
             message: message.errorMessage,
             contextOverflow: isContextOverflow(message, contextWindow),
             provider: message.provider,
         });
-        this._failureCorpus.record({
-            provider: message.provider,
-            modelId: message.model,
-            message: message.errorMessage,
-            classified,
-        });
-        return classified.retryable;
+    }
+    _isRetryableError(message) {
+        return this._classifyAssistantError(message)?.retryable ?? false;
     }
     /**
      * Prepare a retryable error for continuation with exponential backoff.