@myagentroam/agent 0.9.158 → 0.9.160

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

@@ -7,7 +7,9 @@ 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';
 export const OPENAI_RESPONSES_WEBSOCKET_CONNECTION_LIMIT_REASON = 'OPENAI_RESPONSES_WEBSOCKET_CONNECTION_LIMIT';
 const X_CODEX_TURN_STATE = 'x-codex-turn-state';
@@ -624,6 +626,7 @@ class OpenAiResponsesTurnSession {
     #fullBody;
     #completedResponseId;
     #connectionDiagnostic;
+    #webSocketDiagnostic;
     constructor(adapter, state, cacheLease) {
         this.adapter = adapter;
         this.state = state;
@@ -735,9 +738,13 @@ class OpenAiResponsesTurnSession {
     }
     beginAttempt() {
         this.#connectionDiagnostic = undefined;
+        this.#webSocketDiagnostic = undefined;
+    }
+    captureWebSocketDiagnostic(diagnostic) {
+        this.#webSocketDiagnostic = diagnostic;
     }
     connectionDiagnostic() {
-        return this.#connectionDiagnostic ?? {};
+        return { ...this.#connectionDiagnostic, ...this.#webSocketDiagnostic };
     }
     captureTurnState(value) {
         if (this.#turnState !== undefined || typeof value !== 'string')
@@ -855,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'
@@ -881,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,
@@ -933,6 +958,7 @@ function responsesContinuationPropertiesMatch(previous, current) {
         'instructions',
         'tools',
         'tool_choice',
+        'max_output_tokens',
         'parallel_tool_calls',
         'reasoning',
         'store',
@@ -1010,6 +1036,10 @@ async function* parseOpenAiResponsesSse(response, signal, continuation) {
     }
 }
 async function* webSocketResponseEvents(input) {
+    const body = input.turn.withTurnStateMetadata(input.body);
+    const payload = Buffer.from(JSON.stringify({ type: 'response.create', ...body }), 'utf8');
+    const diagnostic = webSocketRequestDiagnostic(body, payload.length);
+    input.turn.captureWebSocketDiagnostic(diagnostic);
     const socket = await input.turn.webSocketForRequest({
         configuration: input.configuration,
         promptCacheKey: input.promptCacheKey,
@@ -1018,32 +1048,75 @@ async function* webSocketResponseEvents(input) {
         continuation: input.continuation,
         credentialAcquired: input.credentialAcquired
     });
-    const body = input.turn.withTurnStateMetadata(input.body);
-    await sendWebSocketMessage(socket, JSON.stringify({ type: 'response.create', ...body }), input.signal);
-    let terminal = false;
-    for await (const item of webSocketMessages(socket, input.signal)) {
-        const event = record(item);
-        const type = text(event.type);
-        input.turn.captureTurnState(turnStateFromEvent(event));
-        if (type !== 'response.metadata' && type !== 'codex.response.metadata')
-            yield item;
-        if (type === 'response.completed' ||
-            type === 'response.incomplete' ||
-            type === 'response.failed' ||
-            type === 'error') {
-            terminal = true;
-            return;
+    const messages = webSocketMessages(socket, input.signal, (code) => {
+        diagnostic.webSocketCloseCode = code;
+    });
+    try {
+        diagnostic.webSocketPhase = 'SEND';
+        await sendWebSocketMessage(socket, payload, input.signal, () => {
+            diagnostic.sentFrameCount = (diagnostic.sentFrameCount ?? 0) + 1;
+        });
+        diagnostic.webSocketPhase = 'RECEIVE';
+        let terminal = false;
+        for await (const item of messages) {
+            const event = record(item);
+            const type = text(event.type);
+            input.turn.captureTurnState(turnStateFromEvent(event));
+            if (type !== 'response.metadata' && type !== 'codex.response.metadata')
+                yield item;
+            if (type === 'response.completed' ||
+                type === 'response.incomplete' ||
+                type === 'response.failed' ||
+                type === 'error') {
+                terminal = true;
+                return;
+            }
         }
+        if (!terminal && !input.signal.aborted)
+            throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'OpenAI Responses WebSocket closed before a terminal event.', {
+                details: {
+                    reason: OPENAI_RESPONSES_EARLY_EOF_REASON,
+                    transport: 'WEBSOCKET',
+                    continuation: input.continuation
+                },
+                retryable: true
+            });
+    }
+    finally {
+        messages.dispose();
     }
-    if (!terminal && !input.signal.aborted)
-        throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'OpenAI Responses WebSocket closed before a terminal event.', {
-            details: {
-                reason: OPENAI_RESPONSES_EARLY_EOF_REASON,
-                transport: 'WEBSOCKET',
-                continuation: input.continuation
-            },
-            retryable: true
-        });
+}
+function webSocketRequestDiagnostic(body, requestBytes) {
+    let imageCount = 0;
+    let imageBytes = 0;
+    for (const item of body.input) {
+        const entry = record(item);
+        const parts = Array.isArray(entry.content)
+            ? entry.content
+            : Array.isArray(entry.output)
+                ? entry.output
+                : [];
+        for (const value of parts) {
+            const part = record(value);
+            if (part.type !== 'input_image')
+                continue;
+            imageCount++;
+            const url = text(part.image_url);
+            if (url === undefined)
+                continue;
+            const marker = url.indexOf(';base64,');
+            if (url.startsWith('data:') && marker >= 0)
+                imageBytes += Buffer.byteLength(url.slice(marker + 8), 'base64');
+        }
+    }
+    return {
+        requestBytes,
+        imageCount,
+        imageBytes,
+        requestFrameCount: Math.ceil(requestBytes / WEBSOCKET_SEND_FRAME_BYTES),
+        sentFrameCount: 0,
+        webSocketPhase: 'CONNECT'
+    };
 }
 async function waitForWebSocketOpen(socket, signal) {
     if (signal.aborted) {
@@ -1101,29 +1174,55 @@ async function waitForWebSocketOpen(socket, signal) {
         socket.once('unexpected-response', unexpectedResponse);
     });
 }
-async function sendWebSocketMessage(socket, value, signal) {
-    if (signal.aborted)
-        throw signal.reason;
-    await new Promise((resolve, reject) => {
-        const cleanup = () => signal.removeEventListener('abort', abort);
-        const abort = () => {
-            socket.terminate();
-            cleanup();
-            reject(signal.reason);
-        };
-        signal.addEventListener('abort', abort, { once: true });
-        socket.send(value, (error) => {
-            cleanup();
-            if (error)
-                reject(webSocketReceiveError(error));
-            else if (signal.aborted)
+async function sendWebSocketMessage(socket, payload, signal, frameSent) {
+    for (let offset = 0; offset < payload.length; offset += WEBSOCKET_SEND_FRAME_BYTES) {
+        if (signal.aborted)
+            throw signal.reason;
+        const end = Math.min(payload.length, offset + WEBSOCKET_SEND_FRAME_BYTES);
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const cleanup = () => {
+                settled = true;
+                signal.removeEventListener('abort', abort);
+                socket.off('error', error);
+                socket.off('close', close);
+            };
+            const abort = () => {
+                cleanup();
+                socket.terminate();
                 reject(signal.reason);
-            else
-                resolve();
+            };
+            const error = (cause) => {
+                cleanup();
+                reject(webSocketReceiveError(cause));
+            };
+            const close = () => error(new Error('WebSocket closed while sending the request.'));
+            signal.addEventListener('abort', abort, { once: true });
+            socket.once('error', error);
+            socket.once('close', close);
+            try {
+                socket.send(payload.subarray(offset, end), { binary: false, fin: end === payload.length }, (cause) => {
+                    if (settled)
+                        return;
+                    cleanup();
+                    if (cause)
+                        reject(webSocketReceiveError(cause));
+                    else if (signal.aborted)
+                        reject(signal.reason);
+                    else {
+                        frameSent();
+                        resolve();
+                    }
+                });
+            }
+            catch (cause) {
+                cleanup();
+                reject(webSocketReceiveError(cause));
+            }
         });
-    });
+    }
 }
-async function* webSocketMessages(socket, signal) {
+function webSocketMessages(socket, signal, closed) {
     const queue = [];
     let resume;
     const push = (item) => {
@@ -1136,7 +1235,10 @@ async function* webSocketMessages(socket, signal) {
         value,
         observedAt: performance.now()
     });
-    const close = () => push({ type: 'closed' });
+    const close = (code) => {
+        closed(code);
+        push({ type: 'closed' });
+    };
     const error = (cause) => push({
         type: 'error',
         error: webSocketReceiveError(cause)
@@ -1153,49 +1255,57 @@ async function* webSocketMessages(socket, signal) {
     socket.on('close', close);
     socket.on('error', error);
     signal.addEventListener('abort', abort, { once: true });
-    try {
-        let idleDeadline = Date.now() + WEBSOCKET_IDLE_TIMEOUT_MS;
-        while (true) {
-            if (Date.now() >= idleDeadline)
-                throw webSocketIdleError(socket);
-            if (queue.length === 0)
-                await new Promise((resolve, reject) => {
-                    const timer = setTimeout(() => {
-                        resume = undefined;
-                        reject(webSocketIdleError(socket));
-                    }, Math.max(0, idleDeadline - Date.now()));
-                    resume = () => {
-                        clearTimeout(timer);
-                        resolve();
-                    };
-                });
-            const item = queue.shift();
-            if (item === undefined)
-                continue;
-            if (item.type === 'closed')
-                return;
-            if (item.type === 'error')
-                throw item.error;
-            const text = await webSocketMessageText(item.value);
-            if (Buffer.byteLength(text) > 16 * 1024 * 1024)
-                throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model response exceeded the size limit.');
-            try {
-                const event = JSON.parse(text);
-                if (!isWebSocketNonProgressEvent(event))
-                    idleDeadline = Date.now() + WEBSOCKET_IDLE_TIMEOUT_MS;
-                yield observeModelStreamEvent(event, item.observedAt);
-            }
-            catch (cause) {
-                throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model WebSocket contained invalid JSON.', { cause });
-            }
-        }
-    }
-    finally {
+    const dispose = () => {
         signal.removeEventListener('abort', abort);
         socket.off('message', message);
         socket.off('close', close);
         socket.off('error', error);
-    }
+    };
+    return {
+        dispose,
+        async *[Symbol.asyncIterator]() {
+            try {
+                let idleDeadline = Date.now() + WEBSOCKET_IDLE_TIMEOUT_MS;
+                while (true) {
+                    if (Date.now() >= idleDeadline)
+                        throw webSocketIdleError(socket);
+                    if (queue.length === 0)
+                        await new Promise((resolve, reject) => {
+                            const timer = setTimeout(() => {
+                                resume = undefined;
+                                reject(webSocketIdleError(socket));
+                            }, Math.max(0, idleDeadline - Date.now()));
+                            resume = () => {
+                                clearTimeout(timer);
+                                resolve();
+                            };
+                        });
+                    const item = queue.shift();
+                    if (item === undefined)
+                        continue;
+                    if (item.type === 'closed')
+                        return;
+                    if (item.type === 'error')
+                        throw item.error;
+                    const text = await webSocketMessageText(item.value);
+                    if (Buffer.byteLength(text) > 16 * 1024 * 1024)
+                        throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model response exceeded the size limit.');
+                    try {
+                        const event = JSON.parse(text);
+                        if (!isWebSocketNonProgressEvent(event))
+                            idleDeadline = Date.now() + WEBSOCKET_IDLE_TIMEOUT_MS;
+                        yield observeModelStreamEvent(event, item.observedAt);
+                    }
+                    catch (cause) {
+                        throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model WebSocket contained invalid JSON.', { cause });
+                    }
+                }
+            }
+            finally {
+                dispose();
+            }
+        }
+    };
 }
 function webSocketIdleError(socket) {
     terminateWebSocket(socket);
@@ -1597,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,
@@ -1771,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;