@leanandmean/coding-agent 0.74.1-scramjet.66 → 0.74.1-scramjet.68

package/dist/core/agent-session.js

@@ -87,6 +87,9 @@ function rejectDeferred(deferred, error) {
 function settleDeferred(deferred, error) {
     return error ? rejectDeferred(deferred, error) : resolveDeferred(deferred, undefined);
 }
+function validRecordedCost(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
 export class AgentSession {
     agent;
     sessionManager;
@@ -97,6 +100,10 @@ export class AgentSession {
     _unsubscribeAgent;
     _eventListeners = [];
     _agentEventQueue = Promise.resolve();
+    // SCRAMJET-DIVERGENCE: execution ownership survives final-event queue latency until append succeeds (#598).
+    _toolCostExecutions = new Map();
+    _pendingToolCosts = new Set();
+    _historicalCostDefinitions = new Map();
     _outputThroughputTracker = new OutputThroughputTracker();
     _outputThroughputHistory;
     _outputThroughputGeneration;
@@ -115,6 +122,7 @@ export class AgentSession {
     _inputSessionEntries = new WeakMap();
     // Compaction state
     _compactionAbortController = undefined;
+    _manualCompactionDrain;
     _autoCompactionAbortController = undefined;
     _overflowRecoveryAttempted = false;
     // Branch summarization state
@@ -299,10 +307,13 @@ export class AgentSession {
     }
     /** Internal handler for agent events - shared by subscribe and reconnect */
     _handleAgentEvent = (event) => {
+        if (this._disposed)
+            return;
         this._captureOutputThroughput(event);
+        const toolCost = this._captureToolCost(event);
         const runSettlement = this._captureAgentRunSettlement(event);
         const harnessAck = this._harnessPersistenceAckForEvent(event);
-        const processing = this._agentEventQueue.then(() => this._processAgentEventTracked(event, runSettlement, harnessAck), () => this._processAgentEventTracked(event, runSettlement, harnessAck));
+        const processing = this._agentEventQueue.then(() => this._processAgentEventTracked(event, runSettlement, harnessAck, toolCost), () => this._processAgentEventTracked(event, runSettlement, harnessAck, toolCost));
         this._agentEventQueue = processing;
         if (harnessAck)
             harnessAck.persistenceTail = processing;
@@ -313,6 +324,42 @@ export class AgentSession {
         if (event.type === "turn_end")
             return this._agentEventQueue;
     };
+    // SCRAMJET-DIVERGENCE: scalar reports are captured before mutable events enter async hooks (#598).
+    _captureToolCost(event) {
+        if (event.type === "tool_execution_start") {
+            const execution = {};
+            this._toolCostExecutions.set(event.toolCallId, execution);
+            this._pendingToolCosts.add(execution);
+            return;
+        }
+        let toolCallId;
+        let reported;
+        const final = event.type === "message_end" && event.message.role === "toolResult";
+        if (event.type === "tool_execution_update" || event.type === "tool_execution_end") {
+            toolCallId = event.toolCallId;
+            reported = event.type === "tool_execution_update" ? event.partialResult?.cost : event.result?.cost;
+        }
+        else if (event.type === "message_end" && event.message.role === "toolResult") {
+            toolCallId = event.message.toolCallId;
+            reported = event.message.cost;
+        }
+        else {
+            return;
+        }
+        let execution = this._toolCostExecutions.get(toolCallId);
+        if (!execution && validRecordedCost(reported)) {
+            execution = {};
+            this._toolCostExecutions.set(toolCallId, execution);
+            this._pendingToolCosts.add(execution);
+        }
+        if (execution && validRecordedCost(reported))
+            execution.cost = reported;
+        if (final) {
+            this._toolCostExecutions.delete(toolCallId);
+            return execution;
+        }
+        return;
+    }
     // SCRAMJET-DIVERGENCE: Capture provider events synchronously and reset stale throughput lifecycles (#476).
     _captureOutputThroughput(event) {
         if (event.type === "message_start" && event.message.role === "assistant" && event.message.origin === "provider") {
@@ -391,16 +438,18 @@ export class AgentSession {
     }
     // SCRAMJET-DIVERGENCE: harness-tool persisted settlement (#341). Synchronous ownership keeps queued
     // invocation events attributed after early failures; public settlement awaits execution and the final persistence tail.
-    async _processAgentEventTracked(event, run, harnessAck) {
+    async _processAgentEventTracked(event, run, harnessAck, toolCost) {
         try {
-            await this._processAgentEvent(event, run, harnessAck !== undefined);
+            await this._processAgentEvent(event, run, harnessAck !== undefined, toolCost);
         }
         catch (err) {
             const error = err instanceof Error ? err : new Error(String(err));
+            if (this._manualCompactionDrain)
+                this._manualCompactionDrain.firstError ??= error;
             if (harnessAck) {
                 harnessAck.firstPersistenceError ??= error;
             }
-            else if (run) {
+            else if (run && !this._manualCompactionDrain) {
                 if (event.type === "message_end" && event.message.role === "assistant") {
                     run.assistantPersistenceError = error;
                 }
@@ -437,7 +486,19 @@ export class AgentSession {
         }
         return toolCallId === undefined ? undefined : this._harnessPersistenceAcks.get(toolCallId);
     }
-    async _processAgentEvent(event, run, fromHarnessInvocation = false) {
+    async _processAgentEvent(event, run, fromHarnessInvocation = false, toolCost) {
+        if (this._disposed)
+            return;
+        // SCRAMJET-DIVERGENCE: queued lifecycle events must respect manual compaction ownership (#598).
+        if (this._manualCompactionDrain && event.type !== "message_end" && event.type !== "agent_end")
+            return;
+        if (this._manualCompactionDrain && event.type === "agent_end") {
+            if (this._retry)
+                this._finishCancelledRetry("cancelled_during_continuation");
+            if (run)
+                this._completeAgentRun(run, this._manualCompactionDrain.firstError);
+            return;
+        }
         // When a user message starts, check if it's from either queue and remove it BEFORE emitting
         // This ensures the UI sees the updated queue state
         if (event.type === "message_start" && event.message.role === "user") {
@@ -462,6 +523,18 @@ export class AgentSession {
         }
         // Emit to extensions first
         await this._emitExtensionEvent(event);
+        if (event.type === "message_end" && event.message.role === "toolResult" && toolCost?.cost !== undefined) {
+            event.message.cost = toolCost.cost;
+        }
+        // An awaited hook may have acquired manual ownership while this event was in flight.
+        if (this._manualCompactionDrain && event.type !== "message_end") {
+            if (event.type === "agent_end" && run) {
+                if (this._retry)
+                    this._finishCancelledRetry("cancelled_during_continuation");
+                this._completeAgentRun(run, this._manualCompactionDrain.firstError);
+            }
+            return;
+        }
         // Notify all listeners
         this._emit(event);
         if (this._disposed)
@@ -482,6 +555,8 @@ export class AgentSession {
                     ? JSON.parse(JSON.stringify(event.message))
                     : event.message;
                 const messageEntryId = this.sessionManager.appendMessage(persistedMessage);
+                if (toolCost)
+                    this._pendingToolCosts.delete(toolCost);
                 if (persistedMessage.role === "assistant" && !fromHarnessInvocation && run) {
                     run.persistedAssistantSnapshot = persistedMessage;
                 }
@@ -514,7 +589,8 @@ export class AgentSession {
             if (event.message.role === "assistant" &&
                 event.message.stopReason !== "error" &&
                 event.message.stopReason !== "aborted" &&
-                !fromHarnessInvocation) {
+                !fromHarnessInvocation &&
+                !this._manualCompactionDrain) {
                 this._overflowRecoveryAttempted = false;
                 if (this._retry)
                     this._retry = { ...this._retry, attempt: 0 };
@@ -523,6 +599,12 @@ export class AgentSession {
         if (event.type === "agent_end") {
             if (this._disposed || !run)
                 return;
+            if (this._manualCompactionDrain) {
+                if (this._retry)
+                    this._finishCancelledRetry("cancelled_during_continuation");
+                this._completeAgentRun(run, this._manualCompactionDrain.firstError);
+                return;
+            }
             if (run.assistantPersistenceError) {
                 const error = run.assistantPersistenceError;
                 run.assistantPersistenceError = undefined;
@@ -741,8 +823,8 @@ export class AgentSession {
      * Preserves all existing listeners.
      */
     _reconnectToAgent() {
-        if (this._unsubscribeAgent)
-            return; // Already connected
+        if (this._disposed || this._unsubscribeAgent)
+            return; // Already connected or disposed
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
     }
     /**
@@ -755,6 +837,8 @@ export class AgentSession {
         if (this._disposed)
             return;
         this._disposed = true;
+        this._toolCostExecutions.clear();
+        this._pendingToolCosts.clear();
         this._resetOutputThroughput();
         const retryDisposeError = new Error("AgentSession disposed before retry settlement completed.");
         const unsettledRuns = [...this._unsettledAgentRuns];
@@ -966,6 +1050,10 @@ export class AgentSession {
         if (this._disposed) {
             throw new Error(`Cannot invoke harness tool "${name}": the session has been disposed.`);
         }
+        // SCRAMJET-DIVERGENCE: reject new session work before allocating invocation ownership (#598).
+        if (this._compactionAbortController) {
+            throw new Error(`Cannot invoke harness tool "${name}": manual compaction is in progress. Retry after it settles.`);
+        }
         const tool = this._toolRegistry.get(name);
         if (!tool) {
             throw new Error(`Cannot invoke harness tool "${name}": no tool with that name is registered.`);
@@ -1759,12 +1847,32 @@ export class AgentSession {
      * @param customInstructions Optional instructions for the compaction summary
      */
     async compact(customInstructions) {
-        this._resetOutputThroughput();
-        this._disconnectFromAgent();
-        await this.abort();
-        this._compactionAbortController = new AbortController();
-        this._emit({ type: "compaction_start", reason: "manual" });
+        // SCRAMJET-DIVERGENCE: acquire one owner before awaits and drain terminal persistence (#598).
+        if (this._disposed)
+            throw new Error("Cannot compact a disposed session.");
+        if (this.isCompacting)
+            throw new Error("Compaction or branch summarization is already in progress. Retry after it settles.");
+        if (this.agent.hasActiveTransientHarnessTools) {
+            throw new Error("A harness tool is still executing outside an Agent run. Retry compaction after its persisted settlement.");
+        }
+        const controller = new AbortController();
+        this._compactionAbortController = controller;
+        const drain = {};
+        this._manualCompactionDrain = drain;
+        const runs = [...this._unsettledAgentRuns];
         try {
+            this._resetOutputThroughput();
+            this._disconnectFromAgent();
+            this._unsubscribeAgent = this.agent.subscribe((event) => this._handleAgentEvent(event));
+            this._emit({ type: "compaction_start", reason: "manual" });
+            await this.abort();
+            await this._agentEventQueue;
+            if (drain.firstError)
+                throw drain.firstError;
+            if (this._disposed)
+                throw new Error("Session disposed during compaction.");
+            if (controller.signal.aborted)
+                throw new Error("Compaction cancelled");
             if (!this.model) {
                 throw new Error(formatNoModelSelectedMessage());
             }
@@ -1788,7 +1896,7 @@ export class AgentSession {
                     preparation,
                     branchEntries: pathEntries,
                     customInstructions,
-                    signal: this._compactionAbortController.signal,
+                    signal: controller.signal,
                 }));
                 if (result?.cancel) {
                     throw new Error("Compaction cancelled");
@@ -1811,13 +1919,15 @@ export class AgentSession {
             }
             else {
                 // Generate compaction result
-                const result = await compact(preparation, this.model, apiKey, headers, customInstructions, this._compactionAbortController.signal, this.thinkingLevel);
+                const result = await compact(preparation, this.model, apiKey, headers, customInstructions, controller.signal, this.thinkingLevel);
                 summary = result.summary;
                 firstKeptEntryId = result.firstKeptEntryId;
                 tokensBefore = result.tokensBefore;
                 details = result.details;
             }
-            if (this._compactionAbortController.signal.aborted) {
+            if (this._disposed)
+                throw new Error("Session disposed during compaction.");
+            if (controller.signal.aborted) {
                 throw new Error("Compaction cancelled");
             }
             this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension);
@@ -1849,8 +1959,13 @@ export class AgentSession {
             return compactionResult;
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            const aborted = message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
+            const failure = drain.firstError ?? error;
+            const settlementError = failure instanceof Error ? failure : new Error(String(failure));
+            this._releaseRetryForFailedRun(settlementError);
+            for (const run of runs)
+                this._completeAgentRun(run, settlementError);
+            const message = settlementError.message;
+            const aborted = message === "Compaction cancelled" || settlementError.name === "AbortError";
             this._emit({
                 type: "compaction_end",
                 reason: "manual",
@@ -1859,9 +1974,11 @@ export class AgentSession {
                 willRetry: false,
                 errorMessage: aborted ? undefined : `Compaction failed: ${message}`,
             });
-            throw error;
+            throw failure;
         }
         finally {
+            this._disconnectFromAgent();
+            this._manualCompactionDrain = undefined;
             this._compactionAbortController = undefined;
             this._reconnectToAgent();
         }
@@ -1891,6 +2008,8 @@ export class AgentSession {
      * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
      */
     async _checkCompaction(assistantMessage, skipAbortedCheck = true) {
+        if (this._manualCompactionDrain)
+            return;
         const settings = this.settingsManager.getCompactionSettings();
         if (!settings.enabled)
             return;
@@ -1969,9 +2088,10 @@ export class AgentSession {
      */
     async _runAutoCompaction(reason, willRetry) {
         const settings = this.settingsManager.getCompactionSettings();
-        this._emit({ type: "compaction_start", reason });
+        // SCRAMJET-DIVERGENCE: reentrant subscribers must observe compaction ownership (#598).
         this._autoCompactionAbortController = new AbortController();
         try {
+            this._emit({ type: "compaction_start", reason });
             if (!this.model) {
                 this._emit({
                     type: "compaction_end",
@@ -2316,7 +2436,13 @@ export class AgentSession {
                 definition,
                 sourceInfo: createSyntheticSourceInfo(`<sdk:${definition.name}>`, { source: "sdk" }),
             })),
-        ].filter((tool) => isAllowedTool(tool.definition.name));
+        ];
+        // SCRAMJET-DIVERGENCE: historical interpretation follows definition collision winners, not execution allowlists (#598).
+        this._historicalCostDefinitions = new Map(this._baseToolDefinitions);
+        for (const tool of allCustomTools) {
+            this._historicalCostDefinitions.set(tool.definition.name, tool.definition);
+        }
+        const allowedCustomTools = allCustomTools.filter((tool) => isAllowedTool(tool.definition.name));
         const definitionRegistry = new Map(Array.from(this._baseToolDefinitions.entries())
             .filter(([name]) => isAllowedTool(name))
             .map(([name, definition]) => [
@@ -2326,7 +2452,7 @@ export class AgentSession {
                 sourceInfo: createSyntheticSourceInfo(`<builtin:${name}>`, { source: "builtin" }),
             },
         ]));
-        for (const tool of allCustomTools) {
+        for (const tool of allowedCustomTools) {
             definitionRegistry.set(tool.definition.name, {
                 definition: tool.definition,
                 sourceInfo: tool.sourceInfo,
@@ -2346,7 +2472,7 @@ export class AgentSession {
         })
             .filter((entry) => entry !== undefined));
         const runner = this._extensionRunner;
-        const wrappedExtensionTools = wrapRegisteredTools(allCustomTools, runner);
+        const wrappedExtensionTools = wrapRegisteredTools(allowedCustomTools, runner);
         const wrappedBuiltInTools = wrapRegisteredTools(Array.from(this._baseToolDefinitions.values())
             .filter((definition) => isAllowedTool(definition.name))
             .map((definition) => ({
@@ -2498,7 +2624,7 @@ export class AgentSession {
             this._appendAutoRetryRecord(record);
         }
         catch (error) {
-            if (retry) {
+            if (retry && !this._manualCompactionDrain) {
                 this._emit({
                     type: "auto_retry_end",
                     success: false,
@@ -2508,7 +2634,7 @@ export class AgentSession {
             }
             throw this._reportRetryFailure(error);
         }
-        if (retry && end)
+        if (retry && end && !this._manualCompactionDrain)
             this._emit(end);
     }
     _finishRetryWithoutSuccess(record, message) {
@@ -2645,6 +2771,8 @@ export class AgentSession {
         if (controller.signal.aborted || this._disposed) {
             return this._finishCancelledRetry("cancelled_during_backoff", backoff);
         }
+        if (this._manualCompactionDrain)
+            return this._finishCancelledRetry("cancelled_during_backoff", backoff);
         // Hand the chain to the continuation before `continue()`; the run that eventually emits
         // `agent_start` adopts it (see `_captureAgentRunSettlement`), however long Agent defers that start.
         const continuing = { phase: "continuing", attempt, chain: run.chain };
@@ -3051,6 +3179,43 @@ export class AgentSession {
         }
         return result;
     }
+    // SCRAMJET-DIVERGENCE: whole-journal parent/tool costs plus reports awaiting successful append (#598).
+    getRecordedSessionCost() {
+        let total = 0;
+        for (const entry of this.sessionManager.getEntries()) {
+            if (entry.type !== "message")
+                continue;
+            const message = entry.message;
+            if (message.role === "assistant") {
+                if (validRecordedCost(message.usage?.cost?.total))
+                    total += message.usage.cost.total;
+            }
+            else if (message.role === "toolResult") {
+                if (validRecordedCost(message.cost)) {
+                    total += message.cost;
+                    continue;
+                }
+                const definition = this._historicalCostDefinitions.get(message.toolName);
+                if (!definition?.getHistoricalCost)
+                    continue;
+                try {
+                    const cost = definition.getHistoricalCost(message.details);
+                    if (validRecordedCost(cost))
+                        total += cost;
+                }
+                catch (error) {
+                    this._extensionRunner.emitError({
+                        extensionPath: `tool:${message.toolName}`,
+                        event: "historical_cost",
+                        error: `Failed to interpret historical tool cost: ${error instanceof Error ? error.message : String(error)}`,
+                    });
+                }
+            }
+        }
+        for (const execution of this._pendingToolCosts)
+            total += execution.cost ?? 0;
+        return total;
+    }
     /**
      * Get session statistics.
      */