@bastani/atomic 0.8.26-alpha.6 → 0.8.26-alpha.7

package/dist/core/agent-session.js

@@ -22,14 +22,14 @@ import { sleep } from "../utils/sleep.js";
 import { ATOMIC_GUIDE_COMMAND_NAME, ATOMIC_GUIDE_HELP_CHOICES, atomicGuideModeForChoice, getAtomicGuideMessage, isAtomicGuideHelpChoice, normalizeAtomicGuideMode, } from "./atomic-guide-command.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { executeBashWithOperations } from "./bash-executor.js";
-import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
+import { calculateContextTokens, collectEntriesForBranchSummary, compact, contextCompact as runContextCompact, estimateContextTokens, generateBranchSummary, prepareCompaction, prepareContextCompaction, shouldCompact, } from "./compaction/index.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
-import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-manager.js";
+import { CURRENT_SESSION_VERSION, getLatestCompactionBoundaryEntry } from "./session-manager.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
 import { buildSystemPrompt } from "./system-prompt.js";
 import { createLocalBashOperations } from "./tools/bash.js";
@@ -1587,6 +1587,66 @@ export class AgentSession {
             this._reconnectToAgent();
         }
     }
+    /**
+     * Manually compact the session context by applying validated logical deletions.
+     * Retained transcript entries/content blocks stay verbatim; no user prompt text is accepted.
+     */
+    async contextCompact() {
+        this._disconnectFromAgent();
+        await this.abort();
+        this._compactionAbortController = new AbortController();
+        this._emit({ type: "context_compaction_start", reason: "manual" });
+        try {
+            if (!this.model) {
+                throw new Error(formatNoModelSelectedMessage());
+            }
+            const { apiKey, headers } = await this._getRequiredRequestAuth(this.model);
+            const pathEntries = this.sessionManager.getBranch();
+            const settings = this.settingsManager.getCompactionSettings();
+            const preparation = prepareContextCompaction(pathEntries, settings);
+            if (!preparation) {
+                throw new Error("Nothing to context-compact (session too small)");
+            }
+            const validated = await runContextCompact(preparation, this.model, apiKey, headers, this._compactionAbortController.signal, this.thinkingLevel);
+            if (this._compactionAbortController.signal.aborted) {
+                throw new Error("Compaction cancelled");
+            }
+            const backupPath = this.sessionManager.writeBackupSnapshot("context-compact");
+            this.sessionManager.appendContextCompaction(validated.deletedTargets, validated.protectedEntryIds, validated.stats, backupPath);
+            const sessionContext = this.sessionManager.buildSessionContext();
+            this.agent.state.messages = sessionContext.messages;
+            const result = {
+                ...validated,
+                promptVersion: 1,
+                backupPath,
+            };
+            this._emit({
+                type: "context_compaction_end",
+                reason: "manual",
+                result,
+                aborted: false,
+                willRetry: false,
+            });
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const aborted = message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
+            this._emit({
+                type: "context_compaction_end",
+                reason: "manual",
+                result: undefined,
+                aborted,
+                willRetry: false,
+                errorMessage: aborted ? undefined : `Context compaction failed: ${message}`,
+            });
+            throw error;
+        }
+        finally {
+            this._compactionAbortController = undefined;
+            this._reconnectToAgent();
+        }
+    }
     /**
      * Cancel in-progress compaction (manual or auto).
      */
@@ -1606,7 +1666,7 @@ export class AgentSession {
      *
      * 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)
+     * 2. Threshold: Context over threshold, compact, resume queued active-turn work if present; otherwise wait for user
      *
      * @param assistantMessage The assistant message to check
      * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
