@jsonstudio/llms 0.6.230 → 0.6.467

package/dist/conversion/shared/anthropic-message-utils.js

@@ -3,6 +3,7 @@ import { resolveBridgePolicy, resolvePolicyActions } from './bridge-policies.js'
 import { normalizeChatMessageContent } from './chat-output-normalizer.js';
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from './tool-mapping.js';
 import { jsonClone } from '../hub/types/json.js';
+import { ProviderProtocolError } from './errors.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -111,20 +112,39 @@ function extractToolResultSegment(entry) {
     }
     return String(entry);
 }
+function resolveProtocolErrorCode(context) {
+    const ctx = context.toLowerCase();
+    return ctx.includes('tool') ? 'TOOL_PROTOCOL_ERROR' : 'MALFORMED_REQUEST';
+}
 function requireTrimmedString(value, context) {
     if (typeof value !== 'string') {
-        throw new Error(`Anthropic bridge constraint violated: ${context} must be a string`);
+        throw new ProviderProtocolError(`Anthropic bridge constraint violated: ${context} must be a string`, {
+            code: resolveProtocolErrorCode(context),
+            protocol: 'anthropic-messages',
+            providerType: 'anthropic',
+            details: { context, actualType: typeof value }
+        });
     }
     const trimmed = value.trim();
     if (!trimmed.length) {
-        throw new Error(`Anthropic bridge constraint violated: ${context} must not be empty`);
+        throw new ProviderProtocolError(`Anthropic bridge constraint violated: ${context} must not be empty`, {
+            code: resolveProtocolErrorCode(context),
+            protocol: 'anthropic-messages',
+            providerType: 'anthropic',
+            details: { context }
+        });
     }
     return trimmed;
 }
 function requireSystemText(block, context) {
     const text = flattenAnthropicText(block).trim();
     if (!text) {
-        throw new Error(`Anthropic bridge constraint violated: ${context} must contain text`);
+        throw new ProviderProtocolError(`Anthropic bridge constraint violated: ${context} must contain text`, {
+            code: resolveProtocolErrorCode(context),
+            protocol: 'anthropic-messages',
+            providerType: 'anthropic',
+            details: { context }
+        });
     }
     return text;
 }
@@ -266,6 +286,7 @@ export function buildOpenAIChatFromAnthropic(payload) {
             continue;
         }
         const textParts = [];
+        const imageBlocks = [];
         const toolCalls = [];
         const reasoningParts = [];
         const toolResults = [];
@@ -284,6 +305,29 @@ export function buildOpenAIChatFromAnthropic(payload) {
                     reasoningParts.push(thinkingText);
                 }
             }
+            else if (t === 'image') {
+                const source = block.source;
+                if (source && typeof source === 'object') {
+                    const s = source;
+                    const srcType = typeof s.type === 'string' ? s.type.toLowerCase() : '';
+                    let url;
+                    if (srcType === 'url' && typeof s.url === 'string') {
+                        url = s.url;
+                    }
+                    else if (srcType === 'base64' && typeof s.data === 'string') {
+                        const mediaType = typeof s.media_type === 'string' && s.media_type.trim().length
+                            ? s.media_type.trim()
+                            : 'image/png';
+                        url = `data:${mediaType};base64,${s.data}`;
+                    }
+                    if (url && url.trim().length) {
+                        imageBlocks.push({
+                            type: 'image_url',
+                            image_url: { url: url.trim() }
+                        });
+                    }
+                }
+            }
             else if (t === 'tool_use') {
                 const name = requireTrimmedString(block.name, 'tool_use.name');
                 const id = requireTrimmedString(block.id, 'tool_use.id');
@@ -310,10 +354,22 @@ export function buildOpenAIChatFromAnthropic(payload) {
         }
         const hasText = typeof normalized.contentText === 'string' && normalized.contentText.length > 0;
         const hasReasoning = mergedReasoning.length > 0;
-        if (hasText || hasRawText || toolCalls.length > 0 || hasReasoning) {
+        if (hasText || hasRawText || toolCalls.length > 0 || hasReasoning || imageBlocks.length > 0) {
+            let contentNode = (hasText ? normalized.contentText : undefined) ?? combinedText ?? '';
+            if (imageBlocks.length > 0) {
+                const blocks = [];
+                const textPayload = (hasText ? normalized.contentText : undefined) ?? combinedText ?? '';
+                if (typeof textPayload === 'string' && textPayload.trim().length) {
+                    blocks.push({ type: 'text', text: textPayload.trim() });
+                }
+                for (const img of imageBlocks) {
+                    blocks.push(jsonClone(img));
+                }
+                contentNode = blocks;
+            }
             const msg = {
                 role,
-                content: (hasText ? normalized.contentText : undefined) ?? combinedText ?? ''
+                content: contentNode
             };
             if (toolCalls.length)
                 msg.tool_calls = toolCalls;
@@ -674,7 +730,12 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
                 pushSystemBlock(requireSystemText(val, 'top-level system'));
                 return;
             }
-            throw new Error('Anthropic bridge constraint violated: unsupported system payload type');
+            throw new ProviderProtocolError('Anthropic bridge constraint violated: unsupported system payload type', {
+                code: 'MALFORMED_REQUEST',
+                protocol: 'anthropic-messages',
+                providerType: 'anthropic',
+                details: { context: 'top-level system', actualType: typeof val }
+            });
         };
         ingestSystem(sys);
     }
