@myagentroam/agent 0.10.7 → 0.10.9

package/dist/agent-core/extensions/compaction.d.ts

@@ -19,6 +19,7 @@ export interface CoreCompactMessage {
     readonly arguments?: unknown;
 }
 export interface CoreCompactContext {
+    readonly reportModelUsage?: ((usage: import('../model/usage-observer.js').ModelRequestUsage) => Promise<void> | void) | undefined;
     readonly operationId: string;
     readonly reason: 'manual' | 'automatic';
     readonly messages: readonly CoreCompactMessage[];

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

@@ -9,7 +9,7 @@ export class ExtensionRequestSnapshots {
     #current;
     #completed;
     record(modelId, request) {
-        const { onAttemptDiagnostic: _diagnostic, ...serializable } = request;
+        const { onAttemptDiagnostic: _diagnostic, onModelUsage: _usage, onModelUsageFailure: _usageFailure, usageRequestId: _usageRequestId, ...serializable } = request;
         const retained = structuredClone(serializable);
         let view;
         // Preserve dispatch-time isolation without projecting unused public views.

package/dist/agent-core/extensions/session-messages.d.ts

@@ -29,7 +29,7 @@ export interface CoreSessionMessages {
     readonly nextCursor?: string;
 }
 export declare function normalizeSessionMessagesInput(input: CoreSessionMessagesInput): Readonly<{
-    view: "model" | "request" | "conversation";
+    view: "model" | "conversation" | "request";
     agentId: string | undefined;
     includeImages: boolean;
     cursor: number;

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

@@ -53,6 +53,8 @@ export interface HostSessionResourceSnapshot {
 }
 /** The Host owns workspace/tool effects; the SDK owns JSONL storage beneath its supplied HOME. */
 export interface MarAgentHost {
+    /** Independent model consumption facts, including child and auxiliary calls. */
+    modelUsage?: import('../model/usage-observer.js').ModelUsageObserver | undefined;
     readonly extensionPorts?: CoreHostExtensionPorts;
     describe(): Promise<HostDescription>;
     executeTool(call: ToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;

package/dist/agent-core/host/local-agent-host.d.ts

@@ -23,6 +23,7 @@ export interface LocalAgentExecutionExtensions extends HostExecutionExtensions {
 }
 export declare class LocalAgentHost implements MarAgentHost {
     #private;
+    readonly modelUsage: import('../model/usage-observer.js').ModelUsageObserver | undefined;
     readonly extensionPorts: import('./contracts.js').CoreHostExtensionPorts;
     readonly events: MarAgentEvent[];
     constructor(input: {
@@ -31,6 +32,7 @@ export declare class LocalAgentHost implements MarAgentHost {
         beforeOperationToolExecute?: (input: ToolCall, call: CoreOperationContext) => Promise<void> | void;
         callMcpOperation?: (input: ToolCall, call: CoreOperationContext, expected: NonNullable<McpToolCallContext['expectedTool']>) => Promise<ToolExecutionResult>;
         network?: CoreNetworkBackend | false;
+        modelUsage?: import('../model/usage-observer.js').ModelUsageObserver;
         homeDirectory: string;
         workspace: string;
         mode?: 'normal' | 'node';

package/dist/agent-core/host/local-agent-host.js

@@ -12,6 +12,7 @@ import { directLocalProcessExecutor } from './local-process-executor.js';
 import { BUILTIN_TOOL_DEFINITIONS } from '../tools/registry.js';
 import { assertMcpToolCatalog } from '../tools/mcp/catalog.js';
 export class LocalAgentHost {
+    modelUsage;
     extensionPorts;
     #home;
     #workspace;
@@ -37,6 +38,7 @@ export class LocalAgentHost {
     #shell;
     #resourceIdleTtlMs;
     constructor(input) {
+        this.modelUsage = input.modelUsage;
         this.#home = resolve(input.homeDirectory);
         this.#workspace = resolve(input.workspace);
         this.#environment = input.environment ?? process.env;

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

@@ -1,3 +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';
@@ -38,7 +40,7 @@ export class AnthropicMessagesAdapter {
             let firstSemanticEventType;
             await reportModelAttempt(request, { ...attemptDiagnostic, state: 'STARTED' });
             try {
-                for await (const event of this.startAttempt(request, signal)) {
+                for await (const event of observeModelRequestUsage(() => this.startAttempt(request, signal), request, this.configuration, signal)) {
                     if (event.type.startsWith('output.')) {
                         resetOutputTiming = true;
                         yield event;
@@ -143,14 +145,18 @@ 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;
             if (type === 'message_start') {
                 const message = record(event.message);
                 responseId = text(message.id) ?? responseId;
-                yield observeModelStreamEvent({ type: 'response.started', responseId }, modelStreamEventObservedAt(raw));
+                yield observeModelStreamEvent({
+                    type: 'response.started',
+                    responseId,
+                    ...(text(message.model) ? { modelId: text(message.model) } : {})
+                }, modelStreamEventObservedAt(raw));
                 const usage = record(message.usage);
                 const inputTokens = inputTokenCount(usage.input_tokens);
                 const cacheReadTokens = inputTokenCount(usage.cache_read_input_tokens);
@@ -419,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 &&
@@ -491,6 +497,9 @@ function inputUsage(inputTokens, cacheReadTokens, cacheWriteTokens) {
     return {
         inputTokens,
         contextInputTokens: tokenSum(inputTokens, cacheReadTokens, cacheWriteTokens),
+        ...(inputTokens === undefined
+            ? {}
+            : { totalInputTokens: tokenSum(inputTokens, cacheReadTokens, cacheWriteTokens) }),
         cacheReadTokens,
         cacheWriteTokens
     };
@@ -543,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))
@@ -665,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/contracts.d.ts

@@ -82,6 +82,10 @@ export interface ModelRetryState {
     retryDelayMs?: number;
 }
 export interface ModelRequest {
+    /** Metering identity and sink are local only, never serialized upstream. */
+    usageRequestId?: string;
+    onModelUsage?: (usage: import('./usage-observer.js').ModelRequestUsage) => Promise<void> | void;
+    onModelUsageFailure?: () => void;
     /** Shared local attempt accounting across Adapter retries and Runtime continuation. Never sent upstream. */
     retryState?: ModelRetryState;
     system: string;
@@ -106,6 +110,9 @@ export interface ModelRequest {
     onAttemptDiagnostic?: (diagnostic: ModelAttemptDiagnostic) => Promise<void> | void;
 }
 export interface ModelUsage {
+    /** Normalized total input including cache; distinct from protocol-native inputTokens. */
+    totalInputTokens?: number | undefined;
+    reasoningTokens?: number | undefined;
     inputTokens?: number | undefined;
     contextInputTokens?: number | undefined;
     outputTokens?: number | undefined;
@@ -119,6 +126,7 @@ export type ModelStopReason = 'completed' | 'tool_use' | 'pause' | 'max_output'
 export type ModelEvent = {
     type: 'response.started';
     responseId: string;
+    modelId?: string;
 } | {
     type: 'output.started';
 } | {

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

@@ -1,3 +1,4 @@
+import { observeModelRequestUsage } from './usage-observer.js';
 import { observationModelParts } from '../tools/code-mode/observations.js';
 import { stableToolSchema } from '../tools/definition-projection.js';
 import { isDeepStrictEqual } from 'node:util';
@@ -7,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;
@@ -114,7 +116,7 @@ export class OpenAiResponsesAdapter {
                 ...requestPrefixDiagnostic
             });
             try {
-                for await (const event of this.startAttempt(request, signal, requestBody, useContinuation, credentialReason, turn)) {
+                for await (const event of observeModelRequestUsage(() => this.startAttempt(request, signal, requestBody, useContinuation, credentialReason, turn), request, this.configuration, signal)) {
                     if (event.type.startsWith('output.')) {
                         resetOutputTiming = true;
                         yield event;
@@ -252,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',
@@ -290,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) {
@@ -383,7 +387,10 @@ export class OpenAiResponsesAdapter {
                 else if (type === 'response.created')
                     yield observeModelStreamEvent({
                         type: 'response.started',
-                        responseId: responseEventId(event) ?? 'unknown'
+                        responseId: responseEventId(event) ?? 'unknown',
+                        ...(text(record(event.response).model)
+                            ? { modelId: text(record(event.response).model) }
+                            : {})
                     }, modelStreamEventObservedAt(raw));
                 else if (type === 'response.output_text.delta')
                     yield observeModelStreamEvent({
@@ -564,6 +571,8 @@ export class OpenAiResponsesAdapter {
                         final: true,
                         usage: {
                             inputTokens: number(usage.input_tokens),
+                            totalInputTokens: number(usage.input_tokens),
+                            reasoningTokens: number(record(usage.output_tokens_details).reasoning_tokens),
                             contextInputTokens: number(usage.input_tokens),
                             outputTokens: number(usage.output_tokens),
                             cacheReadTokens: number(inputDetails.cached_tokens),
@@ -891,14 +900,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');
@@ -914,7 +924,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',
@@ -937,25 +947,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) {
@@ -1025,9 +1050,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))
@@ -1765,11 +1790,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')));
@@ -1804,7 +1831,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) {
@@ -1822,9 +1852,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)
@@ -1839,14 +1869,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,
@@ -1859,9 +1889,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 {
@@ -1869,7 +1902,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 {
@@ -1928,9 +1961,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);
+}