@leanandmean/coding-agent 0.74.1-scramjet.34 → 0.74.1-scramjet.39

package/dist/core/agent-session.js

@@ -29,6 +29,8 @@ import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { emitSessionShutdownEvent, spliceContributedSections } from "./extensions/runner.js";
+import { OutputThroughputTracker } from "./output-throughput.js";
+import { OutputThroughputHistoryStore } from "./output-throughput-history.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { indexScramjetCommandStarts, restoreScramjetCommandInvocation } from "./scramjet-command-parser.js";
 import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-manager.js";
@@ -61,11 +63,16 @@ export class AgentSession {
     agent;
     sessionManager;
     settingsManager;
+    outputThroughputHistoryPath;
     _scopedModels;
     // Event subscription state
     _unsubscribeAgent;
     _eventListeners = [];
     _agentEventQueue = Promise.resolve();
+    _outputThroughputTracker = new OutputThroughputTracker();
+    _outputThroughputHistory;
+    _outputThroughputGeneration;
+    _latestOutputThroughputSample;
     // SCRAMJET-DIVERGENCE: harness-tool persisted-settlement state (#341). `_disposed` gates post-
     // teardown invocations; the map keys each in-flight invocation's tool-call id to its persistence
     // acknowledgement so `_processAgentEvent` can settle it after the matching tool-result is persisted.
@@ -126,6 +133,15 @@ export class AgentSession {
         this.agent = config.agent;
         this.sessionManager = config.sessionManager;
         this.settingsManager = config.settingsManager;
+        this.outputThroughputHistoryPath = config.outputThroughputHistoryPath;
+        this._outputThroughputHistory = new OutputThroughputHistoryStore(this.outputThroughputHistoryPath, (diagnostic) => {
+            this._extensionRunner.emitError({
+                extensionPath: "output-throughput-history",
+                event: diagnostic.operation,
+                error: `${diagnostic.message} (${diagnostic.path})`,
+                stack: diagnostic.cause instanceof Error ? diagnostic.cause.stack : undefined,
+            });
+        });
         this._scopedModels = config.scopedModels ?? [];
         this._resourceLoader = config.resourceLoader;
         this._customTools = config.customTools ?? [];
@@ -253,6 +269,7 @@ export class AgentSession {
     _lastAssistantMessage = undefined;
     /** Internal handler for agent events - shared by subscribe and reconnect */
     _handleAgentEvent = (event) => {
+        this._captureOutputThroughput(event);
         // Create retry promise synchronously before queueing async processing.
         // Agent.emit() calls this handler synchronously, and prompt() calls waitForRetry()
         // as soon as agent.prompt() resolves. If _retryPromise is created only inside
@@ -263,6 +280,34 @@ export class AgentSession {
         // Keep queue alive if an event handler fails
         this._agentEventQueue.catch(() => { });
     };
+    // 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") {
+            this._outputThroughputGeneration = this._outputThroughputTracker.start({
+                provider: event.message.provider,
+                model: event.message.model,
+            });
+            return;
+        }
+        const generation = this._outputThroughputGeneration;
+        if (generation === undefined)
+            return;
+        if (event.type === "message_update" && event.message.role === "assistant") {
+            this._outputThroughputTracker.observe(generation, event.assistantMessageEvent);
+        }
+        else if (event.type === "message_end" && event.message.role === "assistant") {
+            const sample = this._outputThroughputTracker.finalize(generation, event.message);
+            this._outputThroughputGeneration = undefined;
+            if (sample) {
+                this._latestOutputThroughputSample = sample;
+                this._outputThroughputHistory.submit(sample);
+            }
+        }
+    }
+    _resetOutputThroughput() {
+        this._outputThroughputTracker.reset();
+        this._outputThroughputGeneration = undefined;
+    }
     _createRetryPromiseForAgentEnd(event) {
         if (event.type !== "agent_end" || this._retryPromise) {
             return;
@@ -618,6 +663,7 @@ export class AgentSession {
         if (this._disposed)
             return;
         this._disposed = true;
+        this._resetOutputThroughput();
         this._extensionRunner.invalidate("This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().");
         // Reject pending persistence acknowledgements before revoking Agent-side invocations, so a caller
         // awaiting invokeHarnessTool sees rejection rather than a promise that never settles. Already-
@@ -656,6 +702,48 @@ export class AgentSession {
     get systemPrompt() {
         return flattenSystemPrompt(this.agent.state.systemPrompt);
     }
+    get liveOutputRate() {
+        const model = this.state.model;
+        const identity = this._outputThroughputTracker.activeIdentity;
+        if (!model || identity?.provider !== model.provider || identity.model !== model.id)
+            return undefined;
+        return this._outputThroughputTracker.liveRate();
+    }
+    get outputThroughputActive() {
+        return this._outputThroughputTracker.outputActive;
+    }
+    get outputThroughputGeneration() {
+        return this._outputThroughputTracker.generation;
+    }
+    get medianOutputRate() {
+        const model = this.state.model;
+        if (!model)
+            return undefined;
+        const history = this._outputThroughputHistory.snapshot();
+        const local = this._latestOutputThroughputSample;
+        if (local?.provider === model.provider &&
+            local.model === model.id &&
+            !history
+                .samples(model.provider, model.id)
+                .some((sample) => sample.provider === local.provider &&
+                sample.model === local.model &&
+                sample.responseModel === local.responseModel &&
+                sample.outputTokens === local.outputTokens &&
+                sample.durationMs === local.durationMs &&
+                sample.observedAt === local.observedAt)) {
+            history.add(local);
+        }
+        return history.median(model.provider, model.id);
+    }
+    get outputThroughputHistory() {
+        return this._outputThroughputHistory.snapshot();
+    }
+    refreshOutputThroughputHistory() {
+        return this._outputThroughputHistory.refresh();
+    }
+    flushOutputThroughputHistory() {
+        return this._outputThroughputHistory.flush();
+    }
     /** Current retry attempt (0 if not retrying) */
     get retryAttempt() {
         return this._retryAttempt;
@@ -1322,6 +1410,7 @@ export class AgentSession {
      */
     async abort() {
         this.abortRetry();
+        this._resetOutputThroughput();
         this.agent.abort();
         await this.agent.waitForIdle();
     }
@@ -1509,6 +1598,7 @@ 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();