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

package/dist/core/agent-session.js

@@ -22,7 +22,7 @@ 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, contextCompact as runContextCompact, estimateContextTokens, generateBranchSummary, prepareCompaction, prepareContextCompaction, shouldCompact, } from "./compaction/index.js";
+import { calculateContextTokens, collectEntriesForBranchSummary, contextCompact as runContextCompact, estimateContextTokens, generateBranchSummary, 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";
@@ -1476,11 +1476,41 @@ export class AgentSession {
     // Compaction
     // =========================================================================
     /**
-     * Manually compact the session context.
-     * Aborts current agent operation first.
-     * @param customInstructions Optional instructions for the compaction summary
+     * Apply validated logical deletions and rebuild active agent context.
+     * Retained transcript entries/content blocks stay verbatim.
+     */
+    async _applyContextVerbatimCompaction(options) {
+        if (!this.model) {
+            throw new Error(formatNoModelSelectedMessage());
+        }
+        const pathEntries = this.sessionManager.getBranch();
+        const settings = this.settingsManager.getCompactionSettings();
+        const preparation = prepareContextCompaction(pathEntries, settings);
+        if (!preparation) {
+            return undefined;
+        }
+        const validated = await runContextCompact(preparation, this.model, options.apiKey, options.headers, options.abortController.signal, this.thinkingLevel);
+        if (options.abortController.signal.aborted) {
+            throw new Error("Compaction cancelled");
+        }
+        const backupPath = this.sessionManager.writeBackupSnapshot(options.backupLabel);
+        this.sessionManager.appendContextCompaction(validated.deletedTargets, validated.protectedEntryIds, validated.stats, backupPath);
+        const sessionContext = this.sessionManager.buildSessionContext();
+        this.agent.state.messages = sessionContext.messages;
+        return {
+            ...validated,
+            promptVersion: 1,
+            ...(backupPath ? { backupPath } : {}),
+        };
+    }
+    /**
+     * Manually compact the session context using deletion-only verbatim context compaction.
+     * Aborts current agent operation first. Custom summary instructions are not accepted.
      */
     async compact(customInstructions) {
+        if (customInstructions?.trim()) {
+            throw new Error("Custom compaction instructions are not supported; use /compact without arguments");
+        }
         this._disconnectFromAgent();
         await this.abort();
         this._compactionAbortController = new AbortController();
@@ -1490,84 +1520,23 @@ export class AgentSession {
                 throw new Error(formatNoModelSelectedMessage());
             }
             const { apiKey, headers } = await this._getRequiredRequestAuth(this.model);
-            const pathEntries = this.sessionManager.getBranch();
-            const settings = this.settingsManager.getCompactionSettings();
-            const preparation = prepareCompaction(pathEntries, settings);
-            if (!preparation) {
-                // Check why we can't compact
-                const lastEntry = pathEntries[pathEntries.length - 1];
-                if (lastEntry?.type === "compaction") {
-                    throw new Error("Already compacted");
-                }
+            const result = await this._applyContextVerbatimCompaction({
+                apiKey,
+                headers,
+                abortController: this._compactionAbortController,
+                backupLabel: "compact",
+            });
+            if (!result) {
                 throw new Error("Nothing to compact (session too small)");
             }
-            let extensionCompaction;
-            let fromExtension = false;
-            if (this._extensionRunner.hasHandlers("session_before_compact")) {
-                const result = (await this._extensionRunner.emit({
-                    type: "session_before_compact",
-                    preparation,
-                    branchEntries: pathEntries,
-                    customInstructions,
-                    signal: this._compactionAbortController.signal,
-                }));
-                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 result = await compact(preparation, this.model, apiKey, headers, customInstructions, this._compactionAbortController.signal, this.thinkingLevel);
-                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,
-                });
-            }
-            const compactionResult = {
-                summary,
-                firstKeptEntryId,
-                tokensBefore,
-                details,
-            };
             this._emit({
                 type: "compaction_end",
                 reason: "manual",
-                result: compactionResult,
+                result,
                 aborted: false,
                 willRetry: false,
             });
-            return compactionResult;
+            return result;
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -1601,25 +1570,15 @@ export class AgentSession {
                 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) {
+            const result = await this._applyContextVerbatimCompaction({
+                apiKey,
+                headers,
+                abortController: this._compactionAbortController,
+                backupLabel: "context-compact",
+            });
+            if (!result) {
                 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",
@@ -1781,7 +1740,6 @@ export class AgentSession {
      * Internal: Run auto-compaction with events.
      */
     async _runAutoCompaction(reason, willRetry) {
-        const settings = this.settingsManager.getCompactionSettings();
         this._emit({ type: "compaction_start", reason });
         this._autoCompactionAbortController = new AbortController();
         try {
@@ -1806,10 +1764,13 @@ export class AgentSession {
                 });
                 return;
             }
-            const { apiKey, headers } = authResult;
-            const pathEntries = this.sessionManager.getBranch();
-            const preparation = prepareCompaction(pathEntries, settings);
-            if (!preparation) {
+            const result = await this._applyContextVerbatimCompaction({
+                apiKey: authResult.apiKey,
+                headers: authResult.headers,
+                abortController: this._autoCompactionAbortController,
+                backupLabel: reason === "overflow" ? "overflow-auto-compact" : "auto-compact",
+            });
+            if (!result) {
                 this._emit({
                     type: "compaction_end",
                     reason,
@@ -1819,96 +1780,26 @@ export class AgentSession {
                 });
                 return;
             }
-            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,
-                    });
-                    return;
-                }
-                if (extensionResult?.compaction) {
-                    extensionCompaction = extensionResult.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 compactResult = await compact(preparation, this.model, apiKey, headers, undefined, this._autoCompactionAbortController.signal, this.thinkingLevel);
-                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,
-                });
-                return;
-            }
-            this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension);
-            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) {
-                await this._extensionRunner.emit({
-                    type: "session_compact",
-                    compactionEntry: savedCompactionEntry,
-                    fromExtension,
-                });
-            }
-            const result = {
-                summary,
-                firstKeptEntryId,
-                tokensBefore,
-                details,
-            };
             this._emit({ type: "compaction_end", reason, result, aborted: false, willRetry });
             this._schedulePostAutoCompactionContinuationProbe(reason, willRetry);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
+            const aborted = errorMessage === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
             this._emit({
                 type: "compaction_end",
                 reason,
                 result: undefined,
-                aborted: false,
+                aborted,
                 willRetry: false,
-                errorMessage: reason === "overflow"
-                    ? `Context overflow recovery failed: ${errorMessage}`
-                    : `Auto-compaction failed: ${errorMessage}`,
+                errorMessage: aborted
+                    ? undefined
+                    : reason === "overflow"
+                        ? `Context overflow recovery failed: ${errorMessage}`
+                        : `Auto-compaction failed: ${errorMessage}`,
             });
         }
         finally {