@dreb/coding-agent 2.64.3 → 2.64.4

package/dist/core/agent-session.js

@@ -95,6 +95,10 @@ export class AgentSession {
     // Compaction state
     _compactionAbortController = undefined;
     _autoCompactionAbortController = undefined;
+    /** The in-flight auto-compaction run (any start path), if any. */
+    _autoCompactionInFlight = undefined;
+    /** Serializes auto-compaction checks so two never run concurrently. */
+    _autoCompactionChain = Promise.resolve();
     _overflowRecoveryAttempted = false;
     // Branch summarization state
     _branchSummaryAbortController = undefined;
@@ -234,6 +238,7 @@ export class AgentSession {
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
         this._installAgentToolHooks();
         this._installBackgroundAgentGuardrails();
+        this._installMidTurnCompactionHook();
         this._buildRuntime({
             activeToolNames: this._initialActiveToolNames,
             includeAllExtensionTools: true,
@@ -546,6 +551,64 @@ export class AgentSession {
             return true;
         });
     }
+    /** Install the settled pre-request hook used for mid-turn compaction. */
+    _installMidTurnCompactionHook() {
+        this.agent.setBeforeLlmCall((context, signal) => this._prepareForLlmCall(context, signal));
+    }
+    /**
+     * Compact between tool-loop requests without starting a second Agent loop.
+     * Session persistence is asynchronous, so wait for prior message events before
+     * preparing a summary from the current branch.
+     */
+    async _prepareForLlmCall(context, signal) {
+        await this._agentEventQueue.catch(() => undefined);
+        if (signal?.aborted)
+            return undefined;
+        const loopTail = context.messages[context.messages.length - 1];
+        if (loopTail?.role !== "user" && loopTail?.role !== "toolResult") {
+            return undefined;
+        }
+        const messages = this.agent.state.messages;
+        const lastMessage = messages[messages.length - 1];
+        if (lastMessage?.role !== "user" && lastMessage?.role !== "toolResult") {
+            return undefined;
+        }
+        const settings = this.settingsManager.getCompactionSettings();
+        let contextWindow = this.model?.contextWindow ?? 0;
+        const estimate = estimateContextTokens(messages);
+        let contextTokens = estimate.tokens;
+        // A retained assistant message can still carry pre-compaction usage. For the
+        // first request after compaction, estimate the rebuilt context from message
+        // content instead of reusing that stale high-water mark.
+        const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
+        if (compactionEntry && estimate.lastUsageIndex !== null) {
+            const usageMessage = messages[estimate.lastUsageIndex];
+            if (usageMessage.role === "assistant" &&
+                usageMessage.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
+                contextTokens = messages.reduce((total, message) => total + estimateTokens(message), 0);
+            }
+        }
+        // Preserve K3's tier behavior at the new mid-turn check. If the tier changes,
+        // the hook result refreshes the active loop model before its next request.
+        if (shouldUpgradeK3Tier(this.model, contextTokens)) {
+            const userCompactPoint = K3_256K_CONTEXT_WINDOW - settings.reserveTokens;
+            const userThresholdPreempts = settings.enabled && userCompactPoint < K3_UPGRADE_CUTOFF_TOKENS && contextTokens > userCompactPoint;
+            if (!userThresholdPreempts) {
+                this._tryUpgradeK3ContextTier();
+                contextWindow = this.model?.contextWindow ?? contextWindow;
+            }
+        }
+        if (!shouldCompact(contextTokens, contextWindow, settings)) {
+            return this.model ? { model: this.model } : undefined;
+        }
+        // `willRetry: true` tells event consumers that another request is imminent;
+        // `requestWillFollow` prevents a re-entrant agent.continue() call.
+        await this._trackAutoCompaction("threshold", true, true);
+        return {
+            messages: this.agent.state.messages,
+            ...(this.model ? { model: this.model } : {}),
+        };
+    }
     /**
      * Reset the background-agent guardrail counter and the pause-notified flag together.
      * These two fields are one logical unit — they must always reset in lockstep so a new
@@ -1039,8 +1102,9 @@ export class AgentSession {
         this._unsubscribeGuardrailSentinel = undefined;
         this._unsubscribeGuardrailCounter?.();
         this._unsubscribeGuardrailCounter = undefined;
-        // Clear the shouldContinue callback so the agent doesn't hold a reference to a disposed session
+        // Clear callbacks so the agent doesn't hold a reference to a disconnected session.
         this.agent.setShouldContinue(undefined);
+        this.agent.setBeforeLlmCall(undefined);
     }
     /**
      * Reconnect to agent events after _disconnectFromAgent().
@@ -1051,6 +1115,7 @@ export class AgentSession {
             return; // Already connected
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
         this._installBackgroundAgentGuardrails();
+        this._installMidTurnCompactionHook();
     }
     /**
      * Remove all listeners and disconnect from agent.
@@ -1348,10 +1413,12 @@ export class AgentSession {
             throw new Error(`No API key found for ${this.model.provider}.\n\n` +
                 `Use /login or set an API key environment variable. See ${join(getDocsPath(), "providers.md")}`);
         }
-        // Check if we need to compact before sending (catches aborted responses)
+        // Check if we need to compact before sending (catches aborted responses).
+        // The prompt below is already the next request, so compaction must not
+        // schedule a competing agent.continue().
         const lastAssistant = this._findLastAssistantMessage();
         if (lastAssistant) {
-            await this._checkCompaction(lastAssistant, false);
+            await this._checkCompaction(lastAssistant, false, true);
         }
         // Build messages array (custom message if any, then user message)
         const messages = [];
@@ -2087,10 +2154,43 @@ export class AgentSession {
      * 1. Overflow: LLM returned context overflow error, remove error message from agent state, compact, auto-retry
      * 2. Threshold: Context over threshold, compact, NO auto-retry (user continues manually)
      *
+     * Checks run on a serialization chain: a check that arrives while another
+     * check's compaction is still in flight (e.g. a prompt submitted during an
+     * agent_end compaction) waits for it, then evaluates instead of starting a
+     * competing compaction. If an earlier queued check compacted or rebuilt
+     * context first, the captured message is pre-compaction and the
+     * pre-compaction staleness guard inside _doCheckCompaction skips it.
+     *
+     * @param assistantMessage The assistant message to check
+     * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
+     * @param requestWillFollow Whether the caller will issue the next request without agent.continue().
+     */
+    _checkCompaction(assistantMessage, skipAbortedCheck = true, requestWillFollow = false) {
+        const work = async () => {
+            // A run started outside this chain (the mid-turn hook) may still
+            // be in flight; wait for it before evaluating.
+            if (this._autoCompactionInFlight) {
+                await this._autoCompactionInFlight.catch(() => undefined);
+            }
+            await this._doCheckCompaction(assistantMessage, skipAbortedCheck, requestWillFollow);
+        };
+        const run = this._autoCompactionChain.then(work);
+        this._autoCompactionChain = run.catch(() => undefined);
+        return run;
+    }
+    /**
+     * Evaluate compaction needs and run a tracked compaction if warranted.
+     * Runs inside the _checkCompaction serialization chain.
+     *
+     * Two cases:
+     * 1. Overflow: LLM returned context overflow error, remove error message from agent state, compact, auto-retry
+     * 2. Threshold: Context over threshold, compact, NO auto-retry (user continues manually)
+     *
      * @param assistantMessage The assistant message to check
      * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
+     * @param requestWillFollow Whether the caller will issue the next request without agent.continue().
      */
-    async _checkCompaction(assistantMessage, skipAbortedCheck = true) {
+    async _doCheckCompaction(assistantMessage, skipAbortedCheck = true, requestWillFollow = false) {
         const settings = this.settingsManager.getCompactionSettings();
         // Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
         if (skipAbortedCheck && assistantMessage.stopReason === "aborted")
@@ -2119,11 +2219,13 @@ export class AgentSession {
                 // Remove the error message from agent state (it IS saved to session
                 // for history, but we don't want it in context for the retry)
                 this._removeLastAssistantMessage();
-                setTimeout(() => {
-                    this.agent.continue().catch((err) => {
-                        this.warnInSession(`Agent failed to continue after context window upgrade: ${err instanceof Error ? err.message : String(err)}`);
-                    });
-                }, 100);
+                if (!requestWillFollow) {
+                    setTimeout(() => {
+                        this.agent.continue().catch((err) => {
+                            this.warnInSession(`Agent failed to continue after context window upgrade: ${err instanceof Error ? err.message : String(err)}`);
+                        });
+                    }, 100);
+                }
                 return;
             }
             if (!settings.enabled)
@@ -2133,7 +2235,7 @@ export class AgentSession {
                     type: "auto_compaction_end",
                     result: undefined,
                     aborted: false,
-                    willRetry: false,
+                    willRetry: requestWillFollow,
                     errorMessage: "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model.",
                 });
                 return;
@@ -2142,7 +2244,7 @@ export class AgentSession {
             // Remove the error message from agent state (it IS saved to session for history,
             // but we don't want it in context for the retry)
             this._removeLastAssistantMessage();
-            await this._runAutoCompaction("overflow", true);
+            await this._trackAutoCompaction("overflow", true, requestWillFollow);
             return;
         }
         // Case 2: Threshold - context is getting large
@@ -2188,7 +2290,7 @@ export class AgentSession {
         if (!settings.enabled)
             return;
         if (shouldCompact(contextTokens, contextWindow, settings)) {
-            await this._runAutoCompaction("threshold", false);
+            await this._trackAutoCompaction("threshold", false, requestWillFollow);
         }
     }
     /**
@@ -2227,27 +2329,60 @@ export class AgentSession {
         });
         return true;
     }
+    /**
+     * Start an auto-compaction while tracking it, so a concurrent check that
+     * arrives during the run can await it instead of starting a competing one.
+     * The tracking flag clears when this specific run settles (even on error,
+     * since _runAutoCompaction swallows its own failures).
+     */
+    _trackAutoCompaction(reason, willRetry, requestWillFollow = false) {
+        const run = this._runAutoCompaction(reason, willRetry, requestWillFollow);
+        this._autoCompactionInFlight = run;
+        void run
+            .catch(() => undefined)
+            .finally(() => {
+            if (this._autoCompactionInFlight === run) {
+                this._autoCompactionInFlight = undefined;
+            }
+        });
+        return run;
+    }
     /**
      * Internal: Run auto-compaction with events.
      */
-    async _runAutoCompaction(reason, willRetry) {
+    async _runAutoCompaction(reason, willRetry, requestWillFollow = false) {
         const settings = this.settingsManager.getCompactionSettings();
         this._emit({ type: "auto_compaction_start", reason });
         this._autoCompactionAbortController = new AbortController();
         try {
             if (!this.model) {
-                this._emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false });
+                this._emit({
+                    type: "auto_compaction_end",
+                    result: undefined,
+                    aborted: false,
+                    willRetry: requestWillFollow,
+                });
                 return;
             }
             const apiKey = await this._modelRegistry.getApiKey(this.model);
             if (!apiKey) {
-                this._emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false });
+                this._emit({
+                    type: "auto_compaction_end",
+                    result: undefined,
+                    aborted: false,
+                    willRetry: requestWillFollow,
+                });
                 return;
             }
             const pathEntries = this.sessionManager.getBranch();
             const preparation = prepareCompaction(pathEntries, settings);
             if (!preparation) {
-                this._emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false });
+                this._emit({
+                    type: "auto_compaction_end",
+                    result: undefined,
+                    aborted: false,
+                    willRetry: requestWillFollow,
+                });
                 return;
             }
             let extensionCompaction;
