@myagentroam/agent 0.9.140 → 0.9.141

package/dist/model/anthropic-messages.js

@@ -1,7 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { MarAgentError } from '../error.js';
 import { resolveModelDefaultReasoningEffort } from './configuration.js';
-import { isRetryableUpstreamOverloadCode, number, parseSse, record, text } from './sse.js';
+import { isRetryableUpstreamOverloadCode, number, parseSse, record, text, observeModelStreamEvent, modelStreamEventObservedAt } from './sse.js';
 import { fetchModelResponse, modelRetryMaxAttempts, isRetryableModelRequestError, isRetryableModelTransportError, waitForModelRetry } from './http.js';
 import { anthropicThinkingBlock, assertAnthropicThinkingBudget } from './anthropic-thinking.js';
 export class AnthropicMessagesAdapter {
@@ -12,13 +12,22 @@ export class AnthropicMessagesAdapter {
     async *start(request, signal) {
         const retryState = request.retryState ?? { attempts: 0 };
         const maxAttempts = modelRetryMaxAttempts(retryState);
+        let resetOutputTiming = false;
         while (retryState.attempts < maxAttempts) {
+            if (resetOutputTiming)
+                yield { type: 'output.reset' };
+            resetOutputTiming = false;
             const attempt = retryState.attempts++;
             // Buffer non-semantic events until a semantic event makes this attempt non-retryable.
             const prelude = [];
             let sawSemanticEvent = false;
             try {
                 for await (const event of this.startAttempt(request, signal)) {
+                    if (event.type === 'output.delta') {
+                        resetOutputTiming = true;
+                        yield event;
+                        continue;
+                    }
                     if (!sawSemanticEvent && !isSemanticEvent(event)) {
                         prelude.push(event);
                         continue;
@@ -193,17 +202,25 @@ export class AnthropicMessagesAdapter {
                 if (deltaType === 'text_delta') {
                     const value = text(delta.text) ?? '';
                     block.text += value;
-                    yield { type: 'text.delta', itemId: block.id, phase: 'commentary', delta: value };
+                    yield observeModelStreamEvent({ type: 'text.delta', itemId: block.id, phase: 'commentary', delta: value }, modelStreamEventObservedAt(raw));
+                }
+                else if (deltaType === 'thinking_delta') {
+                    const value = text(delta.thinking) ?? '';
+                    block.text += value;
+                    if (value.length > 0)
+                        yield observeModelStreamEvent({ type: 'output.delta' }, modelStreamEventObservedAt(raw));
                 }
-                else if (deltaType === 'thinking_delta')
-                    block.text += text(delta.thinking) ?? '';
                 else if (deltaType === 'signature_delta') {
                     if (block.type !== 'thinking' || typeof delta.signature !== 'string')
                         throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Anthropic returned an invalid thinking signature delta.');
                     block.signature += delta.signature;
                 }
-                else if (deltaType === 'input_json_delta')
-                    block.json += text(delta.partial_json) ?? '';
+                else if (deltaType === 'input_json_delta') {
+                    const value = text(delta.partial_json) ?? '';
+                    block.json += value;
+                    if (value.length > 0)
+                        yield observeModelStreamEvent({ type: 'output.delta' }, modelStreamEventObservedAt(raw));
+                }
                 else if (deltaType === 'citations_delta') {
                     const citation = record(delta.citation);
                     const url = text(citation.url);
@@ -307,7 +324,7 @@ export class AnthropicMessagesAdapter {
                 };
             }
             else if (type === 'message_stop') {
-                yield { type: 'completed', reason: terminal ?? 'completed' };
+                yield observeModelStreamEvent({ type: 'completed', reason: terminal ?? 'completed' }, modelStreamEventObservedAt(raw));
             }
             else if (type === 'error') {
                 const upstream = record(event.error);

package/dist/model/contracts.d.ts

@@ -95,6 +95,10 @@ export type ModelStopReason = 'completed' | 'tool_use' | 'pause' | 'max_output'
 export type ModelEvent = {
     type: 'response.started';
     responseId: string;
+} | {
+    type: 'output.delta';
+} | {
+    type: 'output.reset';
 } | {
     type: 'response.item';
     provider: 'OPENAI_RESPONSES' | 'ANTHROPIC_MESSAGES';

package/dist/model/openai-responses.js

@@ -3,7 +3,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { describeMarAgentError, MarAgentError } from '../error.js';
 import { marAgentReasoningEffortSchema, resolveModelDefaultReasoningEffort, usesResponsesConfigurationUpdates } from './configuration.js';
 import WebSocket from 'ws';
-import { isRetryableUpstreamOverloadCode, number, parseSse, record, text } from './sse.js';
+import { isRetryableUpstreamOverloadCode, number, parseSse, record, text, observeModelStreamEvent, modelStreamEventObservedAt } from './sse.js';
 import { connectSocks5Target, fetchModelResponse, isRetryableModelHttpStatus, isRetryableModelTransportError, modelRetryMaxAttempts, isRetryableModelRequestError, modelRetryDelay, waitForModelRetry } from './http.js';
 import { acquireModelCredential, appendModelCredentialHeaders } from './runtime-credential.js';
 const WEBSOCKET_IDLE_TIMEOUT_MS = 300_000;
@@ -77,7 +77,11 @@ export class OpenAiResponsesAdapter {
         let invalidContinuationFallbackUsed = false;
         const retryState = request.retryState ?? { attempts: 0 };
         const maxAttempts = modelRetryMaxAttempts(retryState);
+        let resetOutputTiming = false;
         while (retryState.attempts < maxAttempts) {
+            if (resetOutputTiming)
+                yield { type: 'output.reset' };
+            resetOutputTiming = false;
             const attempt = retryState.attempts++;
             const attemptNumber = attempt + 1;
             const attemptStartedAt = Date.now();
@@ -99,6 +103,11 @@ export class OpenAiResponsesAdapter {
             });
             try {
                 for await (const event of this.startAttempt(request, signal, requestBody, useContinuation, credentialReason, turn)) {
+                    if (event.type === 'output.delta') {
+                        resetOutputTiming = true;
+                        yield event;
+                        continue;
+                    }
                     if (!sawSemanticEvent && !isSemanticEvent(event)) {
                         prelude.push(event);
                         continue;
@@ -341,8 +350,16 @@ export class OpenAiResponsesAdapter {
                 else if (type === 'response.custom_tool_call_input.delta') {
                     const itemId = text(event.item_id) ?? '';
                     const known = customCalls.get(itemId);
+                    const delta = text(event.delta) ?? '';
                     if (known)
-                        known.input += text(event.delta) ?? '';
+                        known.input += delta;
+                    if (delta.length > 0)
+                        yield observeModelStreamEvent({ type: 'output.delta' }, modelStreamEventObservedAt(raw));
+                }
+                else if (type === 'response.function_call_arguments.delta' ||
+                    type === 'response.reasoning_summary_text.delta') {
+                    if ((text(event.delta)?.length ?? 0) > 0)
+                        yield observeModelStreamEvent({ type: 'output.delta' }, modelStreamEventObservedAt(raw));
                 }
                 else if (type === 'response.created')
                     yield {
@@ -350,14 +367,14 @@ export class OpenAiResponsesAdapter {
                         responseId: responseEventId(event) ?? 'unknown'
                     };
                 else if (type === 'response.output_text.delta')
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'text.delta',
                         itemId: text(event.item_id) ?? 'text',
                         phase: messagePhase(event.phase) ??
                             textPhases.get(text(event.item_id) ?? '') ??
                             'commentary',
                         delta: text(event.delta) ?? ''
-                    };
+                    }, modelStreamEventObservedAt(raw));
                 else if (type === 'response.output_text.done') {
                     const itemId = text(event.item_id) ?? 'text';
                     const completedText = text(event.text) ?? '';
@@ -519,10 +536,10 @@ export class OpenAiResponsesAdapter {
                             ...(rolloutBudgetUnits === undefined ? {} : { rolloutBudgetUnits })
                         }
                     };
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'completed',
                         reason: type === 'response.incomplete' ? 'max_output' : 'completed'
-                    };
+                    }, modelStreamEventObservedAt(raw));
                     completed = true;
                 }
                 else if (type === 'error' || type === 'response.failed') {
@@ -634,6 +651,7 @@ class OpenAiResponsesTurnSession {
                     if (event.type === 'completed')
                         warmCompleted = event.reason === 'completed';
                     if (event.type === 'client_tool.call' ||
+                        event.type === 'output.delta' ||
                         event.type === 'text.delta' ||
                         event.type === 'text.completed' ||
                         event.type === 'response.item' ||
@@ -660,6 +678,7 @@ class OpenAiResponsesTurnSession {
                 else if (event.type === 'response.item')
                     outputItems.push(event.item);
                 else if (event.type === 'text.delta' ||
+                    event.type === 'output.delta' ||
                     event.type === 'text.completed' ||
                     event.type === 'reasoning.summary' ||
                     event.type === 'client_tool.call' ||
@@ -1179,7 +1198,8 @@ async function* webSocketMessages(socket, signal) {
     };
     const message = (value) => push({
         type: 'message',
-        value
+        value,
+        observedAt: performance.now()
     });
     const close = () => push({ type: 'closed' });
     const error = (cause) => push({
@@ -1228,7 +1248,7 @@ async function* webSocketMessages(socket, signal) {
                 const event = JSON.parse(text);
                 if (!isWebSocketNonProgressEvent(event))
                     idleDeadline = Date.now() + WEBSOCKET_IDLE_TIMEOUT_MS;
-                yield event;
+                yield observeModelStreamEvent(event, item.observedAt);
             }
             catch (cause) {
                 throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model WebSocket contained invalid JSON.', { cause });
@@ -1336,13 +1356,11 @@ const NON_SEMANTIC_OPENAI_RESPONSES_EVENTS = new Set([
     'codex.response.metadata',
     'response.content_part.added',
     'response.content_part.done',
-    'response.function_call_arguments.delta',
     'response.in_progress',
     'response.metadata',
     'response.queued',
     'response.reasoning_summary_part.added',
     'response.reasoning_summary_part.done',
-    'response.reasoning_summary_text.delta',
     'responsesapi.websocket_timing'
 ]);
 function isRetryableResponsesUpstreamError(code, message) {

package/dist/model/sse.d.ts

@@ -1,3 +1,5 @@
+export declare function observeModelStreamEvent<const T>(value: T, observedAt: number | undefined): T;
+export declare function modelStreamEventObservedAt(value: unknown): number | undefined;
 export declare function parseSse(response: Response, signal: AbortSignal, maxBytes?: number, idleTimeoutMs?: number): AsyncIterable<unknown>;
 export declare function isRetryableUpstreamOverloadCode(code: string | undefined): boolean;
 export declare function record(value: unknown): Record<string, unknown>;

package/dist/model/sse.js

@@ -1,6 +1,15 @@
 import { MarAgentError } from '../error.js';
 import { isRetryableModelHttpStatus } from './http.js';
 const DEFAULT_MODEL_STREAM_IDLE_TIMEOUT_MS = 300_000;
+const streamEventObservedAt = new WeakMap();
+export function observeModelStreamEvent(value, observedAt) {
+    if (typeof value === 'object' && value !== null && observedAt !== undefined)
+        streamEventObservedAt.set(value, observedAt);
+    return value;
+}
+export function modelStreamEventObservedAt(value) {
+    return typeof value === 'object' && value !== null ? streamEventObservedAt.get(value) : undefined;
+}
 export async function* parseSse(response, signal, maxBytes = 16 * 1024 * 1024, idleTimeoutMs = DEFAULT_MODEL_STREAM_IDLE_TIMEOUT_MS) {
     if (!response.ok) {
         const body = await readResponseText(response, signal, maxBytes, idleTimeoutMs);
@@ -34,6 +43,7 @@ export async function* parseSse(response, signal, maxBytes = 16 * 1024 * 1024, i
             if (signal.aborted)
                 throw signal.reason;
             const { value, done } = await readStreamChunk(reader, signal, idleTimeoutMs);
+            const observedAt = performance.now();
             if (done) {
                 streamCompleted = true;
                 break;
@@ -53,7 +63,7 @@ export async function* parseSse(response, signal, maxBytes = 16 * 1024 * 1024, i
                 if (data.length === 0 || data === '[DONE]')
                     continue;
                 try {
-                    yield JSON.parse(data);
+                    yield observeModelStreamEvent(JSON.parse(data), observedAt);
                 }
                 catch (cause) {
                     throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model SSE contained invalid JSON.', { cause });

package/dist/sdk/agent.js

@@ -37,6 +37,7 @@ import { createCodeToolDispatch } from '../tools/code-mode/dispatch.js';
 import { createSessionToolScheduler, scheduleToolCallBatch } from '../tools/scheduler.js';
 import { projectCodeModeSearchResult, projectCodeModeTools } from '../tools/code-mode.js';
 import { allowsDirectTool, allowsToolCaller, toolCallers } from '../tools/callers.js';
+import { modelStreamEventObservedAt } from '../model/sse.js';
 import { SubagentSessionController } from '../subagent/session-controller.js';
 /** Retry only classified recoverable failures within the attempt budget; never retry cancellation. */
 async function recoverModelStream(error, retryState, signal) {
@@ -905,6 +906,8 @@ export async function createMarAgentWithAdapter(options) {
                         let sawModelSemanticEvent = false;
                         let requestStartedAt;
                         let firstModelResponseAt;
+                        let firstOutputDeltaAt;
+                        let lastOutputDeltaAt;
                         let requestCompletedAt;
                         let requestOutputTokens;
                         const roundMessageCount = messages.length;
@@ -917,18 +920,24 @@ export async function createMarAgentWithAdapter(options) {
                             });
                         };
                         const emitFinalPerformance = async (completedAt) => {
-                            if (mode === 'compact' || firstModelResponseAt === undefined)
+                            if (mode === 'compact' ||
+                                firstModelResponseAt === undefined ||
+                                firstOutputDeltaAt === undefined ||
+                                lastOutputDeltaAt === undefined ||
+                                lastOutputDeltaAt - firstOutputDeltaAt < 1)
                                 return;
-                            const outputDurationMs = Math.max(0, Math.round(completedAt - firstModelResponseAt));
+                            const outputDuration = completedAt - firstOutputDeltaAt;
                             const outputTokens = requestOutputTokens;
-                            if (outputTokens === undefined || outputDurationMs <= 0)
+                            if (outputTokens === undefined ||
+                                outputDuration < 1 ||
+                                completedAt < lastOutputDeltaAt)
                                 return;
                             await emit({
                                 type: 'model.performance',
                                 latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt)),
                                 outputTokens,
-                                outputDurationMs,
-                                tokensPerSecond: Number(((outputTokens * 1000) / outputDurationMs).toFixed(2))
+                                outputDurationMs: Math.round(outputDuration),
+                                tokensPerSecond: Number(((outputTokens * 1000) / outputDuration).toFixed(2))
                             });
                         };
                         const persistToolCalls = async (calls) => {
@@ -976,11 +985,25 @@ export async function createMarAgentWithAdapter(options) {
                                 ...(modelInputImages?.length ? { images: modelInputImages } : {}),
                                 onAttemptDiagnostic: recordModelAttempt(mode === 'compact' ? 'COMPACTION' : 'EXECUTION')
                             })) {
-                                const modelResponseAt = mode !== 'compact' && isModelResponseEvent(event) ? performance.now() : undefined;
+                                if (event.type === 'output.reset') {
+                                    firstOutputDeltaAt = undefined;
+                                    lastOutputDeltaAt = undefined;
+                                    requestOutputTokens = undefined;
+                                    continue;
+                                }
+                                const modelResponseAt = mode !== 'compact' && isModelResponseEvent(event)
+                                    ? Math.max(requestStartedAt, modelStreamEventObservedAt(event) ?? performance.now())
+                                    : undefined;
                                 const isFirstModelResponse = modelResponseAt !== undefined && firstModelResponseAt === undefined;
                                 if (modelResponseAt !== undefined) {
-                                    sawModelSemanticEvent = true;
+                                    if (event.type !== 'output.delta')
+                                        sawModelSemanticEvent = true;
                                     firstModelResponseAt ??= modelResponseAt;
+                                    if (event.type === 'output.delta' ||
+                                        (event.type === 'text.delta' && event.delta.length > 0)) {
+                                        firstOutputDeltaAt ??= modelResponseAt;
+                                        lastOutputDeltaAt = modelResponseAt;
+                                    }
                                 }
                                 if (event.type === 'response.item') {
                                     // Compaction keeps only its successful checkpoint, never intermediate native output.
@@ -1117,7 +1140,7 @@ export async function createMarAgentWithAdapter(options) {
                                 }
                                 else if (event.type === 'completed') {
                                     stop = event.reason;
-                                    requestCompletedAt = performance.now();
+                                    requestCompletedAt = modelStreamEventObservedAt(event) ?? performance.now();
                                 }
                                 if (isFirstModelResponse)
                                     await emitLatency();
@@ -2459,6 +2482,7 @@ function isModelResponseEvent(event) {
     if (event.type === 'text.completed' || event.type === 'reasoning.summary')
         return event.text.length > 0;
     return (event.type === 'response.item' ||
+        event.type === 'output.delta' ||
         event.type === 'client_tool.call' ||
         event.type === 'hosted_tool' ||
         event.type === 'citation');

package/dist/tools/code-mode/quickjs-engine.js

@@ -527,13 +527,23 @@ function streamText(value, emit) {
         else {
             emit('{');
             let first = true;
-            for (const name of Object.keys(item)) {
+            const names = Object.keys(item);
+            // Special-case view_image and native MCP image objects: text omits Base64; out.image keeps pixels.
+            const imagePayload = names.includes('mimeType') &&
+                typeof item.mimeType === 'string' &&
+                item.mimeType.startsWith('image/');
+            for (const name of names) {
                 if (!first)
                     emit(',');
                 first = false;
                 chunks(name, true);
                 emit(':');
-                write(item[name], name);
+                const field = item[name];
+                write(imagePayload &&
+                    (name === 'dataBase64' || (name === 'data' && item.type === 'image')) &&
+                    typeof field === 'string'
+                    ? '[image payload omitted; use out.image]'
+                    : field, name);
             }
             emit('}');
         }

package/dist/tools/code-mode.js

@@ -30,7 +30,7 @@ Tool calls:
 - skill, tool_search, question, code_exec, code_exec_wait and direct-only tools cannot be called here. Load Skills directly and read their instructions before the next tool call. Use direct tool_search before a later code cell for deferred tools; the current cell's tools do not change.
 
 Built-in namespaces:
-- out.text(value): void emits text. Strings and scalar values are stringified; JSON-compatible objects/arrays are serialized as compact JSON. Excess ordinary text is truncated with omission metadata, without stopping later code or tools. Cyclic or unsupported object values fail. Only explicitly emitted output reaches the model.
+- out.text(value): void emits text. Strings and scalar values are stringified; JSON-compatible objects/arrays are serialized as compact JSON. Structured image objects (image/* mimeType and string dataBase64, or native MCP type:image with string data) are recursively summarized without their Base64 payload; originals remain unchanged. Ordinary strings remain unchanged. This does not emit pixels: use out.image(result.images[0]) for images. Prefer result.data or result.content over the whole image result. Excess ordinary text is truncated with omission metadata, without stopping later code or tools. Cyclic or unsupported object values fail. Only explicitly emitted output reaches the model.
 - out.image(value: {mimeType:string,dataBase64:string}): void emits one returned image; for example out.image(result.images[0]) when that image exists and the model supports images. It does not accept a path, URL, or result.content.
 - state.get(key), state.has(key), state.set(key, value), state.delete(key) access bounded session JSON state. Mutations commit atomically only when the cell succeeds; failed or cancelled cells discard them.
 - catalog.tools() returns a read-only snapshot of the tools callable in this cell, including name, description, inputSchema and inputMode. It does not discover or authorize additional tools.

package/package.json

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