@@ -690,10 +751,16 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
             targetShape = mirrorShapes[mirrorIndex];
             mirrorIndex += 1;
         }
-        const text = collectText(m.content).trim();
+        const contentNode = m.content;
+        const text = collectText(contentNode).trim();
         if (role === 'system') {
             if (!text) {
-                throw new Error('Anthropic bridge constraint violated: Chat system message must contain text');
+                throw new ProviderProtocolError('Anthropic bridge constraint violated: Chat system message must contain text', {
+                    code: 'MALFORMED_REQUEST',
+                    protocol: 'anthropic-messages',
+                    providerType: 'anthropic',
+                    details: { context: 'chat.system', original: contentNode }
+                });
             }
             pushSystemBlock(text);
             continue;
@@ -701,7 +768,12 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
         if (role === 'tool') {
             const toolCallId = requireTrimmedString(m.tool_call_id ?? m.call_id ?? m.tool_use_id ?? m.id, 'tool_result.tool_call_id');
             if (!knownToolCallIds.has(toolCallId)) {
-                throw new Error(`Anthropic bridge constraint violated: tool result ${toolCallId} has no matching tool call`);
+                throw new ProviderProtocolError(`Anthropic bridge constraint violated: tool result ${toolCallId} has no matching tool call`, {
+                    code: 'TOOL_PROTOCOL_ERROR',
+                    protocol: 'anthropic-messages',
+                    providerType: 'anthropic',
+                    details: { toolCallId }
+                });
             }
             const block = {
                 type: 'tool_result',
@@ -715,6 +787,58 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
             continue;
         }
         const blocks = [];
+        if (Array.isArray(contentNode)) {
+            // Preserve or synthesize image blocks where possible, and fall back to text for the rest.
+            for (const entry of contentNode) {
+                if (!entry || typeof entry !== 'object')
+                    continue;
+                const node = entry;
+                const t = typeof node.type === 'string' ? node.type.toLowerCase() : '';
+                if (t === 'image' && node.source && typeof node.source === 'object') {
+                    // Pass-through Anthropic image block as-is.
+                    blocks.push({
+                        type: 'image',
+                        source: jsonClone(node.source)
+                    });
+                    continue;
+                }
+                if (t === 'image_url') {
+                    let url = '';
+                    const imageUrl = node.image_url;
+                    if (typeof imageUrl === 'string') {
+                        url = imageUrl;
+                    }
+                    else if (imageUrl && typeof imageUrl === 'object' && typeof imageUrl.url === 'string') {
+                        url = imageUrl.url;
+                    }
+                    const trimmed = url.trim();
+                    if (!trimmed.length)
+                        continue;
+                    const source = {};
+                    if (trimmed.startsWith('data:')) {
+                        const match = /^data:([^;,]+)?(?:;base64)?,(.*)$/s.exec(trimmed);
+                        if (match) {
+                            const mediaType = (match[1] || '').trim() || 'image/png';
+                            source.type = 'base64';
+                            source.media_type = mediaType;
+                            source.data = match[2] || '';
+                        }
+                        else {
+                            source.type = 'url';
+                            source.url = trimmed;
+                        }
+                    }
+                    else {
+                        source.type = 'url';
+                        source.url = trimmed;
+                    }
+                    blocks.push({
+                        type: 'image',
+                        source
+                    });
+                }
+            }
+        }
         if (text) {
             blocks.push({ type: 'text', text });
         }

package/dist/conversion/shared/bridge-message-utils.js

@@ -66,6 +66,59 @@ function collectText(value) {
     }
     return '';
 }
+function extractImageBlocksFromContent(content) {
+    const images = [];
+    const visit = (value) => {
+        if (!value)
+            return;
+        if (Array.isArray(value)) {
+            for (const entry of value)
+                visit(entry);
+            return;
+        }
+        if (typeof value !== 'object') {
+            return;
+        }
+        const record = value;
+        const typeValue = typeof record.type === 'string' ? record.type.toLowerCase() : '';
+        if (typeValue === 'image' || typeValue === 'image_url' || typeValue === 'input_image') {
+            let url = '';
+            const imageUrl = record.image_url;
+            if (typeof imageUrl === 'string') {
+                url = imageUrl;
+            }
+            else if (imageUrl && typeof imageUrl === 'object' && typeof imageUrl.url === 'string') {
+                url = imageUrl.url;
+            }
+            else if (typeof record.url === 'string') {
+                url = record.url;
+            }
+            else if (typeof record.uri === 'string') {
+                url = record.uri;
+            }
+            else if (typeof record.data === 'string') {
+                url = record.data;
+            }
+            const trimmed = url.trim();
+            if (trimmed.length) {
+                let detail;
+                if (imageUrl && typeof imageUrl === 'object' && typeof imageUrl.detail === 'string') {
+                    detail = imageUrl.detail.trim() || undefined;
+                }
+                else if (typeof record.detail === 'string') {
+                    detail = record.detail.trim() || undefined;
+                }
+                images.push({ url: trimmed, detail });
+            }
+            return;
+        }
+        if (Array.isArray(record.content)) {
+            visit(record.content);
+        }
+    };
+    visit(content);
+    return images;
+}
 function extractUserTextFromEntry(entry) {
     if (!entry || typeof entry !== 'object')
         return '';
@@ -94,6 +147,7 @@ export function convertMessagesToBridgeInput(options) {
         const role = coerceBridgeRole(m.role || 'user');
         const content = m.content;
         const collectedText = collectText(content);
+        const imageBlocks = extractImageBlocksFromContent(content);
         const text = role === 'system' ? collectedText : collectedText.trim();
         if (role === 'system') {
             if (collectedText && collectedText.length) {
@@ -170,13 +224,29 @@ export function convertMessagesToBridgeInput(options) {
             }
             continue;
         }
-        if (typeof text === 'string') {
+        if (typeof text === 'string' || imageBlocks.length) {
             const tRole = role === 'assistant' ? 'output_text' : 'input_text';
-            const entry = {
-                role,
-                content: [{ type: tRole, text }]
-            };
-            input.push(entry);
+            const blocks = [];
+            if (typeof text === 'string' && text.length) {
+                blocks.push({ type: tRole, text });
+            }
+            for (const img of imageBlocks) {
+                const block = {
+                    type: 'input_image',
+                    image_url: img.url
+                };
+                if (img.detail) {
+                    block.detail = img.detail;
+                }
+                blocks.push(block);
+            }
+            if (blocks.length) {
+                const entry = {
+                    role,
+                    content: blocks
+                };
+                input.push(entry);
+            }
             if (role === 'user') {
                 const trimmed = typeof text === 'string' ? text.trim() : '';
                 if (trimmed.length) {
@@ -260,6 +330,7 @@ function processMessageBlocks(blocks, normalizeFunctionName, tools, toolNameById
     const toolMessages = [];
     let currentLastCall = lastToolCallId;
     const reasoningSegments = [];
+    const images = [];
     for (const block of blocks) {
         if (!block || typeof block !== 'object')
             continue;
@@ -282,6 +353,18 @@ function processMessageBlocks(blocks, normalizeFunctionName, tools, toolNameById
                 toolMessages.push(tm);
             currentLastCall = nested.lastCallId;
             reasoningSegments.push(...nested.reasoningSegments);
+            if (nested.images.length)
+                images.push(...nested.images);
+            continue;
+        }
+        if (type === 'input_image') {
+            const url = typeof block.image_url === 'string' ? block.image_url.trim() : '';
+            if (url) {
+                const detail = typeof block.detail === 'string' && block.detail.trim()
+                    ? block.detail.trim()
+                    : undefined;
+                images.push({ url, detail });
+            }
             continue;
         }
         if (type === 'function_call') {
@@ -344,7 +427,7 @@ function processMessageBlocks(blocks, normalizeFunctionName, tools, toolNameById
         }
     }
     const text = textParts.length ? textParts.join('\n').trim() : null;
-    return { text, toolCalls, toolMessages, lastCallId: currentLastCall, reasoningSegments };
+    return { text, images, toolCalls, toolMessages, lastCallId: currentLastCall, reasoningSegments };
 }
 export function convertBridgeInputToChatMessages(options) {
     const { input, tools, normalizeFunctionName, toolResultFallbackText } = options;
@@ -470,7 +553,29 @@ export function convertBridgeInputToChatMessages(options) {
             for (const msg of nested.toolMessages)
                 messages.push(msg);
             const normalizedRole = coerceBridgeRole((explicit.role ?? entry.role) || 'user');
-            if (typeof nested.text === 'string') {
+            if (nested.images.length) {
+                const contentBlocks = [];
+                if (typeof nested.text === 'string' && nested.text.trim().length) {
+                    contentBlocks.push({ type: 'text', text: nested.text });
+                }
+                for (const img of nested.images) {
+                    const imgBlock = { type: 'image_url', image_url: { url: img.url } };
+                    if (img.detail) {
+                        imgBlock.image_url.detail = img.detail;
+                    }
+                    contentBlocks.push(imgBlock);
+                }
+                const msg = {
+                    role: normalizedRole,
+                    content: contentBlocks
+                };
+                const combinedReasoning = combineReasoningSegments(consumeEntryReasoning(), nested.reasoningSegments);
+                if (combinedReasoning.length) {
+                    msg.reasoning_content = combinedReasoning.join('\n');
+                }
+                messages.push(msg);
+            }
+            else if (typeof nested.text === 'string') {
                 pushNormalizedChatMessage(messages, normalizedRole, nested.text, {
                     reasoningSegments: combineReasoningSegments(consumeEntryReasoning(), nested.reasoningSegments)
                 });
@@ -491,9 +596,31 @@ export function convertBridgeInputToChatMessages(options) {
             for (const msg of nested.toolMessages)
                 messages.push(msg);
             const normalizedRole = coerceBridgeRole(entry.role || 'user');
-            if (typeof nested.text === 'string') {
+            if (nested.images.length) {
+                const contentBlocks = [];
+                if (typeof nested.text === 'string' && nested.text.trim().length) {
+                    contentBlocks.push({ type: 'text', text: nested.text });
+                }
+                for (const img of nested.images) {
+                    const imgBlock = { type: 'image_url', image_url: { url: img.url } };
+                    if (img.detail) {
+                        imgBlock.image_url.detail = img.detail;
+                    }
+                    contentBlocks.push(imgBlock);
+                }
+                const msg = {
+                    role: normalizedRole,
+                    content: contentBlocks
+                };
+                const combinedReasoning = combineReasoningSegments(consumeEntryReasoning(), nested.reasoningSegments);
+                if (combinedReasoning.length) {
+                    msg.reasoning_content = combinedReasoning.join('\n');
+                }
+                messages.push(msg);
+            }
+            else if (typeof nested.text === 'string') {
                 pushNormalizedChatMessage(messages, normalizedRole, nested.text, {
-                    reasoningSegments: combineReasoningSegments(consumeEntryReasoning(), nested.reasoningSegments)
+                    reasoningSegments: consumeEntryReasoning()
                 });
             }
             lastToolCallId = nested.lastCallId;

package/dist/conversion/shared/errors.d.ts

@@ -0,0 +1,20 @@
+export type ProviderProtocolErrorCode = 'TOOL_PROTOCOL_ERROR' | 'SSE_DECODE_ERROR' | 'MALFORMED_RESPONSE' | 'MALFORMED_REQUEST';
+export type ProviderErrorCategory = 'EXTERNAL_ERROR' | 'TOOL_ERROR' | 'INTERNAL_ERROR';
+export interface ProviderProtocolErrorOptions {
+    code: ProviderProtocolErrorCode;
+    protocol?: string;
+    providerType?: string;
+    /**
+     * 粗粒度错误类别；若未显式指定，将基于 code 自动推导。
+     */
+    category?: ProviderErrorCategory;
+    details?: Record<string, unknown>;
+}
+export declare class ProviderProtocolError extends Error {
+    readonly code: ProviderProtocolErrorCode;
+    readonly protocol?: string;
+    readonly providerType?: string;
+    readonly category: ProviderErrorCategory;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, options: ProviderProtocolErrorOptions);
+}

package/dist/conversion/shared/errors.js

@@ -0,0 +1,28 @@
+function inferCategoryFromCode(code) {
+    switch (code) {
+        case 'TOOL_PROTOCOL_ERROR':
+            return 'TOOL_ERROR';
+        case 'SSE_DECODE_ERROR':
+        case 'MALFORMED_RESPONSE':
+        case 'MALFORMED_REQUEST':
+        default:
+            // 默认视为外部协议/载荷问题；真正的内部错误由上层使用 INTERNAL_ERROR 显式标记。
+            return 'EXTERNAL_ERROR';
+    }
+}
+export class ProviderProtocolError extends Error {
+    code;
+    protocol;
+    providerType;
+    category;
+    details;
+    constructor(message, options) {
+        super(message);
+        this.name = 'ProviderProtocolError';
+        this.code = options.code;
+        this.protocol = options.protocol;
+        this.providerType = options.providerType;
+        this.category = options.category ?? inferCategoryFromCode(options.code);
+        this.details = options.details;
+    }
+}

package/dist/conversion/shared/responses-conversation-store.js

@@ -1,3 +1,4 @@
+import { ProviderProtocolError } from './errors.js';
 const TTL_MS = 1000 * 60 * 30; // 30min
 function cloneDeep(value) {
     try {
@@ -205,16 +206,42 @@ class ResponsesConversationStore {
     }
     resumeConversation(responseId, submitPayload, options) {
         if (typeof responseId !== 'string' || !responseId.trim()) {
-            throw new Error('Responses conversation requires valid response_id');
+            throw new ProviderProtocolError('Responses conversation requires valid response_id', {
+                code: 'MALFORMED_REQUEST',
+                protocol: 'openai-responses',
+                providerType: 'responses',
+                details: {
+                    context: 'responses-conversation-store.resumeConversation',
+                    reason: 'missing_or_empty_response_id'
+                }
+            });
         }
         this.prune();
         const entry = this.responseIndex.get(responseId);
         if (!entry) {
-            throw new Error('Responses conversation expired or not found');
+            throw new ProviderProtocolError('Responses conversation expired or not found', {
+                code: 'MALFORMED_REQUEST',
+                protocol: 'openai-responses',
+                providerType: 'responses',
+                details: {
+                    context: 'responses-conversation-store.resumeConversation',
+                    reason: 'expired_or_unknown_response_id',
+                    responseId
+                }
+            });
         }
         const toolOutputs = Array.isArray(submitPayload.tool_outputs) ? submitPayload.tool_outputs : [];
         if (!toolOutputs.length) {
-            throw new Error('tool_outputs array is required when submitting Responses tool results');
+            throw new ProviderProtocolError('tool_outputs array is required when submitting Responses tool results', {
+                code: 'MALFORMED_REQUEST',
+                protocol: 'openai-responses',
+                providerType: 'responses',
+                details: {
+                    context: 'responses-conversation-store.resumeConversation',
+                    reason: 'missing_tool_outputs',
+                    responseId
+                }
+            });
         }
         const mergedInput = coerceInputArray(entry.input);
         const normalizedOutputs = normalizeSubmittedToolOutputs(toolOutputs);

package/dist/conversion/shared/responses-output-builder.js

@@ -1,6 +1,41 @@
 import { normalizeFunctionCallId } from './bridge-id-utils.js';
 import { normalizeContentPart } from './output-content-normalizer.js';
 import { expandResponsesMessageItem } from '../../sse/shared/responses-output-normalizer.js';
+function buildToolOutputIndex(response) {
+    const ids = new Set();
+    try {
+        const primary = Array.isArray(response.tool_outputs)
+            ? response.tool_outputs
+            : [];
+        for (const entry of primary) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const raw = entry.tool_call_id ||
+                entry.call_id ||
+                entry.id;
+            if (typeof raw === 'string' && raw.trim().length) {
+                const trimmed = raw.trim();
+                // 记录原始 ID（例如 OpenAI 的 toolu_ 前缀），以兼容直接使用
+                // tool_call_id 的客户端；同时记录归一化后的 fc_ 形式，保证与
+                // buildFunctionCallOutput 中 normalizeFunctionCallId 的结果对齐。
+                ids.add(trimmed);
+                try {
+                    const normalized = normalizeFunctionCallId({ callId: trimmed, fallback: trimmed });
+                    if (normalized && normalized !== trimmed) {
+                        ids.add(normalized);
+                    }
+                }
+                catch {
+                    // 归一化失败不应影响主流程
+                }
+            }
+        }
+    }
+    catch {
+        // best-effort: 不因索引构建失败影响主流程
+    }
+    return ids;
+}
 function appendReasoningSegments(target, raw) {
     if (typeof raw !== 'string' || !raw.length) {
         return;
@@ -91,7 +126,13 @@ export function buildResponsesOutputFromChat(options) {
     const usage = normalizeUsage(response.usage);
     const outputTextMeta = response?.__responses_output_text_meta;
     const outputText = resolveOutputText(convertedContent, outputTextMeta);
-    const hasNormalizedToolCalls = normalizedToolCalls.length > 0;
+    // 如果顶层 tool_outputs 已经为所有 tool_calls 提供了结果，说明这些函数调用
+    // 已在服务端（例如 server-side web_search）完成，不应再对客户端暴露
+    // required_action/submit_tool_outputs。此时只需返回 completed 状态即可，避免
+    // 再触发一轮工具回合。
+    const executedIds = buildToolOutputIndex(response);
+    const pendingToolCalls = normalizedToolCalls.filter((entry) => !executedIds.has(entry.id));
+    const hasNormalizedToolCalls = pendingToolCalls.length > 0;
     if (hasNormalizedToolCalls) {
         for (const item of outputItems) {
             if (item.type === 'message') {
@@ -100,7 +141,7 @@ export function buildResponsesOutputFromChat(options) {
         }
     }
     const requiredAction = hasNormalizedToolCalls
-        ? buildRequiredActionFromNormalized(normalizedToolCalls)
+        ? buildRequiredActionFromNormalized(pendingToolCalls)
         : undefined;
     const status = hasNormalizedToolCalls ? 'requires_action' : 'completed';
     return {
@@ -136,6 +177,47 @@ function normalizeUsage(usageRaw) {
     }
     return usageRaw;
 }
+function extractApplyPatchArguments(rawArgs) {
+    // Upstream Responses providers may wrap apply_patch arguments in a JSON object
+    // (e.g. { patch: '*** Begin Patch...', input: '...' }). For Codex, the tool
+    // expects a FREEFORM patch string obeying the unified diff grammar. Here we
+    // best-effort extract such a patch string when available.
+    const tryExtractFromObject = (obj) => {
+        if (!obj || typeof obj !== 'object' || Array.isArray(obj))
+            return null;
+        const record = obj;
+        const candidates = ['patch', 'input'];
+        for (const key of candidates) {
+            const value = record[key];
+            if (typeof value !== 'string')
+                continue;
+            const trimmed = value.trimStart();
+            if (trimmed.startsWith('*** Begin Patch')) {
+                return trimmed;
+            }
+        }
+        return null;
+    };
+    if (typeof rawArgs === 'string') {
+        const trimmed = rawArgs.trimStart();
+        if (trimmed.startsWith('*** Begin Patch')) {
+            return trimmed;
+        }
+        try {
+            const parsed = JSON.parse(rawArgs);
+            const fromObject = tryExtractFromObject(parsed);
+            if (fromObject) {
+                return fromObject;
+            }
+        }
+        catch {
+            // non-JSON string that is not a patch header; leave to caller
+        }
+        return null;
+    }
+    const fromObject = tryExtractFromObject(rawArgs);
+    return fromObject;
+}
 function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, baseCount, offset) {
     try {
         const fn = call?.function || {};
@@ -146,16 +228,37 @@ function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, b
         if (!sanitized || sanitized.toLowerCase() === 'tool')
             return null;
         const rawArgs = fn?.arguments ?? call.arguments ?? {};
-        const argsStr = typeof rawArgs === 'string'
-            ? rawArgs
-            : (() => {
+        let argsStr;
+        if (sanitized === 'apply_patch') {
+            const patch = extractApplyPatchArguments(rawArgs);
+            if (patch != null) {
+                argsStr = patch;
+            }
+            else if (typeof rawArgs === 'string') {
+                argsStr = rawArgs;
+            }
+            else {
                 try {
-                    return JSON.stringify(rawArgs ?? {});
+                    argsStr = JSON.stringify(rawArgs ?? {});
                 }
                 catch {
-                    return '{}';
+                    argsStr = '{}';
                 }
-            })();
+            }
+        }
+        else {
+            argsStr =
+                typeof rawArgs === 'string'
+                    ? rawArgs
+                    : (() => {
+                        try {
+                            return JSON.stringify(rawArgs ?? {});
+                        }
+                        catch {
+                            return '{}';
+                        }
+                    })();
+        }
         const originalCallId = typeof call.id === 'string' && call.id.trim().length
             ? String(call.id)
             : (typeof call.call_id === 'string' && call.call_id.trim().length ? String(call.call_id) : undefined);