@myagentroam/agent 0.9.174 → 0.9.175

package/dist/agent-core/extensions/model-stream.js

@@ -59,7 +59,10 @@ function validEvent(event) {
             return typeof event.sourceRef === 'string';
         case 'response.started':
             return typeof event.responseId === 'string';
+        case 'output.started':
         case 'output.delta':
+        case 'output.paused':
+        case 'output.completed':
         case 'output.reset':
             return true;
         case 'text.delta':
@@ -87,7 +90,8 @@ function validEvent(event) {
                 typeof event.citation.id === 'string' &&
                 typeof event.citation.url === 'string');
         case 'usage':
-            return (!!event.usage &&
+            return ((event.final === undefined || typeof event.final === 'boolean') &&
+                !!event.usage &&
                 typeof event.usage === 'object' &&
                 Object.values(event.usage).every((value) => value === undefined ||
                     (typeof value === 'number' && Number.isFinite(value) && value >= 0)));

package/dist/agent-core/model/anthropic-messages.js

@@ -39,7 +39,7 @@ export class AnthropicMessagesAdapter {
             await reportModelAttempt(request, { ...attemptDiagnostic, state: 'STARTED' });
             try {
                 for await (const event of this.startAttempt(request, signal)) {
-                    if (event.type === 'output.delta') {
+                    if (event.type.startsWith('output.')) {
                         resetOutputTiming = true;
                         yield event;
                         continue;
@@ -150,18 +150,19 @@ export class AnthropicMessagesAdapter {
             if (type === 'message_start') {
                 const message = record(event.message);
                 responseId = text(message.id) ?? responseId;
-                yield { type: 'response.started', responseId };
+                yield observeModelStreamEvent({ type: 'response.started', responseId }, modelStreamEventObservedAt(raw));
                 const usage = record(message.usage);
                 const inputTokens = inputTokenCount(usage.input_tokens);
                 const cacheReadTokens = inputTokenCount(usage.cache_read_input_tokens);
                 const cacheWriteTokens = inputTokenCount(usage.cache_creation_input_tokens);
                 latestInputUsage = inputUsage(inputTokens, cacheReadTokens, cacheWriteTokens);
-                yield {
+                yield observeModelStreamEvent({
                     type: 'usage',
+                    final: false,
                     usage: {
                         ...latestInputUsage
                     }
-                };
+                }, modelStreamEventObservedAt(raw));
             }
             else if (type === 'content_block_start') {
                 const block = record(event.content_block);
@@ -174,16 +175,18 @@ export class AnthropicMessagesAdapter {
                     for (const blockIndex of pendingTextBlocks) {
                         const pending = blocks.get(blockIndex);
                         if (pending?.type === 'text')
-                            yield {
+                            yield observeModelStreamEvent({
                                 type: 'text.completed',
                                 itemId: pending.id,
                                 phase: 'commentary',
                                 text: pending.text
-                            };
+                            }, modelStreamEventObservedAt(raw));
                     }
                     pendingTextBlocks.clear();
                 }
                 const id = text(block.id) ?? `${responseId}:content-${index}`;
+                if (['text', 'thinking', 'redacted_thinking', 'tool_use', 'server_tool_use'].includes(blockType))
+                    yield observeModelStreamEvent({ type: 'output.started' }, modelStreamEventObservedAt(raw));
                 blocks.set(index, {
                     type: blockType,
                     id,
@@ -194,18 +197,18 @@ export class AnthropicMessagesAdapter {
                     ...(blockType === 'redacted_thinking' ? { data: block.data } : {})
                 });
                 if (blockType === 'text' && text(block.text))
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'text.delta',
                         itemId: id,
                         phase: 'commentary',
                         delta: text(block.text) ?? ''
-                    };
+                    }, modelStreamEventObservedAt(raw));
                 else if (blockType === 'server_tool_use') {
                     const toolName = text(block.name) ?? 'unknown';
                     const kind = toolName === 'web_fetch' ? 'WEB_FETCH' : 'WEB_SEARCH';
                     const summary = anthropicHostedInputSummary(record(block.input));
                     hostedTools.set(id, { kind, toolName, summary });
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'hosted_tool',
                         itemId: id,
                         kind,
@@ -213,7 +216,7 @@ export class AnthropicMessagesAdapter {
                         ...(Object.keys(summary).length ? { input: summary } : {}),
                         status: 'RUNNING',
                         summary
-                    };
+                    }, modelStreamEventObservedAt(raw));
                 }
                 else if (blockType === 'web_search_tool_result' ||
                     blockType === 'web_fetch_tool_result') {
@@ -228,7 +231,7 @@ export class AnthropicMessagesAdapter {
                             ...(Array.isArray(result) && result.length > 20 ? { sourcesTruncated: true } : {})
                         };
                         hostedTools.set(toolId, { ...hosted, summary });
-                        yield {
+                        yield observeModelStreamEvent({
                             type: 'hosted_tool',
                             itemId: toolId,
                             kind: hosted.kind,
@@ -247,7 +250,7 @@ export class AnthropicMessagesAdapter {
                             ...(summary.sourcesTruncated ? { truncated: true } : {}),
                             status: anthropicHostedResultFailed(result) ? 'FAILED' : 'COMPLETED',
                             summary
-                        };
+                        }, modelStreamEventObservedAt(raw));
                     }
                 }
             }
@@ -283,10 +286,10 @@ export class AnthropicMessagesAdapter {
                     const citation = record(delta.citation);
                     const url = text(citation.url);
                     if (url)
-                        yield {
+                        yield observeModelStreamEvent({
                             type: 'citation',
                             citation: { id: `${block.id}-citation`, url, title: text(citation.title) }
-                        };
+                        }, modelStreamEventObservedAt(raw));
                 }
             }
             else if (type === 'content_block_stop') {
@@ -302,12 +305,13 @@ export class AnthropicMessagesAdapter {
                             throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Anthropic returned an invalid or oversized native thinking block.');
                         thinkingBytes += Buffer.byteLength(JSON.stringify(item));
                         assertAnthropicThinkingBudget(thinkingBytes);
-                        yield { type: 'response.item', provider: 'ANTHROPIC_MESSAGES', item };
+                        yield observeModelStreamEvent({ type: 'response.item', provider: 'ANTHROPIC_MESSAGES', item }, modelStreamEventObservedAt(raw));
                     }
                     if (block.type === 'thinking' && block.text)
-                        yield { type: 'reasoning.summary', itemId: block.id, text: block.text };
+                        yield observeModelStreamEvent({ type: 'reasoning.summary', itemId: block.id, text: block.text }, modelStreamEventObservedAt(raw));
                 }
                 else if (block?.type === 'server_tool_use') {
+                    yield observeModelStreamEvent({ type: 'output.paused' }, modelStreamEventObservedAt(raw));
                     const hosted = hostedTools.get(block.id);
                     if (hosted !== undefined) {
                         let input;
@@ -320,7 +324,7 @@ export class AnthropicMessagesAdapter {
                         const summary = { ...hosted.summary, ...anthropicHostedInputSummary(record(input)) };
                         if (summary.query !== hosted.summary.query || summary.url !== hosted.summary.url) {
                             hostedTools.set(block.id, { ...hosted, summary });
-                            yield {
+                            yield observeModelStreamEvent({
                                 type: 'hosted_tool',
                                 itemId: block.id,
                                 kind: hosted.kind,
@@ -328,7 +332,7 @@ export class AnthropicMessagesAdapter {
                                 input: anthropicHostedInputSummary(record(input)),
                                 status: 'RUNNING',
                                 summary
-                            };
+                            }, modelStreamEventObservedAt(raw));
                         }
                     }
                 }
@@ -341,18 +345,20 @@ export class AnthropicMessagesAdapter {
                     catch {
                         argumentError = 'Tool arguments are invalid JSON.';
                     }
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'client_tool.call',
                         callId: block.id,
                         name: block.name ?? 'unknown',
                         arguments: args,
                         ...(argumentError ? { argumentError } : {})
-                    };
+                    }, modelStreamEventObservedAt(raw));
                 }
             }
             else if (type === 'message_delta') {
                 const delta = record(event.delta);
                 const reason = text(delta.stop_reason);
+                if (reason !== undefined)
+                    yield observeModelStreamEvent({ type: 'output.completed' }, modelStreamEventObservedAt(raw));
                 terminal =
                     reason === 'tool_use'
                         ? 'tool_use'
@@ -365,7 +371,7 @@ export class AnthropicMessagesAdapter {
                 for (const blockIndex of pendingTextBlocks) {
                     const block = blocks.get(blockIndex);
                     if (block?.type === 'text')
-                        yield { type: 'text.completed', itemId: block.id, phase, text: block.text };
+                        yield observeModelStreamEvent({ type: 'text.completed', itemId: block.id, phase, text: block.text }, modelStreamEventObservedAt(raw));
                 }
                 pendingTextBlocks.clear();
                 const usage = record(event.usage);
@@ -376,13 +382,14 @@ export class AnthropicMessagesAdapter {
                 const zeroPlaceholder = inputTokens === 0 && cacheReadTokens === 0 && cacheWriteTokens === 0;
                 if (!zeroPlaceholder)
                     latestInputUsage = inputUsage(inputTokens ?? latestInputUsage?.inputTokens, cacheReadTokens ?? latestInputUsage?.cacheReadTokens, cacheWriteTokens ?? latestInputUsage?.cacheWriteTokens);
-                yield {
+                yield observeModelStreamEvent({
                     type: 'usage',
+                    final: reason !== undefined,
                     usage: {
                         ...latestInputUsage,
                         outputTokens: number(usage.output_tokens)
                     }
-                };
+                }, modelStreamEventObservedAt(raw));
             }
             else if (type === 'message_stop') {
                 yield observeModelStreamEvent({ type: 'completed', reason: terminal ?? 'completed' }, modelStreamEventObservedAt(raw));
@@ -400,7 +407,7 @@ export class AnthropicMessagesAdapter {
                     : {});
             }
             else
-                yield { type: 'unknown', nativeType: type };
+                yield observeModelStreamEvent({ type: 'unknown', nativeType: type }, modelStreamEventObservedAt(raw));
         }
         if (terminal === undefined)
             throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Anthropic Messages stream ended without a terminal event.', {
@@ -463,6 +470,8 @@ function anthropicHostedResultFailed(result) {
     return entries.some((entry) => text(record(entry).type)?.endsWith('_tool_result_error'));
 }
 function isSemanticEvent(event) {
+    if (event.type.startsWith('output.'))
+        return false;
     return event.type !== 'response.started' && event.type !== 'usage';
 }
 export function isAnthropicRecoverableStreamError(error) {

package/dist/agent-core/model/contracts.d.ts

@@ -119,8 +119,14 @@ export type ModelStopReason = 'completed' | 'tool_use' | 'pause' | 'max_output'
 export type ModelEvent = {
     type: 'response.started';
     responseId: string;
+} | {
+    type: 'output.started';
 } | {
     type: 'output.delta';
+} | {
+    type: 'output.paused';
+} | {
+    type: 'output.completed';
 } | {
     type: 'output.reset';
 } | {
@@ -179,6 +185,7 @@ export type ModelEvent = {
 } | {
     type: 'usage';
     usage: ModelUsage;
+    final?: boolean;
 } | {
     type: 'unknown';
     nativeType: string;

package/dist/agent-core/model/openai-responses.js

@@ -115,7 +115,7 @@ export class OpenAiResponsesAdapter {
             });
             try {
                 for await (const event of this.startAttempt(request, signal, requestBody, useContinuation, credentialReason, turn)) {
-                    if (event.type === 'output.delta') {
+                    if (event.type.startsWith('output.')) {
                         resetOutputTiming = true;
                         yield event;
                         continue;
@@ -310,10 +310,15 @@ export class OpenAiResponsesAdapter {
             for await (const raw of rawEvents) {
                 const event = record(raw);
                 const type = text(event.type) ?? 'unknown';
+                if (type === 'response.output_item.added' &&
+                    ['reasoning', 'message', 'function_call', 'custom_tool_call'].includes(text(record(event.item).type) ?? ''))
+                    yield observeModelStreamEvent({ type: 'output.started' }, modelStreamEventObservedAt(raw));
+                if (type === 'response.web_search_call.searching')
+                    yield observeModelStreamEvent({ type: 'output.paused' }, modelStreamEventObservedAt(raw));
                 if (type === 'response.output_item.done') {
                     const item = responseItem(event.item);
                     if (item)
-                        yield { type: 'response.item', provider: 'OPENAI_RESPONSES', item };
+                        yield observeModelStreamEvent({ type: 'response.item', provider: 'OPENAI_RESPONSES', item }, modelStreamEventObservedAt(raw));
                 }
                 if (type === 'response.output_item.added' && text(record(event.item).type) === 'message') {
                     const item = record(event.item);
@@ -332,7 +337,7 @@ export class OpenAiResponsesAdapter {
                     if (completedText !== undefined && !emittedCompletedText.has(itemId)) {
                         emittedCompletedText.add(itemId);
                         pendingCompletedText.delete(itemId);
-                        yield { type: 'text.completed', itemId, phase, text: completedText };
+                        yield observeModelStreamEvent({ type: 'text.completed', itemId, phase, text: completedText }, modelStreamEventObservedAt(raw));
                     }
                 }
                 else if (type === 'response.output_item.added' &&
@@ -376,10 +381,10 @@ export class OpenAiResponsesAdapter {
                         yield observeModelStreamEvent({ type: 'output.delta' }, modelStreamEventObservedAt(raw));
                 }
                 else if (type === 'response.created')
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'response.started',
                         responseId: responseEventId(event) ?? 'unknown'
-                    };
+                    }, modelStreamEventObservedAt(raw));
                 else if (type === 'response.output_text.delta')
                     yield observeModelStreamEvent({
                         type: 'text.delta',
@@ -397,17 +402,17 @@ export class OpenAiResponsesAdapter {
                         continue;
                     if (phase) {
                         emittedCompletedText.add(itemId);
-                        yield { type: 'text.completed', itemId, phase, text: completedText };
+                        yield observeModelStreamEvent({ type: 'text.completed', itemId, phase, text: completedText }, modelStreamEventObservedAt(raw));
                     }
                     else
                         pendingCompletedText.set(itemId, completedText);
                 }
                 else if (type === 'response.reasoning_summary_text.done')
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'reasoning.summary',
                         itemId: text(event.item_id) ?? 'reasoning',
                         text: text(event.text) ?? ''
-                    };
+                    }, modelStreamEventObservedAt(raw));
                 else if (type === 'response.output_item.done' &&
                     text(record(event.item).type) === 'tool_search_call') {
                     const item = record(event.item);
@@ -423,13 +428,13 @@ export class OpenAiResponsesAdapter {
                         }
                     if (!emittedFunctionCalls.has(callId)) {
                         emittedFunctionCalls.add(callId);
-                        yield {
+                        yield observeModelStreamEvent({
                             type: 'client_tool.call',
                             callId,
                             name: 'tool_search',
                             arguments: arguments_,
                             ...(argumentError ? { argumentError } : {})
-                        };
+                        }, modelStreamEventObservedAt(raw));
                     }
                 }
                 else if (type === 'response.function_call_arguments.done' ||
@@ -453,13 +458,13 @@ export class OpenAiResponsesAdapter {
                         'unknown';
                     if (!emittedFunctionCalls.has(callId)) {
                         emittedFunctionCalls.add(callId);
-                        yield {
+                        yield observeModelStreamEvent({
                             type: 'client_tool.call',
                             callId,
                             name: text(event.name) ?? text(item.name) ?? known?.name ?? 'unknown',
                             arguments: args,
                             ...(argumentError ? { argumentError } : {})
-                        };
+                        }, modelStreamEventObservedAt(raw));
                     }
                 }
                 else if (type === 'response.custom_tool_call_input.done' ||
@@ -471,13 +476,13 @@ export class OpenAiResponsesAdapter {
                     const callId = text(event.call_id) ?? text(item.call_id) ?? known?.callId ?? itemId;
                     if (!emittedFunctionCalls.has(callId)) {
                         emittedFunctionCalls.add(callId);
-                        yield {
+                        yield observeModelStreamEvent({
                             type: 'client_tool.call',
                             callId,
                             name: text(event.name) ?? text(item.name) ?? known?.name ?? 'unknown',
                             arguments: text(event.input) ?? text(item.input) ?? known?.input ?? '',
                             inputMode: 'freeform'
-                        };
+                        }, modelStreamEventObservedAt(raw));
                     }
                 }
                 else if (type.includes('web_search_call') ||
@@ -502,7 +507,7 @@ export class OpenAiResponsesAdapter {
                             ? {}
                             : { sourcesTruncated: summary.sourcesTruncated })
                     };
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'hosted_tool',
                         itemId,
                         kind,
@@ -516,13 +521,13 @@ export class OpenAiResponsesAdapter {
                                 ? 'COMPLETED'
                                 : 'RUNNING',
                         summary
-                    };
+                    }, modelStreamEventObservedAt(raw));
                 }
                 else if (type === 'response.output_text.annotation.added') {
                     const annotation = record(event.annotation);
                     const url = text(annotation.url);
                     if (url)
-                        yield {
+                        yield observeModelStreamEvent({
                             type: 'citation',
                             citation: {
                                 id: text(annotation.id) ??
@@ -530,9 +535,10 @@ export class OpenAiResponsesAdapter {
                                 url,
                                 ...(text(annotation.title) ? { title: text(annotation.title) } : {})
                             }
-                        };
+                        }, modelStreamEventObservedAt(raw));
                 }
                 else if (type === 'response.completed' || type === 'response.incomplete') {
+                    yield observeModelStreamEvent({ type: 'output.completed' }, modelStreamEventObservedAt(raw));
                     const responseData = record(event.response);
                     if (type === 'response.completed')
                         turn.captureCompletedResponseId(responseEventId(event));
@@ -540,21 +546,22 @@ export class OpenAiResponsesAdapter {
                         if (emittedCompletedText.has(itemId))
                             continue;
                         emittedCompletedText.add(itemId);
-                        yield {
+                        yield observeModelStreamEvent({
                             type: 'text.completed',
                             itemId,
                             phase: textPhases.get(itemId) ?? 'final_answer',
                             text: completedText
-                        };
+                        }, modelStreamEventObservedAt(raw));
                     }
                     pendingCompletedText.clear();
                     for (const citation of responseCitations(responseData))
-                        yield { type: 'citation', citation };
+                        yield observeModelStreamEvent({ type: 'citation', citation }, modelStreamEventObservedAt(raw));
                     const usage = record(responseData.usage);
                     const inputDetails = record(usage.input_tokens_details);
                     const rolloutBudgetUnits = optionalRolloutBudgetUnits(usage.codex_rollout_budget_units);
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'usage',
+                        final: true,
                         usage: {
                             inputTokens: number(usage.input_tokens),
                             contextInputTokens: number(usage.input_tokens),
@@ -563,7 +570,7 @@ export class OpenAiResponsesAdapter {
                             cacheWriteTokens: number(inputDetails.cache_write_tokens),
                             ...(rolloutBudgetUnits === undefined ? {} : { rolloutBudgetUnits })
                         }
-                    };
+                    }, modelStreamEventObservedAt(raw));
                     yield observeModelStreamEvent({
                         type: 'completed',
                         reason: type === 'response.incomplete' ? 'max_output' : 'completed'
@@ -599,7 +606,7 @@ export class OpenAiResponsesAdapter {
                     });
                 }
                 else if (!isNonSemanticOpenAiResponsesEvent(type))
-                    yield { type: 'unknown', nativeType: type };
+                    yield observeModelStreamEvent({ type: 'unknown', nativeType: type }, modelStreamEventObservedAt(raw));
             }
         }
         catch (error) {
@@ -1387,6 +1394,8 @@ function webSocketReceiveError(cause) {
     });
 }
 function isSemanticEvent(event) {
+    if (event.type.startsWith('output.'))
+        return false;
     if (event.type === 'response.started' || event.type === 'usage' || event.type === 'response.item')
         return false;
     if (event.type === 'text.delta')

package/dist/agent-core/model/sse.js

@@ -38,18 +38,66 @@ export async function* parseSse(response, signal, maxBytes = 16 * 1024 * 1024, i
     let buffer = '';
     let total = 0;
     let streamCompleted = false;
+    const receiverAbort = new AbortController();
+    const receiverSignal = AbortSignal.any([signal, receiverAbort.signal]);
+    const chunks = [];
+    let nextChunk = 0;
+    let receivedAll = false;
+    let receiverFailure;
+    let wake;
+    const notify = () => {
+        wake?.();
+        wake = undefined;
+    };
+    // Keep transport receipt independent of async SDK publication and persistence.
+    // The cumulative response byte limit also bounds the pending raw chunk queue.
+    const receive = (async () => {
+        try {
+            while (true) {
+                const { value, done } = await readStreamChunk(reader, receiverSignal, idleTimeoutMs);
+                const observedAt = performance.now();
+                if (done) {
+                    streamCompleted = true;
+                    break;
+                }
+                total += value.byteLength;
+                enforceResponseSize(total, maxBytes);
+                if (value.byteLength === 0)
+                    continue;
+                chunks.push({ value, observedAt });
+                notify();
+            }
+        }
+        catch (error) {
+            receiverFailure = { error };
+            await reader.cancel(error).catch(() => undefined);
+        }
+        finally {
+            receivedAll = true;
+            notify();
+        }
+    })();
     try {
         while (true) {
-            if (signal.aborted)
-                throw signal.reason;
-            const { value, done } = await readStreamChunk(reader, signal, idleTimeoutMs);
-            const observedAt = performance.now();
-            if (done) {
-                streamCompleted = true;
-                break;
+            signal.throwIfAborted();
+            const chunk = chunks[nextChunk];
+            if (chunk === undefined) {
+                if (receivedAll) {
+                    if (receiverFailure !== undefined)
+                        throw receiverFailure.error;
+                    break;
+                }
+                await new Promise((resolve) => {
+                    wake = resolve;
+                });
+                continue;
             }
-            total += value.byteLength;
-            enforceResponseSize(total, maxBytes);
+            chunks[nextChunk++] = undefined;
+            if (nextChunk >= 1_024 && nextChunk * 2 >= chunks.length) {
+                chunks.splice(0, nextChunk);
+                nextChunk = 0;
+            }
+            const { value, observedAt } = chunk;
             buffer += decoder.decode(value, { stream: true }).replaceAll('\r\n', '\n');
             let boundary;
             while ((boundary = buffer.indexOf('\n\n')) >= 0) {
@@ -75,6 +123,8 @@ export async function* parseSse(response, signal, maxBytes = 16 * 1024 * 1024, i
             throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model SSE ended with an incomplete frame.');
     }
     finally {
+        receiverAbort.abort();
+        await receive;
         await closeReader(reader, streamCompleted);
     }
 }

package/dist/agent-core/runtime/events.d.ts

@@ -26,7 +26,7 @@ export type MarAgentEvent = MarAgentEventBase & ({
     modelName: string;
 } | {
     type: 'model.performance';
-    latencyMs: number;
+    latencyMs?: number | undefined;
     outputTokens?: number | undefined;
     outputDurationMs?: number | undefined;
     tokensPerSecond?: number | undefined;

package/dist/agent-core/runtime/execution.js

@@ -5,6 +5,7 @@ import { modelOutputContinuationMessage } from '../prompts/output.js';
 import { executeRoundTools } from '../tools/execution.js';
 import { publicHostedToolEvents, publicModelUsage } from './event-projection.js';
 import { PlanOutputPrefix, splitPlanOutput } from './plan-output.js';
+import { ModelGenerationTiming } from './model-generation-timing.js';
 /** Own the single model/tool loop; the SDK owns its handle, terminal events and cleanup. */
 export class ExecutionLoop {
     input;
@@ -38,8 +39,7 @@ export class ExecutionLoop {
             let sawModelSemanticEvent = false;
             let requestStartedAt;
             let firstModelResponseAt;
-            let firstOutputDeltaAt;
-            let lastOutputDeltaAt;
+            let generation = new ModelGenerationTiming();
             let requestCompletedAt;
             let requestOutputTokens;
             const roundMessageCount = messages.length;
@@ -52,19 +52,18 @@ export class ExecutionLoop {
                 });
             };
             const emitFinalPerformance = async (completedAt) => {
-                if (mode === 'compact' ||
-                    firstModelResponseAt === undefined ||
-                    firstOutputDeltaAt === undefined ||
-                    lastOutputDeltaAt === undefined ||
-                    lastOutputDeltaAt - firstOutputDeltaAt < 1)
+                if (mode === 'compact')
                     return;
-                const outputDuration = completedAt - firstOutputDeltaAt;
+                generation.finish(completedAt);
+                const outputDuration = generation.durationMs;
                 const outputTokens = requestOutputTokens;
-                if (outputTokens === undefined || outputDuration < 1 || completedAt < lastOutputDeltaAt)
+                if (outputTokens === undefined || outputDuration === undefined)
                     return;
                 await input.publish({
                     type: 'model.performance',
-                    latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt)),
+                    ...(firstModelResponseAt === undefined
+                        ? {}
+                        : { latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt)) }),
                     outputTokens,
                     outputDurationMs: Math.round(outputDuration),
                     tokensPerSecond: Number(((outputTokens * 1000) / outputDuration).toFixed(2))
@@ -91,14 +90,25 @@ export class ExecutionLoop {
                     retryState: modelRetryState
                 })) {
                     if (event.type === 'output.reset') {
-                        firstOutputDeltaAt = undefined;
-                        lastOutputDeltaAt = undefined;
+                        generation = new ModelGenerationTiming();
+                        requestCompletedAt = undefined;
                         requestOutputTokens = undefined;
                         continue;
                     }
-                    const modelResponseAt = mode !== 'compact' && isModelResponseEvent(event)
-                        ? Math.max(requestStartedAt, modelStreamEventObservedAt(event) ?? performance.now())
-                        : undefined;
+                    const observedAt = Math.max(requestStartedAt, modelStreamEventObservedAt(event) ?? performance.now());
+                    if (event.type === 'output.started') {
+                        generation.start(observedAt);
+                        continue;
+                    }
+                    if (event.type === 'output.completed') {
+                        generation.finish(observedAt);
+                        continue;
+                    }
+                    if (event.type === 'output.paused') {
+                        generation.pause(observedAt);
+                        continue;
+                    }
+                    const modelResponseAt = mode !== 'compact' && isModelResponseEvent(event) ? observedAt : undefined;
                     const isFirstModelResponse = modelResponseAt !== undefined && firstModelResponseAt === undefined;
                     if (modelResponseAt !== undefined) {
                         if (event.type !== 'output.delta')
@@ -106,8 +116,7 @@ export class ExecutionLoop {
                         firstModelResponseAt ??= modelResponseAt;
                         if (event.type === 'output.delta' ||
                             (event.type === 'text.delta' && event.delta.length > 0)) {
-                            firstOutputDeltaAt ??= modelResponseAt;
-                            lastOutputDeltaAt = modelResponseAt;
+                            generation.start(modelResponseAt);
                         }
                     }
                     if (event.type === 'response.item') {
@@ -185,14 +194,15 @@ export class ExecutionLoop {
                     }
                     else if (event.type === 'usage') {
                         latestUsage = event.usage;
+                        if (event.final === true)
+                            generation.finish(observedAt);
                         const outputTokens = typeof event.usage.outputTokens === 'number' &&
                             Number.isSafeInteger(event.usage.outputTokens) &&
                             event.usage.outputTokens >= 0
                             ? event.usage.outputTokens
                             : undefined;
-                        if (outputTokens !== undefined) {
+                        if (event.final !== false && (outputTokens !== undefined || event.final === true))
                             requestOutputTokens = outputTokens;
-                        }
                         const reportedContext = event.usage.contextInputTokens ?? event.usage.inputTokens;
                         if (reportedContext !== undefined &&
                             Number.isSafeInteger(reportedContext) &&
@@ -235,15 +245,16 @@ export class ExecutionLoop {
                     }
                     else if (event.type === 'completed') {
                         stop = event.reason;
-                        requestCompletedAt = modelStreamEventObservedAt(event) ?? performance.now();
+                        requestCompletedAt = observedAt;
                     }
                     if (isFirstModelResponse)
                         await emitLatency();
                 }
-                if (mode !== 'compact' && firstModelResponseAt !== undefined) {
-                    const completedAt = requestCompletedAt ?? performance.now();
-                    await emitFinalPerformance(completedAt);
-                }
+                if (mode !== 'compact' &&
+                    stop !== 'cancelled' &&
+                    !input.signal.aborted &&
+                    requestCompletedAt !== undefined)
+                    await emitFinalPerformance(requestCompletedAt);
                 pendingOutputContinuation = undefined;
                 incompleteToolCall = pendingTools.some((call) => call.argumentError !== undefined);
                 if (!(stop === 'max_output' && incompleteToolCall)) {

package/dist/agent-core/runtime/model-generation-timing.d.ts

@@ -0,0 +1,12 @@
+/** Request-local observed generation intervals, excluding explicit execution pauses. */
+export declare class ModelGenerationTiming {
+    private startedAt;
+    private latestAt;
+    private duration;
+    private completed;
+    private valid;
+    start(at: number): void;
+    pause(at: number): void;
+    finish(at: number): void;
+    get durationMs(): number | undefined;
+}

package/dist/agent-core/runtime/model-generation-timing.js

@@ -0,0 +1,39 @@
+/** Request-local observed generation intervals, excluding explicit execution pauses. */
+export class ModelGenerationTiming {
+    startedAt;
+    latestAt;
+    duration = 0;
+    completed = false;
+    valid = true;
+    start(at) {
+        if (this.completed)
+            return;
+        if (!Number.isFinite(at) || (this.latestAt !== undefined && at < this.latestAt)) {
+            this.valid = false;
+            return;
+        }
+        this.startedAt ??= at;
+        this.latestAt = at;
+    }
+    pause(at) {
+        if (this.completed || this.startedAt === undefined)
+            return;
+        if (!Number.isFinite(at) || at < (this.latestAt ?? this.startedAt))
+            this.valid = false;
+        else
+            this.duration += at - this.startedAt;
+        this.startedAt = undefined;
+        this.latestAt = at;
+    }
+    finish(at) {
+        if (this.completed)
+            return;
+        if (!Number.isFinite(at) || (this.latestAt !== undefined && at < this.latestAt))
+            this.valid = false;
+        this.pause(at);
+        this.completed = true;
+    }
+    get durationMs() {
+        return this.completed && this.valid && this.duration >= 1 ? this.duration : undefined;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.9.174",
+  "version": "0.9.175",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",