@kolisachint/hoocode-agent 0.4.4 → 0.4.6

package/dist/core/agent-session.js

@@ -1237,6 +1237,57 @@ export class AgentSession {
     // =========================================================================
     // Compaction
     // =========================================================================
+    /**
+     * Shared core for manual and auto compaction.
+     *
+     * Runs the `session_before_compact` extension hook, produces the compaction
+     * (from an extension or by summarizing), persists it, updates agent context,
+     * and emits `session_compact`. Returns `{ status: "cancelled" }` if an
+     * extension cancels or the signal aborts; callers map that to their own
+     * cancel handling (manual throws, auto emits).
+     */
+    async _applyCompaction(params) {
+        const { preparation, branchEntries, model, apiKey, headers, customInstructions, signal } = params;
+        let extensionCompaction;
+        let fromExtension = false;
+        if (this._extensionRunner.hasHandlers("session_before_compact")) {
+            const result = (await this._extensionRunner.emit({
+                type: "session_before_compact",
+                preparation,
+                branchEntries,
+                customInstructions,
+                signal,
+            }));
+            if (result?.cancel) {
+                return { status: "cancelled" };
+            }
+            if (result?.compaction) {
+                extensionCompaction = result.compaction;
+                fromExtension = true;
+            }
+        }
+        const generated = extensionCompaction ??
+            (await compact(preparation, model, apiKey, headers, customInstructions, signal, this.thinkingLevel));
+        if (signal.aborted) {
+            return { status: "cancelled" };
+        }
+        const { summary, firstKeptEntryId, tokensBefore, tokensAfter, details } = generated;
+        this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension, tokensAfter);
+        const newEntries = this.sessionManager.getEntries();
+        this.agent.state.messages = this.sessionManager.buildSessionContext().messages;
+        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,
+            });
+        }
+        return {
+            status: "ok",
+            result: { summary, firstKeptEntryId, tokensBefore, tokensAfter: tokensAfter ?? tokensBefore, details },
+        };
+    }
     /**
      * Manually compact the session context.
      * Aborts current agent operation first.
@@ -1263,69 +1314,19 @@ export class AgentSession {
                 }
                 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 tokensAfter;
-            let details;
-            if (extensionCompaction) {
-                // Extension provided compaction content
-                summary = extensionCompaction.summary;
-                firstKeptEntryId = extensionCompaction.firstKeptEntryId;
-                tokensBefore = extensionCompaction.tokensBefore;
-                tokensAfter = extensionCompaction.tokensAfter;
-                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;
-                tokensAfter = result.tokensAfter;
-                details = result.details;
-            }
-            if (this._compactionAbortController.signal.aborted) {
+            const applied = await this._applyCompaction({
+                preparation,
+                branchEntries: pathEntries,
+                model: this.model,
+                apiKey,
+                headers,
+                customInstructions,
+                signal: this._compactionAbortController.signal,
+            });
+            if (applied.status === "cancelled") {
                 throw new Error("Compaction cancelled");
             }
-            this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension, tokensAfter);
-            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,
-                tokensAfter: tokensAfter ?? tokensBefore,
-                details,
-            };
+            const compactionResult = applied.result;
             this._emit({
                 type: "compaction_end",
                 reason: "manual",
@@ -1490,54 +1491,16 @@ 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 tokensAfter;
-            let details;
-            if (extensionCompaction) {
-                // Extension provided compaction content
-                summary = extensionCompaction.summary;
-                firstKeptEntryId = extensionCompaction.firstKeptEntryId;
-                tokensBefore = extensionCompaction.tokensBefore;
-                tokensAfter = extensionCompaction.tokensAfter;
-                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;
-                tokensAfter = compactResult.tokensAfter;
-                details = compactResult.details;
-            }
-            if (this._autoCompactionAbortController.signal.aborted) {
+            const applied = await this._applyCompaction({
+                preparation,
+                branchEntries: pathEntries,
+                model: this.model,
+                apiKey,
+                headers,
+                customInstructions: undefined,
+                signal: this._autoCompactionAbortController.signal,
+            });
+            if (applied.status === "cancelled") {
                 this._emit({
                     type: "compaction_end",
                     reason,
@@ -1547,26 +1510,7 @@ export class AgentSession {
                 });
                 return;
             }
-            this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension, tokensAfter);
-            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 = {
-                summary,
-                firstKeptEntryId,
-                tokensBefore,
-                tokensAfter: tokensAfter ?? tokensBefore,
-                details,
-            };
+            const result = applied.result;
             this._emit({ type: "compaction_end", reason, result, aborted: false, willRetry });
             if (willRetry) {
                 const messages = this.agent.state.messages;