@myagentroam/agent 0.9.158 → 0.9.160

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

@@ -5,6 +5,7 @@ import { resolveModelDefaultReasoningEffort } from './configuration.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';
+import { resolveModelTextBlocks } from './text-blocks.js';
 export class AnthropicMessagesAdapter {
     configuration;
     constructor(configuration) {
@@ -74,20 +75,25 @@ export class AnthropicMessagesAdapter {
             },
             body: JSON.stringify({
                 model: this.configuration.modelId,
-                system: [
-                    {
-                        type: 'text',
-                        text: request.system,
-                        cache_control: { type: 'ephemeral' }
-                    }
-                ],
-                messages: anthropicMessages(request.messages, request.images, request.tools, this.configuration.id),
+                system: request.systemBlocks !== undefined
+                    ? anthropicTextBlocks(request.system, request.systemBlocks)
+                    : request.system
+                        ? [
+                            {
+                                type: 'text',
+                                text: request.system,
+                                cache_control: { type: 'ephemeral' }
+                            }
+                        ]
+                        : [],
+                messages: anthropicMessages(request.messages, request.images, request.tools, this.configuration.id, request.systemBlocks === undefined &&
+                    request.messages.every((message) => message.textBlocks === undefined), request.cachePrefixMessages),
                 tools,
                 ...(request.toolChoice === undefined
                     ? {}
                     : { tool_choice: { type: request.toolChoice } }),
                 stream: true,
-                max_tokens: this.configuration.maxOutputTokens,
+                max_tokens: Math.min(request.outputLimit ?? this.configuration.maxOutputTokens, this.configuration.maxOutputTokens),
                 output_config: {
                     effort: request.reasoningEffort?.trim() ||
                         resolveModelDefaultReasoningEffort(this.configuration)
@@ -452,12 +458,20 @@ function boundedError(value, maximum) {
         return undefined;
     return [...normalized].slice(0, maximum).join('');
 }
-function anthropicMessages(messages, images, tools = [], modelId) {
+function anthropicMessages(messages, images, tools = [], modelId, automaticCache = true, cachePrefixMessages) {
+    if (cachePrefixMessages !== undefined &&
+        (!Number.isSafeInteger(cachePrefixMessages) ||
+            cachePrefixMessages < 0 ||
+            cachePrefixMessages > messages.length))
+        throw new MarAgentError('MAR_AGENT_MODEL_REQUEST_INVALID', 'The captured cache prefix is invalid.');
     const imageMessage = messages.findLastIndex((message) => message.role === 'user');
     const toolDefinitions = new Map(tools.map((tool) => [tool.name, tool]));
     const result = [];
     let thinkingBytes = 0;
     for (const [index, message] of messages.entries()) {
+        if (index === cachePrefixMessages)
+            for (const prior of result.slice(-2))
+                prior.content = withCacheBreakpoint(prior.content);
         const userImages = message.role === 'user'
             ? uniqueModelImages(message.images, index === imageMessage ? images : undefined)
             : [];
@@ -494,6 +508,7 @@ function anthropicMessages(messages, images, tools = [], modelId) {
             const block = {
                 type: 'tool_result',
                 tool_use_id: message.callId,
+                ...(message.isError === undefined ? {} : { is_error: message.isError }),
                 content: observationModelParts(message)?.map((part) => part.type === 'text'
                     ? { type: 'text', text: part.text }
                     : {
@@ -504,10 +519,10 @@ function anthropicMessages(messages, images, tools = [], modelId) {
                             data: part.image.dataBase64
                         }
                     }) ??
-                    (message.images?.length
+                    (message.textBlocks !== undefined
                         ? [
-                            { type: 'text', text: message.content },
-                            ...message.images.map((image) => ({
+                            ...anthropicTextBlocks(message.content, message.textBlocks),
+                            ...(message.images ?? []).map((image) => ({
                                 type: 'image',
                                 source: {
                                     type: 'base64',
@@ -516,7 +531,19 @@ function anthropicMessages(messages, images, tools = [], modelId) {
                                 }
                             }))
                         ]
-                        : message.content)
+                        : message.images?.length
+                            ? [
+                                { type: 'text', text: message.content },
+                                ...message.images.map((image) => ({
+                                    type: 'image',
+                                    source: {
+                                        type: 'base64',
+                                        media_type: image.mimeType,
+                                        data: image.dataBase64
+                                    }
+                                }))
+                            ]
+                            : message.content)
             };
             const previous = result.at(-1);
             if (previous?.role === 'user' && Array.isArray(previous.content))
@@ -526,19 +553,21 @@ function anthropicMessages(messages, images, tools = [], modelId) {
             continue;
         }
         if (message.role === 'assistant') {
-            if (!message.content)
+            if (!message.content && message.textBlocks === undefined)
                 continue;
-            const block = { type: 'text', text: message.content };
+            const blocks = message.textBlocks !== undefined
+                ? anthropicTextBlocks(message.content, message.textBlocks)
+                : [{ type: 'text', text: message.content }];
             const previous = result.at(-1);
             if (previous?.role === 'assistant' && Array.isArray(previous.content))
-                previous.content.push(block);
+                previous.content.push(...blocks);
             else
-                result.push({ role: 'assistant', content: [block] });
+                result.push({ role: 'assistant', content: blocks });
             continue;
         }
         result.push({
             role: message.role,
-            content: userImages.length > 0
+            content: message.textBlocks !== undefined
                 ? [
                     ...userImages.map((image) => ({
                         type: 'image',
@@ -548,15 +577,36 @@ function anthropicMessages(messages, images, tools = [], modelId) {
                             data: image.dataBase64
                         }
                     })),
-                    { type: 'text', text: message.content }
+                    ...anthropicTextBlocks(message.content, message.textBlocks)
                 ]
-                : message.content
+                : userImages.length > 0
+                    ? [
+                        ...userImages.map((image) => ({
+                            type: 'image',
+                            source: {
+                                type: 'base64',
+                                media_type: image.mimeType,
+                                data: image.dataBase64
+                            }
+                        })),
+                        { type: 'text', text: message.content }
+                    ]
+                    : message.content
         });
     }
-    for (const message of result.slice(-2))
-        message.content = withCacheBreakpoint(message.content);
+    if (cachePrefixMessages === messages.length ||
+        (cachePrefixMessages === undefined && automaticCache))
+        for (const message of result.slice(-2))
+            message.content = withCacheBreakpoint(message.content);
     return result;
 }
+function anthropicTextBlocks(text, blocks) {
+    return resolveModelTextBlocks(text, blocks).map((block) => ({
+        type: 'text',
+        text: block.text,
+        ...(block.cache ? { cache_control: { type: 'ephemeral' } } : {})
+    }));
+}
 function uniqueModelImages(...groups) {
     const seen = new Set();
     return groups.flatMap((group) => (group ?? []).flatMap((image) => {

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

@@ -1,10 +1,17 @@
 import type { ClientToolDefinition } from '../tools/contracts.js';
 import type { MarAgentModelConfiguration, MarAgentReasoningEffort, ModelCredentialAcquireReason } from './configuration.js';
 export type { ClientToolDefinition, ToolCaller } from '../tools/contracts.js';
+export interface ModelTextBlock {
+    readonly text: string;
+    readonly cache?: true;
+}
 export interface ModelMessage {
+    /** Model-facing tool-result status; independent of the actual execution outcome. */
+    isError?: boolean;
     calls?: readonly import('../tools/code-mode/observations.js').CodeToolCallRecord[];
     role: 'user' | 'assistant' | 'tool' | 'tool_call' | 'provider';
     content: string;
+    textBlocks?: readonly ModelTextBlock[];
     contextKind?: 'environment' | 'private';
     callId?: string;
     name?: string;
@@ -36,6 +43,15 @@ export interface ModelAttemptDiagnostic {
     connectionId?: string;
     connectionReused?: boolean;
     proxyType?: 'DIRECT' | 'SOCKS5';
+    /** Actual serialized WebSocket request size, including inline image Base64. */
+    requestBytes?: number;
+    imageCount?: number;
+    /** Decoded byte count of inline input images; external URLs do not add bytes. */
+    imageBytes?: number;
+    requestFrameCount?: number;
+    sentFrameCount?: number;
+    webSocketPhase?: 'CONNECT' | 'SEND' | 'RECEIVE';
+    webSocketCloseCode?: number;
     durationMs?: number;
     errorCode?: string;
     errorMessage?: string;
@@ -55,8 +71,13 @@ export interface ModelRequest {
     /** Shared local attempt accounting across Adapter retries and Runtime continuation. Never sent upstream. */
     retryState?: ModelRetryState;
     system: string;
+    systemBlocks?: readonly ModelTextBlock[];
+    /** Retain the automatic cache boundary of an actual captured prefix, excluding a fork tail. */
+    cachePrefixMessages?: number;
     messages: readonly ModelMessage[];
     tools: readonly ClientToolDefinition[];
+    /** Optional per-request cap; adapters never exceed their configured output ceiling. */
+    outputLimit?: number;
     allowTools?: boolean;
     /** Preserve the visible tool catalog while controlling whether the model may call it. */
     toolChoice?: 'auto' | 'none';

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

@@ -25,6 +25,7 @@ interface PreparedResponsesRequest {
     readonly body: ResponsesRequestBody;
     readonly continuation: boolean;
 }
+type ResponsesWebSocketDiagnostic = Pick<ModelAttemptDiagnostic, 'requestBytes' | 'imageCount' | 'imageBytes' | 'requestFrameCount' | 'sentFrameCount' | 'webSocketPhase' | 'webSocketCloseCode'>;
 export declare class OpenAiResponsesAdapter implements ModelAdapter {
     #private;
     constructor(configuration: MarAgentModelConfiguration);
@@ -51,7 +52,8 @@ declare class OpenAiResponsesTurnSession implements ModelTurnSession {
     fullRequestBody(): ResponsesRequestBody;
     currentTurnState(): string | undefined;
     beginAttempt(): void;
-    connectionDiagnostic(): Pick<ModelAttemptDiagnostic, 'connectionId' | 'connectionReused' | 'proxyType'>;
+    captureWebSocketDiagnostic(diagnostic: ResponsesWebSocketDiagnostic): void;
+    connectionDiagnostic(): Pick<ModelAttemptDiagnostic, 'connectionId' | 'connectionReused' | 'proxyType'> & ResponsesWebSocketDiagnostic;
     captureTurnState(value: unknown): void;
     withTurnStateMetadata(body: ResponsesRequestBody): ResponsesRequestBody;
     invalidateWebSocket(): void;