@myagentroam/agent 0.9.159 → 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;
@@ -64,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.js

@@ -7,6 +7,7 @@ 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 { resolveModelTextBlocks } from './text-blocks.js';
 const WEBSOCKET_IDLE_TIMEOUT_MS = 300_000;
 const WEBSOCKET_SEND_FRAME_BYTES = 1024 * 1024;
 export const OPENAI_RESPONSES_EARLY_EOF_REASON = 'OPENAI_RESPONSES_EARLY_EOF';
@@ -861,6 +862,11 @@ function isLocalContinuationReset(error) {
     return error instanceof MarAgentError && error.code === 'MAR_AGENT_RESPONSES_CONTINUATION_RESET';
 }
 function responsesRequestBody(configuration, request, messages) {
+    if ((request.systemBlocks !== undefined &&
+        resolveModelTextBlocks(request.system, request.systemBlocks).some((block) => block.cache)) ||
+        messages.some((message) => message.textBlocks !== undefined &&
+            resolveModelTextBlocks(message.content, message.textBlocks).some((block) => block.cache)))
+        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'
@@ -887,14 +893,27 @@ function responsesRequestBody(configuration, request, messages) {
         tools.push({ type: 'web_search' });
     const toolChoice = request.toolChoice ?? 'auto';
     const input = openAiInput(messages, request.images, configuration.id, true, usesResponsesConfigurationUpdates(configuration));
+    if (request.systemBlocks !== undefined && (request.systemBlocks.length || request.system.length))
+        input.unshift({
+            role: 'developer',
+            content: resolveModelTextBlocks(request.system, request.systemBlocks).map((block) => ({
+                type: 'input_text',
+                text: block.text
+            }))
+        });
     return {
         model: configuration.modelId,
+        ...(request.outputLimit === undefined
+            ? {}
+            : {
+                max_output_tokens: Math.min(request.outputLimit, configuration.maxOutputTokens)
+            }),
         ...(configuration.serviceTier !== undefined
             ? { service_tier: configuration.serviceTier }
             : configuration.fastMode === true
                 ? { service_tier: 'priority' }
                 : {}),
-        instructions: request.system,
+        instructions: request.systemBlocks === undefined ? request.system : '',
         tools,
         tool_choice: toolChoice,
         input,
@@ -939,6 +958,7 @@ function responsesContinuationPropertiesMatch(previous, current) {
         'instructions',
         'tools',
         'tool_choice',
+        'max_output_tokens',
         'parallel_tool_calls',
         'reasoning',
         'store',
@@ -1687,8 +1707,8 @@ function strictFunctionSchema(value, optional = false) {
         return value;
     const schema = value;
     const supportedSchema = Object.fromEntries(Object.entries(schema).filter(([keyword]) => keyword !== 'propertyNames'));
-    if (schema.type === 'object' && schema.properties && typeof schema.properties === 'object') {
-        const properties = schema.properties;
+    if (schema.type === 'object') {
+        const properties = record(schema.properties);
         const required = new Set(Array.isArray(schema.required) ? schema.required : []);
         return {
             ...supportedSchema,
@@ -1861,40 +1881,81 @@ function openAiInputItem(message, images, customCallIds = new Set(), functionCal
                     type: 'input_image',
                     image_url: `data:${part.image.mimeType};base64,${part.image.dataBase64}`
                 }) ??
-                (message.images?.length
+                (message.textBlocks !== undefined
                     ? [
-                        { type: 'input_text', text: message.content },
-                        ...message.images.map((image) => ({
+                        ...resolveModelTextBlocks(message.content, message.textBlocks).map((block) => ({
+                            type: 'input_text',
+                            text: block.text
+                        })),
+                        ...(message.images ?? []).map((image) => ({
                             type: 'input_image',
                             image_url: `data:${image.mimeType};base64,${image.dataBase64}`
                         }))
                     ]
-                    : message.content)
+                    : message.images?.length
+                        ? [
+                            { type: 'input_text', text: message.content },
+                            ...message.images.map((image) => ({
+                                type: 'input_image',
+                                image_url: `data:${image.mimeType};base64,${image.dataBase64}`
+                            }))
+                        ]
+                        : message.content)
         };
     return {
         role: message.role,
-        content: userImages.length > 0
+        content: message.textBlocks !== undefined
             ? [
-                { type: 'input_text', text: message.content },
+                ...resolveModelTextBlocks(message.content, message.textBlocks).map((block) => ({
+                    type: message.role === 'assistant' ? 'output_text' : 'input_text',
+                    text: block.text
+                })),
                 ...userImages.map((image) => ({
                     type: 'input_image',
                     image_url: `data:${image.mimeType};base64,${image.dataBase64}`
                 }))
             ]
-            : message.content
+            : userImages.length > 0
+                ? [
+                    { type: 'input_text', text: message.content },
+                    ...userImages.map((image) => ({
+                        type: 'input_image',
+                        image_url: `data:${image.mimeType};base64,${image.dataBase64}`
+                    }))
+                ]
+                : message.content
     };
 }
 function responsesFunctionTool(tool) {
+    const strict = !hasOpenFunctionObject(tool.inputSchema);
     return tool.inputMode === 'freeform'
         ? { type: 'custom', name: tool.name, description: tool.description }
         : {
             type: 'function',
             name: tool.name,
             description: tool.description,
-            parameters: strictFunctionSchema(tool.inputSchema),
-            strict: true
+            parameters: strict ? strictFunctionSchema(tool.inputSchema) : tool.inputSchema,
+            strict
         };
 }
+function hasOpenFunctionObject(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const schema = record(value);
+    if ((schema.type === 'object' || (Array.isArray(schema.type) && schema.type.includes('object'))) &&
+        (schema.additionalProperties === true ||
+            (schema.additionalProperties !== null && typeof schema.additionalProperties === 'object') ||
+            (schema.properties === undefined && schema.additionalProperties !== false)))
+        return true;
+    const children = [
+        ...Object.values(record(schema.properties)),
+        ...Object.values(record(schema.$defs)),
+        ...Object.values(record(schema.definitions)),
+        schema.items,
+        ...[schema.anyOf, schema.oneOf, schema.allOf].flatMap((items) => Array.isArray(items) ? items : [])
+    ];
+    return children.some(hasOpenFunctionObject);
+}
 function uniqueModelImages(...groups) {
     const seen = new Set();
     return groups.flatMap((group) => (group ?? []).flatMap((image) => {

package/dist/agent-core/model/text-blocks.d.ts

@@ -0,0 +1,7 @@
+import type { ModelTextBlock } from './contracts.js';
+/** Preserve explicit blocks only while their complete texts still match the actual prefix. */
+export declare function resolveModelTextBlocks(text: string, blocks: readonly ModelTextBlock[]): readonly ModelTextBlock[];
+export declare function modelTextInput(value: string | readonly ModelTextBlock[]): {
+    text: string;
+    blocks?: readonly ModelTextBlock[];
+};

package/dist/agent-core/model/text-blocks.js

@@ -0,0 +1,40 @@
+import { MarAgentError } from '../error.js';
+/** Preserve explicit blocks only while their complete texts still match the actual prefix. */
+export function resolveModelTextBlocks(text, blocks) {
+    if (typeof text !== 'string' || !Array.isArray(blocks))
+        throw invalid();
+    const copied = blocks.map((block) => {
+        if (!block ||
+            typeof block !== 'object' ||
+            typeof block.text !== 'string' ||
+            (block.cache !== undefined && block.cache !== true))
+            throw invalid();
+        return { text: block.text, ...(block.cache === true ? { cache: true } : {}) };
+    });
+    let offset = 0;
+    const result = [];
+    for (const block of copied) {
+        if (!text.startsWith(block.text, offset))
+            break;
+        result.push(block);
+        offset += block.text.length;
+    }
+    if (offset < text.length)
+        result.push({ text: text.slice(offset) });
+    return result;
+}
+export function modelTextInput(value) {
+    if (typeof value === 'string')
+        return { text: value };
+    if (!Array.isArray(value))
+        throw invalid();
+    for (const block of value) {
+        if (!block || typeof block !== 'object' || typeof block.text !== 'string')
+            throw invalid();
+    }
+    const text = value.map((block) => block.text).join('');
+    return { text, blocks: resolveModelTextBlocks(text, value) };
+}
+function invalid() {
+    return new MarAgentError('MAR_AGENT_MODEL_TEXT_BLOCK_INVALID', 'Model text blocks are invalid.');
+}

package/dist/agent-core/prompts/index.d.ts

@@ -1,6 +1,7 @@
 import type { ExecutionMode } from '../runtime/contracts.js';
+import { type CorePromptPart } from '../extensions/prompt-composition.js';
 export declare const MAR_AGENT_PROMPT_VERSION = "1.60";
-export declare function buildSystemPrompt(input: {
+interface SystemPromptInput {
     mode: ExecutionMode;
     platform: string;
     architecture?: string;
@@ -14,4 +15,7 @@ export declare function buildSystemPrompt(input: {
     directTools?: readonly string[];
     highDensityCompaction?: boolean;
     extension?: string | undefined;
-}): string;
+}
+export declare function buildSystemPrompt(input: SystemPromptInput): string;
+export declare function buildSystemPromptSections(input: SystemPromptInput): readonly CorePromptPart[];
+export {};

package/dist/agent-core/prompts/index.js

@@ -1,3 +1,4 @@
+import { renderPromptSections } from '../extensions/prompt-composition.js';
 import { compactionPrompt, highDensityCompactionPrompt } from './compact.js';
 import { environmentPrompt, identityPrompt, instructionPriorityPrompt, workspaceDisciplinePrompt } from './core.js';
 import { modePrompt } from './modes.js';
@@ -6,6 +7,9 @@ import { subagentPrompt } from './subagent.js';
 import { interactionPrompt, longRunningPrompt, safetyPrompt, toolUsagePrompt, workflowPrompt } from './workflow.js';
 export const MAR_AGENT_PROMPT_VERSION = '1.60';
 export function buildSystemPrompt(input) {
+    return renderPromptSections(buildSystemPromptSections(input));
+}
+export function buildSystemPromptSections(input) {
     const toolNames = new Set(input.tools);
     const hasLongRunningCapability = [
         'exec',
@@ -15,28 +19,38 @@ export function buildSystemPrompt(input) {
         'agent_wait',
         'agent_cancel'
     ].some((name) => toolNames.has(name));
-    return [
-        identityPrompt(),
-        instructionPriorityPrompt,
-        workspaceDisciplinePrompt,
-        workflowPrompt,
-        interactionPrompt,
-        safetyPrompt,
-        outputStylePrompt,
-        environmentPrompt(input),
-        input.tools.length > 0 ? toolUsagePrompt(input.tools, input.directTools) : '',
-        hasLongRunningCapability ? longRunningPrompt(input.tools) : '',
-        modePrompt(input.mode, {
-            questionAvailable: toolNames.has('question')
-        }),
-        input.mode === 'compact'
-            ? input.highDensityCompaction
-                ? highDensityCompactionPrompt()
-                : compactionPrompt()
-            : '',
-        toolNames.has('agent_start') ? subagentPrompt : '',
-        input.extension ? `# Caller, project, and selected Skill instructions\n${input.extension}` : ''
-    ]
-        .filter(Boolean)
-        .join('\n\n');
+    const values = [
+        ['identity', identityPrompt()],
+        ['instruction-priority', instructionPriorityPrompt],
+        ['workspace-discipline', workspaceDisciplinePrompt],
+        ['workflow', workflowPrompt],
+        ['interaction', interactionPrompt],
+        ['safety', safetyPrompt],
+        ['output-style', outputStylePrompt],
+        ['environment-rules', environmentPrompt(input)],
+        ['tools', input.tools.length > 0 ? toolUsagePrompt(input.tools, input.directTools) : ''],
+        ['long-running', hasLongRunningCapability ? longRunningPrompt(input.tools) : ''],
+        [
+            'mode',
+            modePrompt(input.mode, {
+                questionAvailable: toolNames.has('question')
+            })
+        ],
+        [
+            'compaction',
+            input.mode === 'compact'
+                ? input.highDensityCompaction
+                    ? highDensityCompactionPrompt()
+                    : compactionPrompt()
+                : ''
+        ],
+        ['subagent', toolNames.has('agent_start') ? subagentPrompt : ''],
+        [
+            'caller-instructions',
+            input.extension
+                ? `# Caller, project, and selected Skill instructions\n${input.extension}`
+                : ''
+        ]
+    ];
+    return Object.freeze(values.map(([id, text]) => Object.freeze({ id: `core:${id}`, text: text || null })));
 }

package/dist/agent-core/runtime/context/gc-tokens.js

@@ -1,5 +1,6 @@
 import { openAiInput } from '../../model/openai-responses.js';
 import { countModelTokens } from '../token-budget.js';
+import { observationModelText } from '../../tools/code-mode/observations.js';
 export { MODEL_TOKEN_ESTIMATOR as CONTEXT_GC_TOKEN_ESTIMATOR } from '../token-budget.js';
 /** Uses Responses lowering, including native alias and cross-model filtering. */
 export function contextGcTokenEntries(input, messages) {
@@ -17,7 +18,11 @@ function serializedEntries(input, messages) {
         : messages
             .filter((message) => message.role !== 'provider' ||
             (message.provider === 'ANTHROPIC_MESSAGES' && message.providerModelId === input.modelId))
-            .map(({ observations: _observations, observationId: _observationId, ...message }) => message);
+            .map((original) => {
+            const { observations: _observations, observationId: _observationId, ...message } = original;
+            const content = original.role === 'tool' ? observationModelText(original) : undefined;
+            return content === undefined ? message : { ...message, content };
+        });
     return values.map((value, index) => {
         const item = value;
         const callId = item.call_id ?? item.callId;

package/dist/agent-core/runtime/context/normalize.js

@@ -18,7 +18,27 @@ export function normalizeMessagesForModel(messages, input) {
             content: `[tool result unavailable for call ${callId}: the execution was interrupted before the result was recorded]`
         });
     }
-    return result;
+    // A record committed during tool execution may precede its results in physical history.
+    // Delay only user rows in the request projection; never reorder persisted events.
+    const projected = [];
+    const deferred = [];
+    const pending = new Set();
+    for (const message of result) {
+        if (message.role === 'user' && pending.size) {
+            deferred.push(message);
+            continue;
+        }
+        projected.push(message);
+        const callId = pendingToolCallId(message);
+        if (callId)
+            pending.add(callId);
+        if (message.role === 'tool' && message.callId)
+            pending.delete(message.callId);
+        if (!pending.size && deferred.length)
+            projected.push(...deferred.splice(0));
+    }
+    projected.push(...deferred);
+    return projected;
 }
 function pendingToolCallId(message) {
     if (message.role === 'tool_call')

package/dist/agent-core/runtime/context/projection.js

@@ -74,7 +74,9 @@ export function applyContextGcReplacementsToMessages(messages, messageSources, r
             next = {
                 ...next,
                 observations,
-                content: renderObservationResult(observations, next.content)
+                content: next.textBlocks === undefined
+                    ? renderObservationResult(observations, next.content)
+                    : next.content
             };
         }
         if (replacement && target && targetMatchesReplacement(target, replacement.target)) {
@@ -94,6 +96,11 @@ export function applyContextGcReplacementsToMessages(messages, messageSources, r
                 next.role === 'tool')
                 next = { ...next, content: replacement.replacementContent };
         }
+        if (next.textBlocks !== undefined && next.content !== message.content)
+            next = {
+                ...next,
+                textBlocks: [{ text: next.content }]
+            };
         projected.push({ message: next, source });
     }
     return {
@@ -142,6 +149,19 @@ export function restoreModelContext(payload, providerModelId) {
     const byteLimit = inputLimit === undefined ? MAX_MODEL_CONTEXT_BYTES : inputLimit * 6 + 4096;
     if (Buffer.byteLength(JSON.stringify(payload)) > byteLimit)
         return undefined;
+    if (payload.role === 'user' && typeof payload.content === 'string') {
+        const blocks = payload.textBlocks;
+        const textBlocks = Array.isArray(blocks) &&
+            Array.from(blocks).every((block) => block && typeof block.text === 'string') &&
+            blocks.map((block) => block.text).join('') === payload.content
+            ? blocks.map((block) => ({ text: block.text }))
+            : undefined;
+        return {
+            role: 'user',
+            content: payload.content,
+            ...(textBlocks === undefined ? {} : { textBlocks })
+        };
+    }
     if (payload.role === 'tool' &&
         typeof payload.content === 'string' &&
         typeof payload.callId === 'string')
@@ -149,6 +169,20 @@ export function restoreModelContext(payload, providerModelId) {
             role: 'tool',
             content: payload.content,
             callId: payload.callId,
+            ...(typeof payload.name === 'string' ? { name: payload.name } : {}),
+            ...(typeof payload.isError === 'boolean' ? { isError: payload.isError } : {}),
+            ...(Array.isArray(payload.textBlocks) &&
+                payload.textBlocks.every((block) => block &&
+                    typeof block.text === 'string' &&
+                    (block.cache === undefined || block.cache === true)) &&
+                payload.textBlocks.map((block) => block.text).join('') === payload.content
+                ? {
+                    textBlocks: payload.textBlocks.map((block) => ({
+                        text: block.text,
+                        ...(block.cache === true ? { cache: true } : {})
+                    }))
+                }
+                : {}),
             ...(parseCodeCalls(payload.calls) ? { calls: parseCodeCalls(payload.calls) } : {}),
             ...(parseObservations(payload.observations)
                 ? { observations: parseObservations(payload.observations) }

package/dist/agent-core/runtime/context/request-budget.js

@@ -1,10 +1,13 @@
 import { AGENT_EXECUTION_POLICY } from '../execution-policy.js';
 import { countModelTokens } from '../token-budget.js';
+import { observationModelText } from '../../tools/code-mode/observations.js';
 export function estimatedRequestTokens(system, messages, tools, images) {
     const transientImageCount = messages.reduce((total, message) => total + (message.images?.length ?? 0), images?.length ?? 0);
     const textMessages = messages.map((message) => {
-        const textMessage = { ...message };
-        delete textMessage.images;
+        const { images: _images, observations: _observations, observationId: _observationId, ...textMessage } = message;
+        const content = message.role === 'tool' ? observationModelText(message) : undefined;
+        if (content !== undefined)
+            textMessage.content = content;
         return textMessage;
     });
     return (countModelTokens(`${system}${stableJson(textMessages)}${stableJson(tools)}`) +