@@ -2261,7 +2396,12 @@ export class AgentSession {
                     signal: this._autoCompactionAbortController.signal,
                 }));
                 if (extensionResult?.cancel) {
-                    this._emit({ type: "auto_compaction_end", result: undefined, aborted: true, willRetry: false });
+                    this._emit({
+                        type: "auto_compaction_end",
+                        result: undefined,
+                        aborted: true,
+                        willRetry: requestWillFollow,
+                    });
                     return;
                 }
                 if (extensionResult?.compaction) {
@@ -2289,7 +2429,12 @@ export class AgentSession {
                 details = compactResult.details;
             }
             if (this._autoCompactionAbortController.signal.aborted) {
-                this._emit({ type: "auto_compaction_end", result: undefined, aborted: true, willRetry: false });
+                this._emit({
+                    type: "auto_compaction_end",
+                    result: undefined,
+                    aborted: true,
+                    willRetry: requestWillFollow,
+                });
                 return;
             }
             this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension);
@@ -2316,17 +2461,28 @@ export class AgentSession {
                 tokensBefore,
                 details,
             };
-            this._emit({ type: "auto_compaction_end", result, aborted: false, willRetry });
-            if (willRetry) {
-                const messages = this.agent.state.messages;
-                const lastMsg = messages[messages.length - 1];
-                if (lastMsg?.role === "assistant" && lastMsg.stopReason === "error") {
-                    this.agent.replaceMessages(messages.slice(0, -1));
-                }
+            // Rebuilding from persisted entries can reintroduce the assistant error
+            // that triggered compaction. It is historical evidence, not valid retry
+            // context, regardless of how the compaction was classified.
+            let removedTrailingError = false;
+            const rebuiltMessages = this.agent.state.messages;
+            const rebuiltTail = rebuiltMessages[rebuiltMessages.length - 1];
+            if (rebuiltTail?.role === "assistant" && rebuiltTail.stopReason === "error") {
+                this.agent.replaceMessages(rebuiltMessages.slice(0, -1));
+                removedTrailingError = true;
             }
-            // Check the explicit setting first so the continuation decision does not
-            // consult overflow-retry or queued-message state when it is enabled.
-            const shouldContinue = settings.continueAfterAutoCompaction || willRetry || this.agent.hasQueuedMessages();
+            const messages = this.agent.state.messages;
+            const tail = messages[messages.length - 1];
+            const hasQueuedMessages = this.agent.hasQueuedMessages();
+            const hasResumableTail = tail !== undefined && tail.role !== "assistant";
+            const shouldContinue = !requestWillFollow &&
+                messages.length > 0 &&
+                (hasQueuedMessages ||
+                    (hasResumableTail && (removedTrailingError || willRetry || settings.continueAfterAutoCompaction)));
+            const nextRequestWillFollow = requestWillFollow || shouldContinue;
+            // Emit after deciding continuation so frontends can attach input queued
+            // during compaction to the imminent request instead of starting a rival run.
+            this._emit({ type: "auto_compaction_end", result, aborted: false, willRetry: nextRequestWillFollow });
             if (shouldContinue) {
                 setTimeout(() => {
                     this.agent.continue().catch((err) => {
@@ -2342,7 +2498,7 @@ export class AgentSession {
                 type: "auto_compaction_end",
                 result: undefined,
                 aborted: false,
-                willRetry: false,
+                willRetry: requestWillFollow,
                 errorMessage: reason === "overflow"
                     ? `Context overflow recovery failed: ${errorMessage}`
                     : `Auto-compaction failed: ${errorMessage}`,