@jsonstudio/llms 0.6.0 → 0.6.6

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-filter-pipeline.js

@@ -35,12 +35,11 @@ export async function runChatRequestToolFilters(chatRequest, options = {}) {
             /* optional */
         }
     }
-    const { RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter, RequestStreamingToNonStreamingFilter } = await import('../../filters/index.js');
+    const { RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter } = await import('../../filters/index.js');
     engine.registerFilter(new RequestToolCallsStringifyFilter());
     if (!isAnthropic) {
         engine.registerFilter(new RequestToolChoicePolicyFilter());
     }
-    engine.registerFilter(new RequestStreamingToNonStreamingFilter());
     try {
         const cfg = await loadFieldMapConfig('openai-openai.fieldmap.json');
         if (cfg)

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/filters/index.d.ts

@@ -0,0 +1,18 @@
+export * from './types.js';
+export * from './engine.js';
+export * from './builtin/whitelist-filter.js';
+export * from './builtin/blacklist-filter.js';
+export * from './builtin/add-fields-filter.js';
+export * from './special/request-toolcalls-stringify.js';
+export * from './special/request-tool-choice-policy.js';
+export * from './special/request-tool-list-filter.js';
+export * from './special/tool-filter-hooks.js';
+export * from './special/response-tool-text-canonicalize.js';
+export * from './special/response-tool-arguments-stringify.js';
+export * from './special/response-finish-invariants.js';
+export * from './special/request-tools-normalize.js';
+export * from './special/response-tool-arguments-toon-decode.js';
+export * from './special/response-tool-arguments-blacklist.js';
+export * from './special/response-tool-arguments-schema-converge.js';
+export * from './special/response-tool-arguments-whitelist.js';
+export * from './special/tool-post-constraints.js';

package/dist/filters/index.js

@@ -9,7 +9,6 @@ export * from './special/request-toolcalls-stringify.js';
 export * from './special/request-tool-choice-policy.js';
 export * from './special/request-tool-list-filter.js';
 export * from './special/tool-filter-hooks.js';
-export * from './special/request-streaming-to-nonstreaming.js';
 export * from './special/response-tool-text-canonicalize.js';
 export * from './special/response-tool-arguments-stringify.js';
 export * from './special/response-finish-invariants.js';

package/dist/filters/special/request-streaming-to-nonstreaming.d.ts

@@ -0,0 +1,13 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * RequestStreamingToNonStreamingFilter (request_post)
+ * - Unifies provider requests to non-streaming regardless of inbound stream flag.
+ * - Preserves original intent via `originalStream` and `_originalStreamOptions`,
+ *   but ensures `stream: false` is sent to providers.
+ */
+export declare class RequestStreamingToNonStreamingFilter implements Filter<JsonObject> {
+    readonly name = "request_streaming_to_nonstreaming";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject, ctx: FilterContext): FilterResult<JsonObject>;
+    private shouldPreserveStream;
+}

package/dist/filters/special/request-streaming-to-nonstreaming.js

@@ -7,9 +7,12 @@
 export class RequestStreamingToNonStreamingFilter {
     name = 'request_streaming_to_nonstreaming';
     stage = 'request_post';
-    apply(input) {
+    apply(input, ctx) {
         try {
             const out = JSON.parse(JSON.stringify(input || {}));
+            if (this.shouldPreserveStream(out, ctx)) {
+                return { ok: true, data: out };
+            }
             if (out.stream === true) {
                 out.originalStream = true;
                 out.stream = false;
@@ -24,4 +27,13 @@ export class RequestStreamingToNonStreamingFilter {
             return { ok: true, data: input };
         }
     }
+    shouldPreserveStream(payload, ctx) {
+        if (ctx.stream === true) {
+            return true;
+        }
+        if (payload.stream === true) {
+            return true;
+        }
+        return false;
+    }
 }

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事件
      */