@myagentroam/agent 0.10.8 → 0.10.10

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

@@ -1,4 +1,5 @@
 import { observeModelRequestUsage } from './usage-observer.js';
+import { jsonToolInput } from './tool-input.js';
 import { observationModelParts } from '../tools/code-mode/observations.js';
 import { stableToolSchema } from '../tools/definition-projection.js';
 import { randomUUID } from 'node:crypto';
@@ -144,7 +145,7 @@ export class AnthropicMessagesAdapter {
         let terminal;
         let latestInputUsage;
         let thinkingBytes = 0;
-        for await (const raw of parseAnthropicSse(response, signal)) {
+        for await (const raw of parseAnthropicSse(response, signal, apiKey.reveal())) {
             const event = record(raw);
             const type = text(event.type) ?? 'unknown';
             const index = number(event.index) ?? -1;
@@ -424,9 +425,9 @@ export class AnthropicMessagesAdapter {
             });
     }
 }
-async function* parseAnthropicSse(response, signal) {
+async function* parseAnthropicSse(response, signal, apiKey) {
     try {
-        yield* parseSse(response, signal);
+        yield* parseSse(response, signal, undefined, undefined, [apiKey]);
     }
     catch (cause) {
         if (response.ok &&
@@ -551,7 +552,7 @@ function anthropicMessages(messages, images, tools = [], modelId, automaticCache
                 type: 'tool_use',
                 id: message.callId,
                 name: message.name,
-                input: anthropicToolInput(message, toolDefinitions.get(message.name ?? ''))
+                input: jsonToolInput(message, toolDefinitions.get(message.name ?? ''))
             };
             const previous = result.at(-1);
             if (previous?.role === 'assistant' && Array.isArray(previous.content))
@@ -673,23 +674,6 @@ function uniqueModelImages(...groups) {
         return [image];
     }));
 }
-function anthropicToolInput(message, tool) {
-    if (isObject(message.arguments))
-        return message.arguments;
-    if (message.inputMode !== 'freeform')
-        return {};
-    const property = freeformInputProperty(tool?.inputSchema);
-    return { [property ?? 'input']: String(message.arguments ?? '') };
-}
-function freeformInputProperty(schema) {
-    if (schema?.type !== 'object' || !isObject(schema.properties) || !Array.isArray(schema.required))
-        return undefined;
-    const required = schema.required.filter((value) => typeof value === 'string');
-    if (required.length !== 1)
-        return undefined;
-    const property = schema.properties[required[0]];
-    return isObject(property) && property.type === 'string' ? required[0] : undefined;
-}
 function isObject(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }

package/dist/agent-core/model/catalog-file.d.ts

@@ -32,6 +32,13 @@ export declare function serializeModel(model: CliModelConfiguration): {
     serviceTier?: "default" | "auto" | "flex" | "priority" | "fast" | "ultrafast" | undefined;
     hostedWebSearch: boolean;
     responsesToolNamespace?: string | undefined;
+    responsesOptionalParameters?: {
+        reasoningEffort: boolean;
+        reasoningSummary: boolean;
+        textVerbosity: boolean;
+        promptCacheKey: boolean;
+        nativeTools?: boolean | undefined;
+    } | undefined;
     enabled: boolean;
 } | {
     credential: {
@@ -58,5 +65,12 @@ export declare function serializeModel(model: CliModelConfiguration): {
     serviceTier?: "default" | "auto" | "flex" | "priority" | "fast" | "ultrafast" | undefined;
     hostedWebSearch: boolean;
     responsesToolNamespace?: string | undefined;
+    responsesOptionalParameters?: {
+        reasoningEffort: boolean;
+        reasoningSummary: boolean;
+        textVerbosity: boolean;
+        promptCacheKey: boolean;
+        nativeTools?: boolean | undefined;
+    } | undefined;
     enabled: boolean;
 };

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

@@ -90,6 +90,13 @@ declare const rawModelSchema: z.ZodObject<{
     }, z.core.$strict>], "transport">>;
     responsesToolNamespace: z.ZodOptional<z.ZodString>;
     responsesPreviousResponseId: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    responsesOptionalParameters: z.ZodOptional<z.ZodObject<{
+        reasoningEffort: z.ZodBoolean;
+        reasoningSummary: z.ZodBoolean;
+        textVerbosity: z.ZodBoolean;
+        promptCacheKey: z.ZodBoolean;
+        nativeTools: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
     enabled: z.ZodBoolean;
 }, z.core.$strict>;
 export interface MarAgentModelConfiguration extends Omit<z.infer<typeof rawModelSchema>, 'apiKey' | 'responsesPreviousResponseId' | 'responsesTransport'> {

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

@@ -58,6 +58,16 @@ const rawModelSchema = z
         .regex(/^[a-zA-Z][a-zA-Z0-9_]{0,63}$/u)
         .optional(),
     responsesPreviousResponseId: z.boolean().optional().default(false),
+    responsesOptionalParameters: z
+        .object({
+        reasoningEffort: z.boolean(),
+        reasoningSummary: z.boolean(),
+        textVerbosity: z.boolean(),
+        promptCacheKey: z.boolean(),
+        nativeTools: z.boolean().optional()
+    })
+        .strict()
+        .optional(),
     enabled: z.boolean()
 })
     .strict()

package/dist/agent-core/model/openai-responses.d.ts

@@ -68,5 +68,5 @@ declare class OpenAiResponsesTurnSession implements ModelTurnSession {
     private connectWebSocket;
 }
 export declare function isOpenAiResponsesRecoverableStreamError(error: unknown): error is MarAgentError;
-export declare function openAiInput(messages: ModelRequest['messages'], images: ModelRequest['images'] | undefined, modelId: string, requireEncryptedReasoning: boolean, configurationUpdates?: boolean): Record<string, unknown>[];
+export declare function openAiInput(messages: ModelRequest['messages'], images: ModelRequest['images'] | undefined, modelId: string, requireEncryptedReasoning: boolean, configurationUpdates?: boolean, nativeTools?: boolean, tools?: ModelRequest['tools']): Record<string, unknown>[];
 export {};

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

@@ -8,8 +8,9 @@ import { marAgentReasoningEffortSchema, resolveModelDefaultReasoningEffort, uses
 import WebSocket from 'ws';
 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';
+import { acquireModelCredential, appendModelCredentialHeaders, modelCredentialSensitiveValues } from './runtime-credential.js';
 import { resolveModelTextBlocks } from './text-blocks.js';
+import { jsonToolInput } from './tool-input.js';
 import { reportModelAttempt } from './attempt-diagnostics.js';
 const WEBSOCKET_IDLE_TIMEOUT_MS = 300_000;
 const WEBSOCKET_SEND_FRAME_BYTES = 1024 * 1024;
@@ -253,11 +254,13 @@ export class OpenAiResponsesAdapter {
     }
     async *startAttempt(request, signal, body, continuation, credentialReason, turn) {
         let latestCredentialRevision;
+        let diagnosticSecrets = [];
         const fetchResponse = async (requestBody) => {
             const serializedBody = JSON.stringify(requestBody);
             return await fetchModelResponse(responsesEndpoint(this.configuration.baseUrl), async () => {
                 const credential = await acquireResponsesCredential(this.configuration, credentialReason, signal);
                 latestCredentialRevision = credential.revision;
+                diagnosticSecrets = modelCredentialSensitiveValues(credential);
                 return {
                     request: {
                         method: 'POST',
@@ -291,7 +294,7 @@ export class OpenAiResponsesAdapter {
             else {
                 response = await fetchResponse(body);
                 turn.captureTurnState(response.headers.get(X_CODEX_TURN_STATE));
-                rawEvents = parseOpenAiResponsesSse(response, signal, continuation);
+                rawEvents = parseOpenAiResponsesSse(response, signal, continuation, diagnosticSecrets);
             }
         }
         catch (error) {
@@ -583,7 +586,9 @@ export class OpenAiResponsesAdapter {
                     }, modelStreamEventObservedAt(raw));
                     completed = true;
                 }
-                else if (type === 'error' || type === 'response.failed') {
+                else if (type === 'error' ||
+                    type === 'response.failed' ||
+                    (event.type === undefined && event.error !== undefined)) {
                     const topLevel = record(event.error);
                     const nested = record(record(event.response).error);
                     const code = boundedError(text(event.code) ??
@@ -591,7 +596,10 @@ export class OpenAiResponsesAdapter {
                         text(topLevel.type) ??
                         text(nested.code) ??
                         text(nested.type), 80);
-                    const message = boundedError(text(event.message) ?? text(topLevel.message) ?? text(nested.message), 1_000);
+                    const message = boundedError(text(event.message) ??
+                        text(topLevel.message) ??
+                        text(nested.message) ??
+                        text(event.error), 1_000);
                     const status = upstreamHttpStatus(event.status, topLevel.status, record(event.response).status, nested.status);
                     const connectionLimit = this.configuration.responsesTransport?.transport === 'WEBSOCKET' &&
                         isWebSocketConnectionLimitCode(code);
@@ -897,14 +905,15 @@ function responsesRequestBody(configuration, request, messages) {
         throw new MarAgentError('MAR_AGENT_MODEL_CAPABILITY_UNAVAILABLE', 'This model protocol does not support explicit text-block cache markers.');
     const tools = request.allowTools === false
         ? []
-        : request.tools.map((tool) => tool.nativeType === 'tool_search'
+        : request.tools.map((tool) => tool.nativeType === 'tool_search' &&
+            configuration.responsesOptionalParameters?.nativeTools !== false
             ? {
                 type: 'tool_search',
                 execution: 'client',
                 description: tool.description,
                 parameters: stableToolSchema(strictFunctionSchema(stableToolSchema(tool.inputSchema)))
             }
-            : responsesFunctionTool(tool));
+            : responsesFunctionTool(tool, configuration.responsesOptionalParameters?.nativeTools !== false));
     if (configuration.responsesToolNamespace && tools.length > 0) {
         const native = tools.filter((tool) => record(tool).type === 'tool_search');
         const nested = tools.filter((tool) => record(tool).type !== 'tool_search');
@@ -920,7 +929,7 @@ function responsesRequestBody(configuration, request, messages) {
     if (request.allowTools !== false && configuration.hostedWebSearch)
         tools.push({ type: 'web_search' });
     const toolChoice = request.toolChoice ?? 'auto';
-    const input = openAiInput(messages, request.images, configuration.id, true, usesResponsesConfigurationUpdates(configuration));
+    const input = openAiInput(messages, request.images, configuration.id, true, usesResponsesConfigurationUpdates(configuration), configuration.responsesOptionalParameters?.nativeTools !== false, request.tools);
     if (request.systemBlocks !== undefined && (request.systemBlocks.length || request.system.length))
         input.unshift({
             role: 'developer',
@@ -943,25 +952,40 @@ function responsesRequestBody(configuration, request, messages) {
                 : {}),
         instructions: request.systemBlocks === undefined ? request.system : '',
         tools,
-        tool_choice: toolChoice,
+        ...(tools.length > 0 ? { tool_choice: toolChoice, parallel_tool_calls: true } : {}),
         input,
         stream: true,
-        parallel_tool_calls: true,
         store: false,
-        text: { verbosity: 'low' },
+        ...(configuration.responsesOptionalParameters?.textVerbosity === false
+            ? {}
+            : { text: { verbosity: 'low' } }),
         include: [
             'reasoning.encrypted_content',
             ...(configuration.hostedWebSearch && request.allowTools !== false && toolChoice !== 'none'
                 ? ['web_search_call.action.sources']
                 : [])
         ],
-        ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
-        reasoning: {
-            effort: request.requestReasoningEffort?.trim() ||
-                request.reasoningEffort?.trim() ||
-                resolveModelDefaultReasoningEffort(configuration),
-            summary: 'auto'
-        }
+        ...(request.promptCacheKey &&
+            configuration.responsesOptionalParameters?.promptCacheKey !== false
+            ? { prompt_cache_key: request.promptCacheKey }
+            : {}),
+        ...(configuration.responsesOptionalParameters?.reasoningEffort === false &&
+            configuration.responsesOptionalParameters?.reasoningSummary === false
+            ? {}
+            : {
+                reasoning: {
+                    ...(configuration.responsesOptionalParameters?.reasoningEffort === false
+                        ? {}
+                        : {
+                            effort: request.requestReasoningEffort?.trim() ||
+                                request.reasoningEffort?.trim() ||
+                                resolveModelDefaultReasoningEffort(configuration)
+                        }),
+                    ...(configuration.responsesOptionalParameters?.reasoningSummary === false
+                        ? {}
+                        : { summary: 'auto' })
+                }
+            })
     };
 }
 function incrementalResponsesInput(state, current) {
@@ -1031,9 +1055,9 @@ function turnStateFromEvent(event) {
     }
     return undefined;
 }
-async function* parseOpenAiResponsesSse(response, signal, continuation) {
+async function* parseOpenAiResponsesSse(response, signal, continuation, sensitiveValues) {
     try {
-        yield* parseSse(response, signal);
+        yield* parseSse(response, signal, undefined, undefined, sensitiveValues);
     }
     catch (cause) {
         if (response.ok && !signal.aborted && isRetryableOpenAiStreamReadError(cause))
@@ -1771,11 +1795,13 @@ function responseCitations(response) {
 function responseEventId(event) {
     return text(record(event.response).id);
 }
-export function openAiInput(messages, images, modelId, requireEncryptedReasoning, configurationUpdates = true) {
+export function openAiInput(messages, images, modelId, requireEncryptedReasoning, configurationUpdates = true, nativeTools = true, tools = []) {
     const compatibleMessages = messages.filter((message) => message.role !== 'provider' ||
         (message.provider === 'OPENAI_RESPONSES' &&
             (message.providerModelId === undefined || message.providerModelId === modelId) &&
             (configurationUpdates || message.item?.type !== 'configuration_update') &&
+            (nativeTools ||
+                !['custom_tool_call', 'tool_search_call', 'tool_search_output'].includes(String(message.item?.type))) &&
             (!requireEncryptedReasoning ||
                 message.item?.type !== 'reasoning' ||
                 typeof message.item.encrypted_content === 'string')));
@@ -1810,7 +1836,10 @@ export function openAiInput(messages, images, modelId, requireEncryptedReasoning
         }
     }
     for (const message of compatibleMessages)
-        if (message.role === 'tool_call' && message.inputMode === 'freeform' && message.callId)
+        if (nativeTools &&
+            message.role === 'tool_call' &&
+            message.inputMode === 'freeform' &&
+            message.callId)
             customCallIds.add(message.callId);
     const orderedMessages = [];
     for (const message of compatibleMessages) {
@@ -1828,9 +1857,9 @@ export function openAiInput(messages, images, modelId, requireEncryptedReasoning
     return orderedMessages
         .filter((message) => !(message.role === 'tool_call' && message.callId && providerCallIds.has(message.callId)) &&
         !(message.role === 'assistant' && providerMessageTexts.has(message.content)))
-        .map((message) => openAiInputItem(message, message === lastUser ? images : undefined, customCallIds, functionCallIds));
+        .map((message) => openAiInputItem(message, message === lastUser ? images : undefined, customCallIds, functionCallIds, nativeTools, tools));
 }
-function openAiInputItem(message, images, customCallIds = new Set(), functionCallIds = new Set()) {
+function openAiInputItem(message, images, customCallIds = new Set(), functionCallIds = new Set(), nativeTools = true, tools = []) {
     const userImages = message.role === 'user' ? uniqueModelImages(message.images, images) : [];
     if (message.role === 'provider') {
         if (message.provider !== 'OPENAI_RESPONSES' || !message.item)
@@ -1845,14 +1874,14 @@ function openAiInputItem(message, images, customCallIds = new Set(), functionCal
             throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Provider context item type is unsupported.');
         return item;
     }
-    if (message.role === 'tool_call' && message.inputMode === 'freeform')
+    if (nativeTools && message.role === 'tool_call' && message.inputMode === 'freeform')
         return {
             type: 'custom_tool_call',
             call_id: message.callId,
             name: message.name,
             input: String(message.arguments ?? '')
         };
-    if (message.role === 'tool_call' && message.name === 'tool_search')
+    if (nativeTools && message.role === 'tool_call' && message.name === 'tool_search')
         return {
             type: 'tool_search_call',
             call_id: message.callId,
@@ -1865,9 +1894,12 @@ function openAiInputItem(message, images, customCallIds = new Set(), functionCal
             type: 'function_call',
             call_id: message.callId,
             name: message.name,
-            arguments: JSON.stringify(message.arguments ?? {})
+            arguments: JSON.stringify(message.inputMode === 'freeform'
+                ? jsonToolInput(message, tools.find((tool) => tool.name === message.name))
+                : (message.arguments ?? {}))
         };
     if (message.role === 'tool' &&
+        nativeTools &&
         message.toolSearchTools &&
         !functionCallIds.has(message.callId ?? ''))
         return {
@@ -1875,7 +1907,7 @@ function openAiInputItem(message, images, customCallIds = new Set(), functionCal
             call_id: message.callId,
             status: 'completed',
             execution: 'client',
-            tools: message.toolSearchTools.map(responsesFunctionTool)
+            tools: message.toolSearchTools.map((tool) => responsesFunctionTool(tool))
         };
     if (message.role === 'tool')
         return {
@@ -1934,9 +1966,9 @@ function openAiInputItem(message, images, customCallIds = new Set(), functionCal
                 : message.content
     };
 }
-function responsesFunctionTool(tool) {
+function responsesFunctionTool(tool, nativeTools = true) {
     const strict = !hasOpenFunctionObject(tool.inputSchema);
-    return tool.inputMode === 'freeform'
+    return tool.inputMode === 'freeform' && nativeTools
         ? { type: 'custom', name: tool.name, description: tool.description }
         : {
             type: 'function',

package/dist/agent-core/model/runtime-credential.d.ts

@@ -4,3 +4,5 @@ export declare function acquireModelCredential(configuration: Pick<MarAgentModel
     readonly credentialProvider?: ModelCredentialProvider;
 }, reason: ModelCredentialAcquireReason, missingCredentialMessage: string, signal?: AbortSignal): Promise<ModelCredential>;
 export declare function appendModelCredentialHeaders(headers: Headers, credential: ModelCredential, reservedHeaders: ReadonlySet<string>): Headers;
+/** Values known to be credentials, used only when producing public HTTP error diagnostics. */
+export declare function modelCredentialSensitiveValues(credential: ModelCredential): readonly string[];

package/dist/agent-core/model/runtime-credential.js

@@ -55,3 +55,18 @@ export function appendModelCredentialHeaders(headers, credential, reservedHeader
     }
     return headers;
 }
+/** Values known to be credentials, used only when producing public HTTP error diagnostics. */
+export function modelCredentialSensitiveValues(credential) {
+    const values = [
+        credential.bearer.reveal(),
+        ...Object.values(credential.headers)
+            .filter((value) => value instanceof SecretValue)
+            .map((value) => value.reveal())
+    ];
+    if (credential.socks5Url !== undefined) {
+        const proxy = credential.socks5Url.reveal();
+        const url = new URL(proxy);
+        values.push(proxy, decodeURIComponent(url.username), decodeURIComponent(url.password));
+    }
+    return values;
+}

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

@@ -1,6 +1,6 @@
 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 parseSse(response: Response, signal: AbortSignal, maxBytes?: number, idleTimeoutMs?: number, sensitiveValues?: readonly string[]): AsyncIterable<unknown>;
 export declare function isRetryableUpstreamOverloadCode(code: string | undefined): boolean;
 export declare function record(value: unknown): Record<string, unknown>;
 export declare function text(value: unknown): string | undefined;

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

@@ -10,9 +10,14 @@ export function observeModelStreamEvent(value, observedAt) {
 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) {
+export async function* parseSse(response, signal, maxBytes = 16 * 1024 * 1024, idleTimeoutMs = DEFAULT_MODEL_STREAM_IDLE_TIMEOUT_MS, sensitiveValues = []) {
     if (!response.ok) {
-        const body = await readResponseText(response, signal, maxBytes, idleTimeoutMs);
+        const redact = responseRedactor(sensitiveValues);
+        const body = redact(await readResponseText(response, signal, maxBytes, idleTimeoutMs));
+        const header = (name, limit) => {
+            const value = response.headers.get(name);
+            return value === null ? null : redact(value).slice(0, limit);
+        };
         const upstream = upstreamError(body);
         const code = upstream?.code ??
             (response.status === 401 || response.status === 403
@@ -25,8 +30,11 @@ export async function* parseSse(response, signal, maxBytes = 16 * 1024 * 1024, i
         throw new MarAgentError(code, upstream?.message ?? `Model endpoint returned HTTP ${response.status}.`, {
             details: {
                 status: response.status,
-                body: body.slice(0, 512),
-                retryAfter: response.headers.get('retry-after')
+                body: body.slice(0, 4096),
+                bodyTruncated: body.length > 4096,
+                contentType: header('content-type', 256),
+                requestId: header('x-request-id', 256) ?? header('request-id', 256),
+                retryAfter: header('retry-after', 128)
             },
             retryable: isRetryableModelHttpStatus(response.status)
         });
@@ -208,6 +216,12 @@ async function readStreamChunk(reader, signal, idleTimeoutMs) {
         });
     });
 }
+function responseRedactor(sensitiveValues) {
+    const secrets = [
+        ...new Set(sensitiveValues.flatMap((value) => value ? [value, JSON.stringify(value).slice(1, -1), encodeURIComponent(value)] : []))
+    ].sort((left, right) => right.length - left.length);
+    return (value) => secrets.reduce((text, secret) => text.replaceAll(secret, '[REDACTED]'), value);
+}
 function upstreamError(body) {
     let parsed;
     try {
@@ -217,6 +231,10 @@ function upstreamError(body) {
         return undefined;
     }
     const root = record(parsed);
+    if (typeof root.error === 'string') {
+        const message = bounded(root.error, 1_000);
+        return message === undefined ? undefined : { message };
+    }
     const error = record(root.error);
     // K3-compatible gateways can put the error discriminator in `type` and omit `code`.
     const code = bounded(text(error.code) ?? text(error.type), 80);

package/dist/agent-core/model/tool-input.d.ts

@@ -0,0 +1,3 @@
+import type { ModelRequest } from './contracts.js';
+/** Preserve a freeform call when replaying it through a JSON-only tool protocol. */
+export declare function jsonToolInput(message: ModelRequest['messages'][number], tool: ModelRequest['tools'][number] | undefined): Record<string, unknown>;

package/dist/agent-core/model/tool-input.js

@@ -0,0 +1,18 @@
+/** Preserve a freeform call when replaying it through a JSON-only tool protocol. */
+export function jsonToolInput(message, tool) {
+    if (isObject(message.arguments))
+        return message.arguments;
+    if (message.inputMode !== 'freeform')
+        return {};
+    const schema = tool?.inputSchema;
+    const required = schema?.type === 'object' && Array.isArray(schema.required)
+        ? schema.required.filter((value) => typeof value === 'string')
+        : [];
+    const name = required.length === 1 && typeof required[0] === 'string' ? required[0] : undefined;
+    const property = name && isObject(schema?.properties) ? schema.properties[name] : undefined;
+    const key = name && isObject(property) && property.type === 'string' ? name : 'input';
+    return { [key]: String(message.arguments ?? '') };
+}
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

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

@@ -34,6 +34,6 @@ export class ModelGenerationTiming {
         this.completed = true;
     }
     get durationMs() {
-        return this.completed && this.valid && this.duration >= 1 ? this.duration : undefined;
+        return this.completed && this.valid && this.duration >= 1_000 ? this.duration : undefined;
     }
 }

package/dist/agent-core/tools/code-mode/index.js

@@ -26,7 +26,7 @@ export const codeModeToolDefinition = {
 - Observe only evidence needed for the next decision or verification: use observe.result for original results, observe.text for derived values, and observe.image for image values. Preserve source and failure details needed for reasoning; keep other intermediate data in the cell.
 - Single-tool cells are valid. Keep loops and retries bounded, and do not blindly replay operations with side effects.
 - Evaluates source in a fresh restricted ECMAScript runtime with top-level await and Promise.all. It is not Node.js or a browser. JavaScript globals do not survive between cells; bounded JSON state is available through state.
-- Accepts raw JavaScript source text, not JSON, quoted strings, or markdown code fences. Responses uses the source directly; Anthropic uses the code field of its tool input object. In either case, do not quote or fence the source again.
+- Accepts JavaScript source text. When exposed as a freeform tool, send the source directly; when exposed with a JSON input schema, put the source in its code field. Do not add another JSON wrapper, quoted string, or markdown code fence inside the source.
 - Use only standard ECMAScript built-ins and the explicitly documented tools, observe, state, catalog and cell namespaces. Do not use Node.js, browser or Web APIs. Module imports, filesystem and network APIs are unavailable. Obtain external capabilities only through available tools. Use tools.exec to start managed processes when permitted; use tools.exec_wait afterward to wait, write stdin or cancel.
 
 Tool calls:

package/package.json

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