@jsonstudio/llms 0.6.2 → 0.6.6

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/index.js

@@ -1,4 +1,5 @@
 import { captureResponsesContext, buildChatRequestFromResponses } from '../../../../../responses/responses-openai-bridge.js';
+import { captureResponsesRequestContext } from '../../../../../shared/responses-conversation-store.js';
 import { recordStage } from '../../../stages/utils.js';
 export async function runReqInboundStage3ContextCapture(options) {
     let context;
@@ -18,6 +19,18 @@ export async function runReqInboundStage3ContextCapture(options) {
         ? augmentContextSnapshot(context, fallbackSnapshot)
         : fallbackSnapshot;
     recordStage(options.stageRecorder, 'req_inbound_stage3_context_capture', snapshot);
+    if (options.adapterContext.providerProtocol === 'openai-responses') {
+        try {
+            captureResponsesRequestContext({
+                requestId: options.adapterContext.requestId,
+                payload: options.rawRequest,
+                context: snapshot
+            });
+        }
+        catch {
+            /* ignore capture failures */
+        }
+    }
     return context ?? snapshot;
 }
 export function runChatContextCapture(options) {

package/dist/conversion/hub/response/response-mappers.d.ts

@@ -9,7 +9,7 @@ export declare class OpenAIChatResponseMapper implements ResponseMapper {
     toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
 }
 export declare class ResponsesResponseMapper implements ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
+    toChatCompletion(format: FormatEnvelope, ctx: AdapterContext): ChatCompletionLike;
 }
 export declare class AnthropicResponseMapper implements ResponseMapper {
     toChatCompletion(format: FormatEnvelope, ctx: AdapterContext): ChatCompletionLike;

package/dist/conversion/hub/response/response-mappers.js

@@ -1,5 +1,6 @@
 import { buildOpenAIChatFromGeminiResponse } from '../../codecs/gemini-openai-codec.js';
 import { buildChatResponseFromResponses } from '../../shared/responses-response-utils.js';
+import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
 import { buildOpenAIChatFromAnthropicMessage } from './response-runtime.js';
 export class OpenAIChatResponseMapper {
     toChatCompletion(format, _ctx) {
@@ -7,8 +8,17 @@ export class OpenAIChatResponseMapper {
     }
 }
 export class ResponsesResponseMapper {
-    toChatCompletion(format, _ctx) {
-        return buildChatResponseFromResponses(format.payload ?? {});
+    toChatCompletion(format, ctx) {
+        const payload = (format.payload ?? {});
+        if (ctx?.requestId) {
+            try {
+                recordResponsesResponse({ requestId: ctx.requestId, response: payload });
+            }
+            catch {
+                /* ignore capture failures */
+            }
+        }
+        return buildChatResponseFromResponses(payload);
     }
 }
 export class AnthropicResponseMapper {

package/dist/conversion/shared/responses-conversation-store.d.ts

@@ -0,0 +1,35 @@
+type AnyRecord = Record<string, unknown>;
+interface CaptureContextArgs {
+    requestId?: string;
+    payload: AnyRecord;
+    context: AnyRecord;
+}
+interface RecordResponseArgs {
+    requestId?: string;
+    response: AnyRecord;
+}
+interface ResumeOptions {
+    requestId?: string;
+}
+interface ResumeResult {
+    payload: AnyRecord;
+    meta: AnyRecord;
+}
+declare class ResponsesConversationStore {
+    private requestMap;
+    private responseIndex;
+    rebindRequestId(oldId: string | undefined, newId: string | undefined): void;
+    captureRequestContext(args: CaptureContextArgs): void;
+    recordResponse(args: RecordResponseArgs): void;
+    resumeConversation(responseId: string, submitPayload: AnyRecord, options?: ResumeOptions): ResumeResult;
+    clearRequest(requestId?: string): void;
+    private cleanupEntry;
+    private prune;
+}
+declare const store: ResponsesConversationStore;
+export declare function captureResponsesRequestContext(args: CaptureContextArgs): void;
+export declare function recordResponsesResponse(args: RecordResponseArgs): void;
+export declare function resumeResponsesConversation(responseId: string, submitPayload: AnyRecord, options?: ResumeOptions): ResumeResult;
+export declare function clearResponsesConversationByRequestId(requestId?: string): void;
+export declare function rebindResponsesConversationRequestId(oldId?: string, newId?: string): void;
+export { store as responsesConversationStore };

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

@@ -1,4 +1,4 @@
-const TTL_MS = 1000 * 60 * 30; // 30 minutes safety window
+const TTL_MS = 1000 * 60 * 30; // 30min
 function cloneDeep(value) {
     try {
         if (typeof globalThis.structuredClone === 'function') {
@@ -49,19 +49,26 @@ function pickPersistedFields(payload) {
         'input_audio',
         'output_audio'
     ];
-    const result = {};
+    const next = {};
     for (const key of fields) {
         if (payload[key] !== undefined) {
-            result[key] = cloneDeep(payload[key]);
+            next[key] = cloneDeep(payload[key]);
         }
     }
-    return result;
+    return next;
 }
 function normalizeOutputItemToInput(item) {
+    if (!item || typeof item !== 'object') {
+        return null;
+    }
     const type = typeof item.type === 'string' ? item.type : '';
     if (type === 'message' || type === 'reasoning') {
         const role = typeof item.role === 'string' ? item.role : 'assistant';
-        const content = Array.isArray(item.content) ? cloneDeep(item.content) : (typeof item.text === 'string' ? [{ type: 'text', text: item.text }] : []);
+        const content = Array.isArray(item.content)
+            ? cloneDeep(item.content)
+            : typeof item.text === 'string'
+                ? [{ type: 'text', text: item.text }]
+                : [];
         return {
             type: 'message',
             role,
@@ -70,7 +77,11 @@ function normalizeOutputItemToInput(item) {
         };
     }
     if (type === 'function_call') {
-        const callId = typeof item.call_id === 'string' ? item.call_id : (typeof item.id === 'string' ? item.id : undefined);
+        const callId = typeof item.call_id === 'string'
+            ? item.call_id
+            : typeof item.id === 'string'
+                ? item.id
+                : undefined;
         return {
             type: 'function_call',
             role: 'assistant',
@@ -80,9 +91,9 @@ function normalizeOutputItemToInput(item) {
             arguments: item.arguments,
             function: isRecord(item.function)
                 ? cloneDeep(item.function)
-                : (typeof item.name === 'string'
+                : typeof item.name === 'string'
                     ? { name: item.name, arguments: item.arguments }
-                    : undefined)
+                    : undefined
         };
     }
     return null;
@@ -139,6 +150,18 @@ function normalizeSubmittedToolOutputs(toolOutputs) {
 class ResponsesConversationStore {
     requestMap = new Map();
     responseIndex = new Map();
+    rebindRequestId(oldId, newId) {
+        if (!oldId || !newId || oldId === newId) {
+            return;
+        }
+        const entry = this.requestMap.get(oldId);
+        if (!entry) {
+            return;
+        }
+        this.requestMap.delete(oldId);
+        entry.requestId = newId;
+        this.requestMap.set(newId, entry);
+    }
     captureRequestContext(args) {
         const { requestId, payload, context } = args;
         if (!requestId || !payload)
@@ -148,7 +171,8 @@ class ResponsesConversationStore {
             requestId,
             basePayload: pickPersistedFields(payload),
             input: coerceInputArray(context.input),
-            tools: coerceTools(context.toolsRaw || (Array.isArray(payload.tools) ? payload.tools : undefined)),
+            tools: coerceTools(context.toolsRaw) ||
+                coerceTools(Array.isArray(payload.tools) ? payload.tools : undefined),
             createdAt: Date.now(),
             updatedAt: Date.now()
         };
@@ -164,7 +188,7 @@ class ResponsesConversationStore {
         this.requestMap.set(requestId, entry);
     }
     recordResponse(args) {
-        const entry = this.requestMap.get(args.requestId);
+        const entry = args.requestId ? this.requestMap.get(args.requestId) : undefined;
         if (!entry)
             return;
         const response = args.response;
@@ -188,9 +212,7 @@ class ResponsesConversationStore {
         if (!entry) {
             throw new Error('Responses conversation expired or not found');
         }
-        const toolOutputs = Array.isArray(submitPayload.tool_outputs)
-            ? submitPayload.tool_outputs
-            : [];
+        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');
         }
@@ -208,7 +230,8 @@ class ResponsesConversationStore {
             payload.model = submitPayload.model.trim();
         }
         if (submitPayload.metadata && isRecord(submitPayload.metadata)) {
-            payload.metadata = { ...payload.metadata, ...cloneDeep(submitPayload.metadata) };
+            const baseMeta = isRecord(payload.metadata) ? payload.metadata : {};
+            payload.metadata = { ...baseMeta, ...cloneDeep(submitPayload.metadata) };
         }
         delete payload.tool_outputs;
         delete payload.response_id;
@@ -225,6 +248,8 @@ class ResponsesConversationStore {
         };
     }
     clearRequest(requestId) {
+        if (!requestId)
+            return;
         const entry = this.requestMap.get(requestId);
         if (!entry)
             return;
@@ -254,10 +279,14 @@ class ResponsesConversationStore {
         }
     }
 }
-export const responsesConversationStore = new ResponsesConversationStore();
+const store = new ResponsesConversationStore();
+const RESPONSES_DEBUG = (process.env.ROUTECODEX_RESPONSES_DEBUG || '').trim() === '1';
 export function captureResponsesRequestContext(args) {
     try {
-        responsesConversationStore.captureRequestContext(args);
+        if (RESPONSES_DEBUG) {
+            console.log('[responses-store] capture', args.requestId);
+        }
+        store.captureRequestContext(args);
     }
     catch {
         /* ignore capture failures */
@@ -265,15 +294,31 @@ export function captureResponsesRequestContext(args) {
 }
 export function recordResponsesResponse(args) {
     try {
-        responsesConversationStore.recordResponse(args);
+        if (RESPONSES_DEBUG) {
+            console.log('[responses-store] record', args.requestId, args.response?.id);
+        }
+        store.recordResponse(args);
     }
     catch {
         /* ignore */
     }
 }
 export function resumeResponsesConversation(responseId, submitPayload, options) {
-    return responsesConversationStore.resumeConversation(responseId, submitPayload, options);
+    if (RESPONSES_DEBUG) {
+        console.log('[responses-store] resume', responseId);
+    }
+    return store.resumeConversation(responseId, submitPayload, options);
 }
 export function clearResponsesConversationByRequestId(requestId) {
-    responsesConversationStore.clearRequest(requestId);
+    if (RESPONSES_DEBUG && requestId) {
+        console.log('[responses-store] clear', requestId);
+    }
+    store.clearRequest(requestId);
+}
+export function rebindResponsesConversationRequestId(oldId, newId) {
+    if (RESPONSES_DEBUG && oldId && newId) {
+        console.log('[responses-store] rebind', oldId, '->', newId);
+    }
+    store.rebindRequestId(oldId, newId);
 }
+export { store as responsesConversationStore };

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

@@ -112,29 +112,50 @@ export function buildResponsesOutputFromChat(options) {
     };
 }
 function normalizeUsage(usageRaw) {
-    if (usageRaw && typeof usageRaw === 'object') {
-        const usage = { ...usageRaw };
-        if (usage.input_tokens != null && usage.prompt_tokens == null) {
-            usage.prompt_tokens = usage.input_tokens;
-        }
-        if (usage.output_tokens != null && usage.completion_tokens == null) {
-            usage.completion_tokens = usage.output_tokens;
-        }
-        if (usage.prompt_tokens != null && usage.completion_tokens != null && usage.total_tokens == null) {
-            const total = Number(usage.prompt_tokens) + Number(usage.completion_tokens);
-            if (!Number.isNaN(total))
-                usage.total_tokens = total;
-        }
-        try {
-            delete usage.input_tokens;
-            delete usage.output_tokens;
-        }
-        catch {
-            /* ignore */
-        }
-        return usage;
+    if (!usageRaw || typeof usageRaw !== 'object') {
+        return undefined;
+    }
+    const source = usageRaw;
+    const usage = {};
+    const inputValue = normalizeNumber(source.input_tokens ?? source.prompt_tokens);
+    if (inputValue !== undefined) {
+        usage.input_tokens = inputValue;
+    }
+    const outputValue = normalizeNumber(source.output_tokens ?? source.completion_tokens);
+    if (outputValue !== undefined) {
+        usage.output_tokens = outputValue;
+    }
+    const totalValue = normalizeNumber(source.total_tokens);
+    if (totalValue !== undefined) {
+        usage.total_tokens = totalValue;
+    }
+    else if (inputValue !== undefined && outputValue !== undefined) {
+        usage.total_tokens = inputValue + outputValue;
+    }
+    const inputDetails = extractTokenDetails(source.input_tokens_details ??
+        source.prompt_tokens_details);
+    if (inputDetails) {
+        usage.input_tokens_details = inputDetails;
+    }
+    const outputDetails = extractTokenDetails(source.output_tokens_details ??
+        source.completion_tokens_details);
+    if (outputDetails) {
+        usage.output_tokens_details = outputDetails;
+    }
+    return Object.keys(usage).length ? usage : undefined;
+}
+function normalizeNumber(value) {
+    if (value == null) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function extractTokenDetails(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
     }
-    return usageRaw;
+    return { ...raw };
 }
 function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, baseCount, offset) {
     try {

package/dist/conversion/shared/responses-response-utils.js

@@ -167,7 +167,7 @@ export function buildChatResponseFromResponses(payload) {
     const created = typeof response.created_at === 'number'
         ? response.created_at
         : (response.created ?? Math.floor(Date.now() / 1000));
-    const usage = response.usage;
+    const usage = mapResponsesUsageToChat(response.usage);
     const toolCalls = collectToolCallsFromResponses(response);
     const { textParts, reasoningParts } = extractOutputSegments(response);
     const rawReasoningSegments = collectRawReasoningSegments(response);
@@ -237,3 +237,49 @@ export function buildChatResponseFromResponses(payload) {
     }
     return chat;
 }
+function mapResponsesUsageToChat(usageRaw) {
+    if (!usageRaw || typeof usageRaw !== 'object') {
+        return undefined;
+    }
+    const source = usageRaw;
+    const usage = {};
+    const promptValue = toNumber(source.prompt_tokens ?? source.input_tokens);
+    if (promptValue !== undefined) {
+        usage.prompt_tokens = promptValue;
+    }
+    const completionValue = toNumber(source.completion_tokens ?? source.output_tokens);
+    if (completionValue !== undefined) {
+        usage.completion_tokens = completionValue;
+    }
+    const totalValue = toNumber(source.total_tokens);
+    if (totalValue !== undefined) {
+        usage.total_tokens = totalValue;
+    }
+    else if (promptValue !== undefined && completionValue !== undefined) {
+        usage.total_tokens = promptValue + completionValue;
+    }
+    const promptDetails = extractDetailObject(source.prompt_tokens_details ??
+        source.input_tokens_details);
+    if (promptDetails) {
+        usage.prompt_tokens_details = promptDetails;
+    }
+    const completionDetails = extractDetailObject(source.completion_tokens_details ??
+        source.output_tokens_details);
+    if (completionDetails) {
+        usage.completion_tokens_details = completionDetails;
+    }
+    return Object.keys(usage).length ? usage : undefined;
+}
+function toNumber(value) {
+    if (value == null) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function extractDetailObject(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    return { ...raw };
+}

package/dist/conversion/shared/text-markup-normalizer.js

@@ -95,10 +95,10 @@ export function extractApplyPatchCallsFromText(text) {
                     continue;
                 let argsStr = '{}';
                 try {
-                    argsStr = JSON.stringify({ patch });
+                    argsStr = JSON.stringify({ input: patch });
                 }
                 catch {
-                    argsStr = '{"patch":""}';
+                    argsStr = '{"input":""}';
                 }
                 out.push({ id: genId(), name: 'apply_patch', args: argsStr });
             }

package/dist/conversion/shared/tool-canonicalizer.js

@@ -12,31 +12,133 @@ function repairArgumentsToString(args) {
         return String(args);
     }
 }
+function extractStringContent(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const parts = [];
+        for (const entry of value) {
+            if (typeof entry === 'string') {
+                parts.push(entry);
+            }
+            else if (entry && typeof entry === 'object') {
+                const text = entry.text;
+                if (typeof text === 'string') {
+                    parts.push(text);
+                }
+            }
+        }
+        if (parts.length) {
+            return parts.join('\n');
+        }
+    }
+    return null;
+}
+function readApplyPatchArgument(args) {
+    if (!args || typeof args !== 'object')
+        return undefined;
+    const input = args.input;
+    if (typeof input === 'string' && input.trim().length > 0) {
+        return input;
+    }
+    const legacy = args.patch;
+    if (typeof legacy === 'string' && legacy.trim().length > 0) {
+        return legacy;
+    }
+    return undefined;
+}
+function hasApplyPatchInput(argText) {
+    if (!argText) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(argText);
+        const content = readApplyPatchArgument(parsed);
+        return typeof content === 'string' && content.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function extractUnifiedDiff(content) {
+    if (!content)
+        return undefined;
+    const begin = content.indexOf('*** Begin Patch');
+    const end = content.indexOf('*** End Patch');
+    if (begin >= 0 && end > begin) {
+        return content.slice(begin, end + '*** End Patch'.length).trim();
+    }
+    return undefined;
+}
+function createToolCallId() {
+    return `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
 export function canonicalizeChatResponseTools(payload) {
     try {
         const out = isObject(payload) ? JSON.parse(JSON.stringify(payload)) : payload;
         const choices = Array.isArray(out?.choices) ? out.choices : [];
         for (const ch of choices) {
             const msg = ch && ch.message ? ch.message : undefined;
-            const tcs = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
-            if (!tcs || !tcs.length)
+            const toolCalls = Array.isArray(msg?.tool_calls) ? msg.tool_calls : undefined;
+            const hasToolCalls = Array.isArray(toolCalls) && toolCalls.length > 0;
+            const originalContentText = extractStringContent(msg?.content);
+            const harvestedPatch = typeof originalContentText === 'string' ? extractUnifiedDiff(originalContentText) : undefined;
+            if (hasToolCalls) {
+                // ensure arguments is string and content is null when tool_calls present
+                try {
+                    if (!ch.finish_reason)
+                        ch.finish_reason = 'tool_calls';
+                }
+                catch { /* ignore */ }
+                try {
+                    if (msg && typeof msg === 'object')
+                        msg.content = null;
+                }
+                catch { /* ignore */ }
+                for (const tc of toolCalls) {
+                    try {
+                        const fn = tc && tc.function ? tc.function : undefined;
+                        if (fn) {
+                            const repaired = repairArgumentsToString(fn.arguments);
+                            let nextArgs = repaired;
+                            try {
+                                const parsed = JSON.parse(repaired);
+                                const diffText = readApplyPatchArgument(parsed);
+                                if (typeof diffText === 'string' && diffText.trim().length > 0) {
+                                    nextArgs = JSON.stringify({ input: diffText });
+                                }
+                            }
+                            catch {
+                                // fallback to repaired string
+                            }
+                            fn.arguments = nextArgs;
+                            if (typeof fn.name === 'string' &&
+                                fn.name === 'apply_patch' &&
+                                !hasApplyPatchInput(fn.arguments) &&
+                                harvestedPatch) {
+                                fn.arguments = JSON.stringify({ input: harvestedPatch });
+                            }
+                        }
+                    }
+                    catch { /* ignore */ }
+                }
                 continue;
-            // ensure arguments is string and content is null when tool_calls present
-            try {
-                if (!ch.finish_reason)
-                    ch.finish_reason = 'tool_calls';
             }
-            catch { /* ignore */ }
-            try {
-                if (msg && typeof msg === 'object')
-                    msg.content = null;
-            }
-            catch { /* ignore */ }
-            for (const tc of tcs) {
+            if (harvestedPatch) {
+                const id = createToolCallId();
+                const toolCall = {
+                    id,
+                    type: 'function',
+                    function: {
+                        name: 'apply_patch',
+                        arguments: JSON.stringify({ input: harvestedPatch })
+                    }
+                };
                 try {
-                    const fn = tc && tc.function ? tc.function : undefined;
-                    if (fn)
-                        fn.arguments = repairArgumentsToString(fn.arguments);
+                    msg.tool_calls = [toolCall];
+                    msg.content = null;
+                    ch.finish_reason = 'tool_calls';
                 }
                 catch { /* ignore */ }
             }

package/dist/conversion/shared/tool-mapping.js

@@ -15,6 +15,28 @@ const DEFAULT_SANITIZER = (value) => {
     }
     return undefined;
 };
+const APPLY_PATCH_TOOL_NAME = 'apply_patch';
+const APPLY_PATCH_ARG_KEY = 'input';
+function isApplyPatchTool(name) {
+    return typeof name === 'string' && name.trim() === APPLY_PATCH_TOOL_NAME;
+}
+function buildApplyPatchParameters() {
+    return {
+        type: 'object',
+        properties: {
+            [APPLY_PATCH_ARG_KEY]: {
+                type: 'string',
+                description: 'Unified diff patch content (*** Begin Patch ... *** End Patch)'
+            }
+        },
+        required: [APPLY_PATCH_ARG_KEY],
+        additionalProperties: false
+    };
+}
+function applyPatchSchemaToFunction(fnNode) {
+    fnNode.parameters = buildApplyPatchParameters();
+    fnNode.strict = true;
+}
 function resolveToolName(candidate, options) {
     const sanitized = options?.sanitizeName?.(candidate);
     if (typeof sanitized === 'string' && sanitized.trim().length) {
@@ -80,6 +102,9 @@ export function bridgeToolToChatDefinition(rawTool, options) {
     if (strict !== undefined) {
         fnOut.strict = strict;
     }
+    if (isApplyPatchTool(name)) {
+        applyPatchSchemaToFunction(fnOut);
+    }
     return {
         type: normalizedType,
         function: fnOut
@@ -131,6 +156,11 @@ export function chatToolToBridgeDefinition(rawTool, options) {
     if (strict !== undefined) {
         fnOut.strict = strict;
     }
+    if (isApplyPatchTool(name)) {
+        applyPatchSchemaToFunction(fnOut);
+        responseShape.parameters = buildApplyPatchParameters();
+        responseShape.strict = true;
+    }
     responseShape.function = fnOut;
     return responseShape;
 }

package/dist/sse/sse-to-json/builders/response-builder.d.ts

@@ -77,6 +77,8 @@ export declare class ResponsesResponseBuilder {
      * 处理function_call.start事件
      */
     private handleFunctionCallStart;
+    private coerceArgumentsChunk;
+    private shouldOverrideArguments;
     /**
      * 处理function_call.delta事件
      */

package/dist/sse/sse-to-json/builders/response-builder.js

@@ -395,6 +395,36 @@ export class ResponsesResponseBuilder {
         outputItemState.arguments = '';
         outputItemState.lastEventTime = event.timestamp;
     }
+    coerceArgumentsChunk(raw) {
+        if (typeof raw === 'string') {
+            return raw;
+        }
+        if (raw && typeof raw === 'object') {
+            try {
+                return JSON.stringify(raw);
+            }
+            catch {
+                return String(raw);
+            }
+        }
+        return undefined;
+    }
+    shouldOverrideArguments(current, incoming) {
+        if (!incoming) {
+            return false;
+        }
+        const trimmed = incoming.trim();
+        if (!current || !current.length) {
+            return trimmed.length > 0;
+        }
+        if (!trimmed.length) {
+            return false;
+        }
+        if (trimmed === '{}' || trimmed.toLowerCase() === 'null') {
+            return false;
+        }
+        return true;
+    }
     /**
      * 处理function_call.delta事件
      */
@@ -404,10 +434,10 @@ export class ResponsesResponseBuilder {
         if (!outputItemState) {
             throw new Error(`Output item not found: ${data.item_id}`);
         }
-        const chunk = (data && data.delta && typeof data.delta === 'object' && typeof data.delta.arguments === 'string')
-            ? String(data.delta.arguments)
-            : (typeof (data?.delta) === 'string' ? String(data.delta) : (typeof data?.arguments === 'string' ? String(data.arguments) : undefined));
-        if (typeof chunk === 'string') {
+        const chunk = this.coerceArgumentsChunk(data?.delta?.arguments) ??
+            this.coerceArgumentsChunk(data?.delta) ??
+            this.coerceArgumentsChunk(data?.arguments);
+        if (chunk) {
             outputItemState.arguments = (outputItemState.arguments || '') + chunk;
         }
         outputItemState.lastEventTime = event.timestamp;
@@ -445,8 +475,16 @@ export class ResponsesResponseBuilder {
                 outputItemState.name = data.name;
             if (typeof data.call_id === 'string' && data.call_id)
                 outputItemState.callId = data.call_id;
-            if (typeof data.arguments === 'string' && data.arguments)
-                outputItemState.arguments = data.arguments;
+            const finalChunk = this.coerceArgumentsChunk(data?.arguments) ??
+                this.coerceArgumentsChunk(data?.delta?.arguments) ??
+                this.coerceArgumentsChunk(data?.delta);
+            if (this.shouldOverrideArguments(outputItemState.arguments, finalChunk)) {
+                outputItemState.arguments = finalChunk;
+            }
+            else if (!outputItemState.arguments && finalChunk) {
+                // 没有任何累计增量时，保底写入 done 事件里的值
+                outputItemState.arguments = finalChunk;
+            }
         }
         catch { /* ignore */ }
         outputItemState.status = 'completed';
@@ -630,14 +668,17 @@ export class ResponsesResponseBuilder {
         this.state = 'error';
     }
     handleResponseCompleted(event) {
-        const data = event.data;
-        if (data?.usage) {
-            this.response.usage = data.usage;
+        const payload = event.data?.response ?? event.data;
+        const usage = (payload && payload.usage)
+            ? payload.usage
+            : event.data?.usage;
+        if (usage) {
+            this.response.usage = usage;
         }
         // 标准化完成态：部分上游的 response.completed 不包含 status 字段
         // 若未提供明确的完成状态，统一标记为 'completed'，而不是沿用之前的 in_progress。
-        this.response.status = (data && data.status != null)
-            ? data.status
+        this.response.status = (payload && payload.status != null)
+            ? payload.status
             : 'completed';
         // 将已聚合的输出写回并标记完成（若为空数组也重建）
         try {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.002",
+  "version": "0.6.006",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "build:dev": "tsc -p tsconfig.json",
+    "build": "node scripts/bump-version.mjs && tsc -p tsconfig.json",
+    "build:dev": "node scripts/bump-version.mjs && tsc -p tsconfig.json",
     "lint": "eslint --no-eslintrc -c .eslintrc.json src --ext .ts --no-cache",
     "lint:fix": "eslint --no-eslintrc -c .eslintrc.json src --ext .ts --no-cache --fix",
     "postbuild": "node scripts/tests/run-matrix-ci.mjs",