@myagentroam/node 0.9.174 → 0.9.175

package/dist/codex-app-server.js

@@ -231,6 +231,7 @@ export class CodexAppServerClient {
     startThread(cwd, configuration = {}) {
         return this.request('thread/start', {
             cwd,
+            experimentalRawEvents: true,
             ...codexThreadConfiguration(cwd, configuration)
         });
     }

package/dist/runner/claude/managed-run-controller.js

@@ -8,6 +8,7 @@ import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
 import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
+import { GenerationTimingTracker } from '../../service/generation-timing-tracker.js';
 export class ClaudeManagedRunController {
     runner;
     host;
@@ -164,12 +165,27 @@ export class ClaudeManagedRunController {
         try {
             const gate = new ClaudeChannelGate(sessionId);
             const responseLatency = new ResponseLatencyTracker();
+            const generationTiming = new GenerationTimingTracker();
+            const finalOutputTokens = new Map();
+            const pendingOutputTokens = new Map();
+            const completedMessages = new Set();
             let responseMessageId;
             const observeResponse = (id, incremental = false) => {
                 const latencyMs = responseLatency.response(id, incremental);
                 if (latencyMs !== undefined)
                     this.host.emit(runId, 'run.performance', { latencyMs });
             };
+            const settleGeneration = (id, observedAt) => {
+                if (id === undefined)
+                    return;
+                generationTiming.end(id, observedAt);
+                const outputTokens = finalOutputTokens.get(id);
+                if (outputTokens === undefined)
+                    return;
+                const result = generationTiming.settle(id, outputTokens, observedAt);
+                if (result !== undefined)
+                    this.host.emit(runId, 'run.performance', { tokensPerSecond: result.tokensPerSecond });
+            };
             handle = this.runner.startChannel({
                 prompt: payload.input,
                 cwd,
@@ -200,9 +216,14 @@ export class ClaudeManagedRunController {
                         }))
                     }),
                 onPermission: (toolName, toolInput, options) => {
-                    const latencyMs = responseLatency.toolStarted(options.toolUseID);
-                    if (latencyMs !== undefined)
-                        this.host.emit(runId, 'run.performance', { latencyMs });
+                    if (options.agentID === undefined) {
+                        const receiptAt = generationTiming.timestamp();
+                        if (responseMessageId !== undefined)
+                            generationTiming.pause(responseMessageId, receiptAt);
+                        const latencyMs = responseLatency.toolStarted(options.toolUseID);
+                        if (latencyMs !== undefined)
+                            this.host.emit(runId, 'run.performance', { latencyMs });
+                    }
                     return toolName === 'AskUserQuestion'
                         ? (toolKinds.set(options.toolUseID, 'user_input_request'),
                             this.host.requestUserInput(runId, toolInput, options.toolUseID))
@@ -212,6 +233,7 @@ export class ClaudeManagedRunController {
                 onMessage: (message) => {
                     if (terminal)
                         return;
+                    const receiptAt = generationTiming.timestamp();
                     const record = message;
                     const nativeSessionId = typeof record.session_id === 'string' ? record.session_id : undefined;
                     const current = this.runner.execution.runs.get(runId);
@@ -236,7 +258,8 @@ export class ClaudeManagedRunController {
                                 });
                         }
                     }
-                    if (record.type === 'stream_event') {
+                    const mainTask = record.parent_tool_use_id === undefined || record.parent_tool_use_id === null;
+                    if (record.type === 'stream_event' && mainTask) {
                         // Observe semantic timing without forwarding raw thinking or input fragments.
                         const event = record.event;
                         const block = event?.content_block;
@@ -245,14 +268,49 @@ export class ClaudeManagedRunController {
                             const message = event.message;
                             responseMessageId = typeof message?.id === 'string' ? message.id : undefined;
                         }
+                        if (event?.type === 'message_delta') {
+                            const usage = event.usage;
+                            if (responseMessageId !== undefined) {
+                                if (typeof usage?.output_tokens === 'number')
+                                    pendingOutputTokens.set(responseMessageId, usage.output_tokens);
+                                if (typeof delta?.stop_reason === 'string' && delta.stop_reason.length > 0) {
+                                    const tokens = pendingOutputTokens.get(responseMessageId);
+                                    if (tokens !== undefined)
+                                        finalOutputTokens.set(responseMessageId, tokens);
+                                    completedMessages.add(responseMessageId);
+                                    settleGeneration(responseMessageId, receiptAt);
+                                }
+                            }
+                        }
+                        if (event?.type === 'message_stop') {
+                            if (responseMessageId !== undefined) {
+                                completedMessages.add(responseMessageId);
+                                if (!finalOutputTokens.has(responseMessageId)) {
+                                    const tokens = pendingOutputTokens.get(responseMessageId);
+                                    if (tokens !== undefined)
+                                        finalOutputTokens.set(responseMessageId, tokens);
+                                }
+                            }
+                            settleGeneration(responseMessageId, receiptAt);
+                        }
                         if (event?.type === 'content_block_start' &&
-                            block?.type === 'tool_use' &&
-                            typeof block.id === 'string') {
-                            const latencyMs = responseLatency.toolStarted(block.id);
-                            if (latencyMs !== undefined)
-                                this.host.emit(runId, 'run.performance', { latencyMs });
-                            // A later full snapshot of this streamed message is not a new response.
-                            responseLatency.response(responseMessageId);
+                            (block?.type === 'tool_use' ||
+                                block?.type === 'thinking' ||
+                                block?.type === 'redacted_thinking' ||
+                                block?.type === 'encrypted_thinking' ||
+                                block?.type === 'text')) {
+                            if (responseMessageId !== undefined)
+                                generationTiming.start(responseMessageId, receiptAt);
+                            if (block?.type !== 'text' ||
+                                (typeof block.text === 'string' && block.text.length > 0)) {
+                                const latencyMs = block?.type === 'tool_use' && typeof block.id === 'string'
+                                    ? responseLatency.toolStarted(block.id)
+                                    : responseLatency.response(responseMessageId);
+                                if (latencyMs !== undefined)
+                                    this.host.emit(runId, 'run.performance', { latencyMs });
+                                if (block?.type === 'tool_use')
+                                    responseLatency.response(responseMessageId);
+                            }
                         }
                         if ((event?.type === 'content_block_start' && block?.type === 'thinking') ||
                             (event?.type === 'content_block_delta' &&
@@ -264,12 +322,27 @@ export class ClaudeManagedRunController {
                                         delta.thinking.length > 0) ||
                                     (delta?.type === 'input_json_delta' &&
                                         typeof delta.partial_json === 'string' &&
-                                        delta.partial_json.length > 0))))
+                                        delta.partial_json.length > 0)))) {
+                            if (responseMessageId !== undefined)
+                                generationTiming.start(responseMessageId, receiptAt);
                             observeResponse(responseMessageId, event?.type === 'content_block_delta');
+                        }
                     }
                     if (record.type === 'assistant') {
+                        const snapshotMessage = record.message;
+                        const snapshotId = typeof snapshotMessage?.id === 'string' ? snapshotMessage.id : undefined;
+                        const snapshotUsage = snapshotMessage?.usage;
+                        if (mainTask &&
+                            snapshotId !== undefined &&
+                            typeof snapshotUsage?.output_tokens === 'number' &&
+                            (completedMessages.has(snapshotId) ||
+                                (typeof snapshotMessage?.stop_reason === 'string' &&
+                                    snapshotMessage.stop_reason.length > 0))) {
+                            finalOutputTokens.set(snapshotId, snapshotUsage.output_tokens);
+                            settleGeneration(snapshotId, receiptAt);
+                        }
                         const text = extractClaudeText(record);
-                        if (text.length > 0 || extractClaudeThinkingSummaries(record).length > 0)
+                        if (mainTask && (text.length > 0 || extractClaudeThinkingSummaries(record).length > 0))
                             observeResponse(typeof record.message?.id === 'string'
                                 ? record.message.id
                                 : undefined);
@@ -292,7 +365,7 @@ export class ClaudeManagedRunController {
                             });
                         }
                         for (const tool of extractClaudeToolUses(record)) {
-                            const latencyMs = responseLatency.toolStarted(tool.id);
+                            const latencyMs = mainTask ? responseLatency.toolStarted(tool.id) : undefined;
                             if (latencyMs !== undefined)
                                 this.host.emit(runId, 'run.performance', { latencyMs });
                             if (tool.name === 'AskUserQuestion') {
@@ -358,7 +431,8 @@ export class ClaudeManagedRunController {
                     }
                     if (record.type === 'user') {
                         for (const result of extractClaudeToolResults(record)) {
-                            responseLatency.toolCompleted(result.toolUseId);
+                            if (mainTask)
+                                responseLatency.toolCompleted(result.toolUseId);
                             const kind = toolKinds.get(result.toolUseId) ?? 'tool_call';
                             if (kind === 'user_input_request')
                                 continue;

package/dist/runner/codex/managed-run-controller.js

@@ -4,6 +4,7 @@ import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
 import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
+import { GenerationTimingTracker } from '../../service/generation-timing-tracker.js';
 import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
 export function resolveCodexNotificationRun(runs, input) {
     const entries = [...runs.entries()];
@@ -137,6 +138,7 @@ export class CodexManagedRunController {
         if (run === undefined)
             return;
         const [runId, activeRun] = run;
+        const receiptAt = activeRun.generationTiming?.timestamp();
         if (notification.method === 'turn/started' && turnId !== undefined) {
             const active = this.runner.execution.runs.get(runId);
             if (active !== undefined)
@@ -144,6 +146,16 @@ export class CodexManagedRunController {
             this.host.emit(runId, 'run.running', { threadId, turnId }, 'RUNNING');
             return;
         }
+        if (notification.method === 'rawResponseItem/completed')
+            return;
+        if (notification.method === 'rawResponse/completed') {
+            this.completeRawResponse(runId, params, activeRun, receiptAt);
+            return;
+        }
+        if (notification.method === 'thread/tokenUsage/updated') {
+            this.completeStandardUsage(runId, params, activeRun, receiptAt);
+            return;
+        }
         if (notification.method === 'thread/goal/updated' &&
             activeRun.goalMcp === true &&
             turnId !== undefined &&
@@ -168,6 +180,7 @@ export class CodexManagedRunController {
         if (notification.requestId !== undefined &&
             (notification.method === 'item/commandExecution/requestApproval' ||
                 notification.method === 'item/fileChange/requestApproval')) {
+            this.pauseGeneration(runId, receiptAt);
             this.requestApproval(runId, {
                 ...notification,
                 requestId: notification.requestId
@@ -176,6 +189,7 @@ export class CodexManagedRunController {
         }
         if (notification.requestId !== undefined &&
             notification.method === 'item/tool/requestUserInput') {
+            this.pauseGeneration(runId, receiptAt);
             this.requestUserInput(runId, notification.requestId, params);
             return;
         }
@@ -200,15 +214,19 @@ export class CodexManagedRunController {
                 text: params.delta,
                 ...(itemId === undefined ? {} : { itemId })
             });
+            if (params.delta.length > 0)
+                this.beginGeneration(runId, receiptAt);
             if (params.delta.length > 0)
                 this.observeResponse(runId, itemId, true);
             return;
         }
         if (notification.method === 'item/reasoning/textDelta' && typeof params.delta === 'string') {
-            if (params.delta.length > 0)
+            if (params.delta.length > 0) {
+                this.beginGeneration(runId, receiptAt);
                 this.observeResponse(runId, typeof params.itemId === 'string'
                     ? boundedConversationItemId('codex', params.itemId)
                     : undefined, true);
+            }
             return;
         }
         if (notification.method === 'item/reasoning/summaryTextDelta' &&
@@ -225,8 +243,10 @@ export class CodexManagedRunController {
                 merge: true,
                 append: 'sections'
             });
-            if (params.delta.length > 0)
+            if (params.delta.length > 0) {
+                this.beginGeneration(runId, receiptAt);
                 this.observeResponse(runId, boundedConversationItemId('codex', params.itemId), true);
+            }
             return;
         }
         if (notification.method === 'item/commandExecution/outputDelta' &&
@@ -260,9 +280,25 @@ export class CodexManagedRunController {
             const item = codexLiveConversationItem(params.item, notification.method === 'item/completed', attachments);
             if (item !== undefined) {
                 this.host.emitItem(runId, item);
+                if (item.kind === 'context_compaction') {
+                    activeRun.generationCompacting = notification.method === 'item/started';
+                    if (activeRun.generationCompacting) {
+                        for (const key of activeRun.generationKeys ?? [])
+                            activeRun.generationTiming?.discard(key);
+                        activeRun.generationKeys = [];
+                        activeRun.currentGenerationKey = undefined;
+                    }
+                    return;
+                }
                 const tracker = activeRun.responseLatency;
                 const tool = ['tool_call', 'command_execution', 'file_change'].includes(item.kind);
                 if (tool) {
+                    if (notification.method === 'item/started') {
+                        if (codexToolGeneratesArguments(params.item))
+                            this.beginGeneration(runId, receiptAt);
+                        else
+                            this.pauseGeneration(runId, receiptAt);
+                    }
                     if (notification.method === 'item/completed')
                         tracker?.toolCompleted(item.itemId);
                     else {
@@ -273,12 +309,15 @@ export class CodexManagedRunController {
                 }
                 else if (['assistant_message', 'reasoning_summary', 'plan'].includes(item.kind)) {
                     // A started reasoning item is itself a semantic response, even before its summary.
+                    if (notification.method === 'item/started')
+                        this.beginGeneration(runId, receiptAt);
                     this.observeResponse(runId, item.itemId);
                 }
             }
             return;
         }
         if (notification.method === 'turn/completed') {
+            this.endPendingGenerations(activeRun, receiptAt);
             const status = turn?.status;
             const terminal = status === 'completed' ? 'SUCCEEDED' : status === 'interrupted' ? 'INTERRUPTED' : 'FAILED';
             if (terminal === 'FAILED')
@@ -308,6 +347,87 @@ export class CodexManagedRunController {
         if (latencyMs !== undefined)
             this.host.emit(runId, 'run.performance', { latencyMs });
     }
+    beginGeneration(runId, observedAt) {
+        const active = this.runner.execution.runs.get(runId);
+        if (active?.generationTiming === undefined || active.generationCompacting === true)
+            return;
+        let key = active.currentGenerationKey;
+        if (key === undefined) {
+            const sequence = (active.generationRequestSequence ?? 0) + 1;
+            key = `${active.turnId ?? active.threadId}:generation:${sequence}`;
+            active.generationKeys ??= [];
+            active.generationKeys.push(key);
+            active.generationRequestSequence = sequence;
+            active.currentGenerationKey = key;
+        }
+        active.generationTiming.start(key, observedAt);
+    }
+    pauseGeneration(runId, observedAt) {
+        const active = this.runner.execution.runs.get(runId);
+        const key = active?.currentGenerationKey;
+        if (active?.generationTiming === undefined || key === undefined)
+            return;
+        active.generationTiming.pause(key, observedAt);
+    }
+    endPendingGenerations(active, observedAt) {
+        if (active.generationTiming === undefined)
+            return;
+        for (const key of active.generationKeys ?? [])
+            active.generationTiming.end(key, observedAt);
+    }
+    completeRawResponse(runId, params, active, observedAt) {
+        const responseId = typeof params.responseId === 'string' ? params.responseId : undefined;
+        if (responseId === undefined || active.completedGenerationResponseIds?.has(responseId))
+            return;
+        active.completedGenerationResponseIds ??= new Set();
+        active.completedGenerationResponseIds.add(responseId);
+        if (active.generationCompacting === true)
+            return;
+        const key = active.generationResponseIds?.get(responseId) ??
+            active.currentGenerationKey ??
+            active.generationKeys?.find((candidate) => active.generationTiming?.has(candidate));
+        if (key === undefined || active.generationTiming === undefined)
+            return;
+        active.generationResponseIds ??= new Map();
+        active.generationResponseIds.set(responseId, key);
+        active.generationTiming.end(key, observedAt);
+        if (active.currentGenerationKey === key)
+            active.currentGenerationKey = undefined;
+        const outputTokens = codexOutputTokens(params.usage);
+        if (outputTokens === undefined)
+            return;
+        this.emitGenerationTps(runId, active, key, outputTokens, observedAt);
+    }
+    completeStandardUsage(runId, params, active, observedAt) {
+        if (active.generationTiming === undefined)
+            return;
+        const usage = isPlainRecord(params.tokenUsage) ? params.tokenUsage : undefined;
+        const outputTokens = codexOutputTokens(usage?.last);
+        if (outputTokens === undefined)
+            return;
+        // TokenCount also repeats the previous request's snapshot (for example after compaction).
+        // Include total counters to distinguish equal last counts from distinct model requests.
+        const snapshot = JSON.stringify([
+            codexUsageCounters(usage?.last),
+            codexUsageCounters(usage?.total)
+        ]);
+        if (active.generationUsageSnapshot === snapshot)
+            return;
+        active.generationUsageSnapshot = snapshot;
+        if (active.generationCompacting === true)
+            return;
+        const key = active.generationKeys?.find((candidate) => active.generationTiming?.has(candidate));
+        if (key !== undefined)
+            this.emitGenerationTps(runId, active, key, outputTokens, observedAt);
+    }
+    emitGenerationTps(runId, active, key, outputTokens, observedAt) {
+        const result = active.generationTiming?.settle(key, outputTokens, observedAt);
+        if (result !== undefined)
+            this.host.emit(runId, 'run.performance', { tokensPerSecond: result.tokensPerSecond });
+        active.generationKeys = active.generationKeys?.filter((candidate) => candidate !== key);
+        if (active.currentGenerationKey === key)
+            active.currentGenerationKey = undefined;
+    }
     requestApproval(runId, notification) {
         const approvalId = `codex:${runId}:${notification.requestId}`;
         const expiresAt = Date.now() + 10 * 60_000;
@@ -494,7 +614,11 @@ export class CodexManagedRunController {
                         cwd,
                         goalMcp: hasGoalMcp(payload.mcpServers),
                         scheduleMcp: hasScheduleMcp(payload.mcpServers),
-                        responseLatency: new ResponseLatencyTracker()
+                        responseLatency: new ResponseLatencyTracker(),
+                        generationTiming: new GenerationTimingTracker(),
+                        generationKeys: [],
+                        generationResponseIds: new Map(),
+                        completedGenerationResponseIds: new Set()
                     });
                     turnResult = await this.runner.startTurn(threadId, input, cwd, turnConfiguration, materializedAttachments, runId);
                     break;
@@ -560,3 +684,25 @@ function hasGoalMcp(value) {
 function hasScheduleMcp(value) {
     return isPlainRecord(value) && isPlainRecord(value.mar_schedule);
 }
+function codexOutputTokens(value) {
+    if (!isPlainRecord(value) ||
+        typeof value.outputTokens !== 'number' ||
+        !Number.isSafeInteger(value.outputTokens) ||
+        value.outputTokens < 0)
+        return undefined;
+    return value.outputTokens;
+}
+function codexToolGeneratesArguments(value) {
+    return ['functionCall', 'function_call', 'customToolCall', 'custom_tool_call'].includes(typeof value.type === 'string' ? value.type : '');
+}
+function codexUsageCounters(value) {
+    if (!isPlainRecord(value))
+        return undefined;
+    return [
+        value.inputTokens,
+        value.cachedInputTokens,
+        value.outputTokens,
+        value.reasoningOutputTokens,
+        value.totalTokens
+    ];
+}

package/dist/runner/mar-agent/managed-run-controller.js

@@ -832,7 +832,7 @@ export class MarAgentManagedRunController {
             this.host.refreshContext?.(runId);
         if (event.type === 'model.performance')
             this.host.emit(runId, 'run.performance', {
-                latencyMs: event.latencyMs,
+                ...(event.latencyMs === undefined ? {} : { latencyMs: event.latencyMs }),
                 ...(event.tokensPerSecond === undefined ? {} : { tokensPerSecond: event.tokensPerSecond })
             });
         else if (event.type === 'message.delta')

package/dist/runner/opencode/managed-run-controller.js

@@ -5,6 +5,7 @@ import { boundedConversationItemId, compactRunnerText } from '../codex/conversat
 import { openCodePatchToolPayload, openCodeQuestions } from './conversation-parser.js';
 import { normalizeOpenCodeTool } from './tool-normalizer.js';
 import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
+import { GenerationTimingTracker } from '../../service/generation-timing-tracker.js';
 export class OpenCodeManagedRunController {
     runner;
     host;
@@ -272,6 +273,7 @@ export class OpenCodeManagedRunController {
                 execution.responsePartKinds = new Map();
                 execution.responseStartedAt = Date.now();
                 execution.responseMessages = new Set();
+                execution.generationTiming = new GenerationTimingTracker();
             }
             await client.prompt({
                 directory: input.cwd,
@@ -295,6 +297,8 @@ export class OpenCodeManagedRunController {
         const event = record(value);
         const properties = record(event?.properties);
         const nested = record(properties?.part) ?? record(properties?.info);
+        const execution = this.runner.execution.get(runId);
+        const receiptAt = execution?.generationTiming?.timestamp();
         const sessionID = typeof properties?.sessionID === 'string'
             ? properties.sessionID
             : typeof nested?.sessionID === 'string'
@@ -325,8 +329,10 @@ export class OpenCodeManagedRunController {
                 if (info.role === 'assistant' &&
                     execution?.responseStartedAt !== undefined &&
                     typeof created === 'number' &&
-                    created >= execution.responseStartedAt)
+                    created >= execution.responseStartedAt) {
                     execution.responseMessages?.add(info.id);
+                    execution.currentResponseMessageId = info.id;
+                }
             }
             if (info?.role === 'assistant' &&
                 typeof info.id === 'string' &&
@@ -358,8 +364,12 @@ export class OpenCodeManagedRunController {
                 typeof properties.delta === 'string' &&
                 properties.delta.length > 0 &&
                 typeof properties.messageID === 'string' &&
-                this.currentResponseMessage(runId, properties.messageID))
+                this.currentResponseMessage(runId, properties.messageID)) {
+                const key = this.generationKey(runId, properties.messageID, properties.partID);
+                if (key !== undefined)
+                    execution?.generationTiming?.start(key, receiptAt);
                 this.observeResponse(runId, boundedConversationItemId('opencode', properties.partID), true);
+            }
             return;
         }
         if (event?.type === 'message.part.updated') {
@@ -386,36 +396,91 @@ export class OpenCodeManagedRunController {
                 return;
             if (typeof part.id === 'string' && typeof part.type === 'string')
                 this.runner.execution.get(runId)?.responsePartKinds?.set(part.id, part.type);
+            const tracker = this.currentResponseMessage(runId, part.messageID)
+                ? execution?.generationTiming
+                : undefined;
+            if (part.type === 'step-start') {
+                if (tracker !== undefined && typeof part.id === 'string')
+                    this.generationKey(runId, part.messageID, part.id, receiptAt, true);
+                return;
+            }
+            if (part.type === 'step-finish') {
+                const key = typeof part.id === 'string'
+                    ? (execution?.generationPartKeys?.get(part.id) ??
+                        execution?.generationRequestKeys?.get(part.messageID))
+                    : undefined;
+                if (tracker !== undefined && key !== undefined && typeof part.id === 'string') {
+                    execution?.generationPartKeys?.set(part.id, key);
+                    tracker.end(key, receiptAt);
+                    if (execution?.generationRequestKeys?.get(part.messageID) === key)
+                        execution.generationRequestKeys.delete(part.messageID);
+                    const outputTokens = openCodeOutputTokens(part.tokens);
+                    if (outputTokens !== undefined) {
+                        const result = tracker.settle(key, outputTokens, receiptAt);
+                        if (result !== undefined)
+                            this.host.emit(runId, 'run.performance', { tokensPerSecond: result.tokensPerSecond });
+                    }
+                }
+                return;
+            }
             const item = openCodePart(part, this.runner.execution.get(runId)?.agent === 'plan');
             if (item !== undefined)
                 this.host.emitItem(runId, item);
             if (typeof part.id === 'string') {
                 const itemId = boundedConversationItemId('opencode', part.id);
-                const tracker = this.currentResponseMessage(runId, part.messageID)
-                    ? this.runner.execution.get(runId)?.responseLatency
+                const responseLatency = this.currentResponseMessage(runId, part.messageID)
+                    ? execution?.responseLatency
+                    : undefined;
+                const generationTiming = this.currentResponseMessage(runId, part.messageID)
+                    ? execution?.generationTiming
                     : undefined;
+                const generationKey = generationTiming === undefined
+                    ? undefined
+                    : this.generationKey(runId, part.messageID, part.id);
                 if (part.type === 'tool') {
                     const state = record(part.state);
-                    if (state?.status === 'completed' || state?.status === 'error')
-                        tracker?.toolCompleted(itemId);
-                    else if (state?.status === 'pending' || state?.status === 'running') {
-                        const latencyMs = tracker?.toolStarted(itemId);
+                    if (state?.status === 'pending') {
+                        if (generationKey !== undefined)
+                            generationTiming?.start(generationKey, receiptAt);
+                        const latencyMs = responseLatency?.toolStarted(itemId);
+                        if (latencyMs !== undefined)
+                            this.host.emit(runId, 'run.performance', { latencyMs });
+                    }
+                    else if (state?.status === 'running') {
+                        if (generationKey !== undefined)
+                            generationTiming?.pause(generationKey, receiptAt);
+                        const latencyMs = responseLatency?.toolStarted(itemId);
                         if (latencyMs !== undefined)
                             this.host.emit(runId, 'run.performance', { latencyMs });
                     }
+                    else if (state?.status === 'completed' || state?.status === 'error') {
+                        if (generationKey !== undefined)
+                            generationTiming?.pause(generationKey, receiptAt);
+                        responseLatency?.toolCompleted(itemId);
+                    }
                 }
-                else if (tracker !== undefined &&
+                else if (generationTiming !== undefined &&
+                    generationKey !== undefined &&
                     (part.type === 'text' || part.type === 'reasoning') &&
-                    typeof part.text === 'string' &&
-                    part.text.length > 0)
-                    this.observeResponse(runId, itemId);
+                    typeof part.text === 'string') {
+                    if (isOpenCodeGenerationStart(part.time))
+                        generationTiming.start(generationKey, receiptAt);
+                    if (isOpenCodeGenerationEnd(part.time))
+                        generationTiming.pause(generationKey, receiptAt);
+                    if (part.text.length > 0)
+                        this.observeResponse(runId, itemId);
+                }
             }
             return;
         }
-        if (event?.type === 'permission.asked')
+        if (event?.type === 'permission.asked') {
+            this.pauseCurrentGeneration(runId, receiptAt);
             this.requestPermission(runId, properties);
-        if (event?.type === 'question.asked')
+        }
+        if (event?.type === 'question.asked') {
+            this.pauseCurrentGeneration(runId, receiptAt);
             this.requestQuestion(runId, properties);
+        }
     }
     currentResponseMessage(runId, messageId) {
         const parent = this.messageParents.get(runId)?.get(messageId);
@@ -430,6 +495,37 @@ export class OpenCodeManagedRunController {
         if (latencyMs !== undefined)
             this.host.emit(runId, 'run.performance', { latencyMs });
     }
+    pauseCurrentGeneration(runId, observedAt) {
+        const execution = this.runner.execution.get(runId);
+        const key = execution?.currentResponseMessageId === undefined
+            ? undefined
+            : execution.generationRequestKeys?.get(execution.currentResponseMessageId);
+        if (key !== undefined)
+            execution?.generationTiming?.pause(key, observedAt);
+    }
+    generationKey(runId, messageId, partId, observedAt, newRequest = false) {
+        const execution = this.runner.execution.get(runId);
+        if (execution?.generationTiming === undefined)
+            return undefined;
+        execution.generationPartKeys ??= new Map();
+        const existing = execution.generationPartKeys.get(partId);
+        if (existing !== undefined)
+            return existing;
+        execution.generationRequestKeys ??= new Map();
+        let key = execution.generationRequestKeys.get(messageId);
+        if (newRequest && key !== undefined) {
+            execution.generationTiming.end(key, observedAt);
+            key = undefined;
+        }
+        if (key === undefined) {
+            const sequence = (execution.generationRequestSequence ?? 0) + 1;
+            execution.generationRequestSequence = sequence;
+            key = `${messageId}:generation:${sequence}`;
+            execution.generationRequestKeys.set(messageId, key);
+        }
+        execution.generationPartKeys.set(partId, key);
+        return key;
+    }
     requestPermission(runId, properties) {
         const execution = this.runner.execution.get(runId);
         const requestId = typeof properties?.id === 'string' ? properties.id : undefined;
@@ -655,3 +751,21 @@ function record(value) {
         ? value
         : undefined;
 }
+function isOpenCodeGenerationStart(value) {
+    return typeof record(value)?.start === 'number';
+}
+function isOpenCodeGenerationEnd(value) {
+    return typeof record(value)?.end === 'number';
+}
+function openCodeOutputTokens(value) {
+    const tokens = record(value);
+    const output = tokens?.output;
+    const reasoning = tokens?.reasoning;
+    if (!Number.isSafeInteger(output) ||
+        !Number.isSafeInteger(reasoning) ||
+        output < 0 ||
+        reasoning < 0 ||
+        output + reasoning > Number.MAX_SAFE_INTEGER)
+        return undefined;
+    return output + reasoning;
+}

package/dist/service/generation-timing-tracker.js

@@ -0,0 +1,81 @@
+export class GenerationTimingTracker {
+    now;
+    requests = new Map();
+    constructor(now = () => performance.now()) {
+        this.now = now;
+    }
+    timestamp() {
+        return this.now();
+    }
+    start(key, observedAt) {
+        const at = observedAt ?? this.now();
+        const request = this.requests.get(key) ?? {
+            started: false,
+            durationMs: 0,
+            ended: false,
+            settled: false,
+            invalid: false
+        };
+        this.observe(request, at);
+        if (request.ended || request.settled || request.invalid || request.runningAt !== undefined)
+            return false;
+        request.started = true;
+        request.runningAt = at;
+        this.requests.set(key, request);
+        return true;
+    }
+    pause(key, observedAt) {
+        const request = this.requests.get(key);
+        if (request === undefined || request.settled)
+            return;
+        const at = observedAt ?? this.now();
+        this.observe(request, at);
+        if (request.runningAt === undefined)
+            return;
+        const duration = at - request.runningAt;
+        if (!(duration >= 0))
+            request.invalid = true;
+        else
+            request.durationMs += duration;
+        request.runningAt = undefined;
+    }
+    end(key, observedAt) {
+        const request = this.requests.get(key);
+        if (request === undefined || request.settled || request.ended)
+            return;
+        this.pause(key, observedAt);
+        request.ended = true;
+    }
+    settle(key, outputTokens, observedAt) {
+        const request = this.requests.get(key);
+        if (request === undefined ||
+            request.settled ||
+            !request.started ||
+            request.invalid ||
+            !Number.isSafeInteger(outputTokens) ||
+            outputTokens < 0)
+            return undefined;
+        this.end(key, observedAt);
+        request.settled = true;
+        if (request.invalid || request.durationMs < 1)
+            return undefined;
+        return {
+            outputTokens,
+            durationMs: request.durationMs,
+            tokensPerSecond: Math.round((outputTokens * 100_000) / request.durationMs) / 100
+        };
+    }
+    discard(key) {
+        this.requests.delete(key);
+    }
+    has(key) {
+        return this.requests.has(key);
+    }
+    observe(request, observedAt) {
+        if (!Number.isFinite(observedAt) ||
+            (request.lastAt !== undefined && observedAt < request.lastAt))
+            request.invalid = true;
+        if (Number.isFinite(observedAt))
+            request.lastAt = observedAt;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.174",
+  "version": "0.9.175",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -36,10 +36,10 @@
     "playwright": "1.62.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.9.174",
-    "@myagentroam/protocol": "0.9.174",
-    "@myagentroam/code-navigation": "0.9.129",
-    "@myagentroam/marctl": "0.9.123"
+    "@myagentroam/agent": "0.9.175",
+    "@myagentroam/marctl": "0.9.123",
+    "@myagentroam/protocol": "0.9.175",
+    "@myagentroam/code-navigation": "0.9.129"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"