@@ -1627,9 +1687,10 @@ export class AgentSession {
         // Skip compaction checks if this assistant message is older than the latest
         // compaction boundary. This prevents a stale pre-compaction usage/error
         // from retriggering compaction on the first prompt after compaction.
-        const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
-        const assistantIsFromBeforeCompaction = compactionEntry !== null && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime();
-        if (assistantIsFromBeforeCompaction) {
+        const compactionBoundaryEntry = getLatestCompactionBoundaryEntry(this.sessionManager.getBranch());
+        const assistantIsFromBeforeCompactionBoundary = compactionBoundaryEntry !== null &&
+            assistantMessage.timestamp <= new Date(compactionBoundaryEntry.timestamp).getTime();
+        if (assistantIsFromBeforeCompactionBoundary) {
             return;
         }
         // Case 1: Overflow - LLM returned context overflow error
@@ -1668,9 +1729,9 @@ export class AgentSession {
             // have stale usage reflecting the old (larger) context and would falsely
             // trigger compaction right after one just finished.
             const usageMsg = messages[estimate.lastUsageIndex];
-            if (compactionEntry &&
+            if (compactionBoundaryEntry &&
                 usageMsg.role === "assistant" &&
-                usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
+                usageMsg.timestamp <= new Date(compactionBoundaryEntry.timestamp).getTime()) {
                 return;
             }
             contextTokens = estimate.tokens;
@@ -1682,6 +1743,40 @@ export class AgentSession {
             await this._runAutoCompaction("threshold", false);
         }
     }
+    /**
+     * Internal: remove the trailing overflow error from retry context if it is still present.
+     */
+    _dropTrailingOverflowAssistantErrorIfPresent() {
+        const messages = this.agent.state.messages;
+        const lastMsg = messages[messages.length - 1];
+        if (lastMsg?.role === "assistant" && lastMsg.stopReason === "error") {
+            this.agent.state.messages = messages.slice(0, -1);
+        }
+    }
+    /**
+     * Internal: schedule a live post-event continuation probe after compaction_end listeners can flush queues.
+     */
+    _schedulePostAutoCompactionContinuationProbe(reason, willRetry) {
+        setTimeout(() => {
+            if (this.isCompacting || this.isStreaming) {
+                return;
+            }
+            if (reason === "overflow" && willRetry) {
+                this._resumeAfterAutoCompaction();
+                return;
+            }
+            if (!this.agent.hasQueuedMessages()) {
+                return;
+            }
+            this._resumeAfterAutoCompaction();
+        }, 100);
+    }
+    /**
+     * Internal: resume generation after successful auto-compaction only when active work remains.
+     */
+    _resumeAfterAutoCompaction() {
+        this.agent.continue().catch(() => { });
+    }
     /**
      * Internal: Run auto-compaction with events.
      */
@@ -1782,6 +1877,9 @@ export class AgentSession {
             const newEntries = this.sessionManager.getEntries();
             const sessionContext = this.sessionManager.buildSessionContext();
             this.agent.state.messages = sessionContext.messages;
+            if (reason === "overflow" && willRetry) {
+                this._dropTrailingOverflowAssistantErrorIfPresent();
+            }
             // Get the saved compaction entry for the extension event
             const savedCompactionEntry = newEntries.find((e) => e.type === "compaction" && e.summary === summary);
             if (this._extensionRunner && savedCompactionEntry) {
@@ -1798,23 +1896,7 @@ export class AgentSession {
                 details,
             };
             this._emit({ type: "compaction_end", reason, 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.state.messages = messages.slice(0, -1);
-                }
-                setTimeout(() => {
-                    this.agent.continue().catch(() => { });
-                }, 100);
-            }
-            else if (this.agent.hasQueuedMessages()) {
-                // Auto-compaction can complete while follow-up/steering/custom messages are waiting.
-                // Kick the loop so queued messages are actually delivered.
-                setTimeout(() => {
-                    this.agent.continue().catch(() => { });
-                }, 100);
-            }
+            this._schedulePostAutoCompactionContinuationProbe(reason, willRetry);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
@@ -2633,10 +2715,10 @@ export class AgentSession {
         // We can only trust usage from an assistant that responded after the latest compaction.
         // If no such assistant exists, context token count is unknown until the next LLM response.
         const branchEntries = this.sessionManager.getBranch();
-        const latestCompaction = getLatestCompactionEntry(branchEntries);
-        if (latestCompaction) {
+        const latestCompactionBoundary = getLatestCompactionBoundaryEntry(branchEntries);
+        if (latestCompactionBoundary) {
             // Check if there's a valid assistant usage after the compaction boundary
-            const compactionIndex = branchEntries.lastIndexOf(latestCompaction);
+            const compactionIndex = branchEntries.lastIndexOf(latestCompactionBoundary);
             let hasPostCompactionUsage = false;
             for (let i = branchEntries.length - 1; i > compactionIndex; i--) {
                 const entry = branchEntries[i];