@jsonstudio/llms 0.6.1643 → 0.6.1739

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

@@ -1,3 +1,5 @@
+import { createHash } from 'node:crypto';
+const MAX_RESPONSES_ITEM_ID_LENGTH = 64;
 function sanitizeCore(value) {
     return value
         .replace(/[^A-Za-z0-9_-]/g, '_')
@@ -5,7 +7,26 @@ function sanitizeCore(value) {
         .replace(/^_+/, '')
         .replace(/_+$/, '');
 }
-function stripPrefix(value) {
+function shortHash(value) {
+    try {
+        return createHash('sha1').update(value).digest('hex').slice(0, 10);
+    }
+    catch {
+        return Math.random().toString(36).slice(2, 12);
+    }
+}
+function clampPrefixedId(prefix, core, hashSource) {
+    const sanitized = sanitizeCore(core) || Math.random().toString(36).slice(2, 10);
+    const direct = `${prefix}${sanitized}`;
+    if (direct.length <= MAX_RESPONSES_ITEM_ID_LENGTH) {
+        return direct;
+    }
+    const hash = shortHash(`${prefix}|${hashSource}|${sanitized}`);
+    const room = Math.max(1, MAX_RESPONSES_ITEM_ID_LENGTH - prefix.length - 1 - hash.length);
+    const head = sanitizeCore(sanitized.slice(0, room)) || 'id';
+    return `${prefix}${head}_${hash}`;
+}
+function extractCore(value) {
     if (typeof value !== 'string')
         return null;
     const trimmed = value.trim();
@@ -20,23 +41,39 @@ function stripPrefix(value) {
     else if (/^call[_-]/i.test(sanitized)) {
         sanitized = sanitized.replace(/^call[_-]?/i, '');
     }
-    if (!sanitized) {
-        sanitized = Math.random().toString(36).slice(2, 10);
-    }
-    return `fc_${sanitized}`;
+    return sanitizeCore(sanitized) || null;
 }
-function normalizeWithFallback(options) {
-    const normalized = stripPrefix(options.callId);
-    if (normalized)
-        return normalized;
-    const fallbackNormalized = stripPrefix(options.fallback);
-    if (fallbackNormalized)
-        return fallbackNormalized;
-    return `fc_${Math.random().toString(36).slice(2, 10)}`;
+function normalizeWithFallback(options, prefix) {
+    const callCore = extractCore(options.callId);
+    if (callCore) {
+        return clampPrefixedId(prefix, callCore, String(options.callId));
+    }
+    const fallbackCore = extractCore(options.fallback);
+    if (fallbackCore) {
+        return clampPrefixedId(prefix, fallbackCore, String(options.fallback));
+    }
+    const randomCore = Math.random().toString(36).slice(2, 10);
+    return clampPrefixedId(prefix, randomCore, randomCore);
 }
 export function normalizeFunctionCallId(options) {
-    return normalizeWithFallback(options);
+    return normalizeWithFallback(options, 'fc_');
 }
 export function normalizeFunctionCallOutputId(options) {
-    return normalizeWithFallback(options);
+    return normalizeWithFallback(options, 'fc_');
+}
+export function normalizeResponsesCallId(options) {
+    return normalizeWithFallback(options, 'call_');
+}
+export function clampResponsesInputItemId(raw) {
+    const trimmed = typeof raw === 'string' ? raw.trim() : '';
+    if (!trimmed) {
+        return undefined;
+    }
+    if (trimmed.length <= MAX_RESPONSES_ITEM_ID_LENGTH) {
+        return trimmed;
+    }
+    const hash = shortHash(trimmed);
+    const room = Math.max(1, MAX_RESPONSES_ITEM_ID_LENGTH - 1 - hash.length);
+    const head = trimmed.slice(0, room);
+    return `${head}_${hash}`;
 }

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

@@ -1,4 +1,5 @@
 import { ProviderProtocolError } from './errors.js';
+import { normalizeFunctionCallOutputId } from './bridge-id-utils.js';
 const TTL_MS = 1000 * 60 * 30; // 30min
 function cloneDeep(value) {
     try {
@@ -111,7 +112,7 @@ function convertOutputToInputItems(response) {
     }
     return items;
 }
-function normalizeSubmittedToolOutputs(toolOutputs) {
+function normalizeSubmittedToolOutputs(toolOutputs, callIdToFunctionItemId) {
     const items = [];
     const submitted = [];
     toolOutputs.forEach((entry, index) => {
@@ -126,7 +127,17 @@ function normalizeSubmittedToolOutputs(toolOutputs) {
                     ? rec.id
                     : undefined;
         const trimmed = typeof rawId === 'string' ? rawId.trim() : '';
-        const callId = trimmed.length ? trimmed : `fc_resume_${index}`;
+        const callId = trimmed.length ? trimmed : `call_resume_${index}`;
+        const mappedItemId = callIdToFunctionItemId && typeof callId === 'string' && callIdToFunctionItemId.has(callId)
+            ? callIdToFunctionItemId.get(callId)
+            : undefined;
+        const mappedIdTrimmed = typeof mappedItemId === 'string' ? mappedItemId.trim() : '';
+        const outputId = mappedIdTrimmed.length
+            ? normalizeFunctionCallOutputId({ callId: mappedIdTrimmed, fallback: mappedIdTrimmed })
+            : normalizeFunctionCallOutputId({
+                callId,
+                fallback: trimmed.length ? trimmed : `fc_resume_${index}`
+            });
         const outputValue = rec.output ?? null;
         const normalizedOutput = typeof outputValue === 'string'
             ? outputValue
@@ -140,7 +151,7 @@ function normalizeSubmittedToolOutputs(toolOutputs) {
             })();
         items.push({
             type: 'function_call_output',
-            id: callId,
+            id: outputId,
             call_id: callId,
             output: normalizedOutput
         });
@@ -244,11 +255,35 @@ class ResponsesConversationStore {
             });
         }
         const mergedInput = coerceInputArray(entry.input);
-        const normalizedOutputs = normalizeSubmittedToolOutputs(toolOutputs);
+        const callIdToFunctionItemId = new Map();
+        for (const item of mergedInput) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const type = typeof item.type === 'string' ? String(item.type) : '';
+            if (type !== 'function_call')
+                continue;
+            const id = typeof item.id === 'string' ? String(item.id).trim() : '';
+            const callId = typeof item.call_id === 'string' ? String(item.call_id).trim() : '';
+            if (id) {
+                callIdToFunctionItemId.set(id, id);
+            }
+            if (callId) {
+                callIdToFunctionItemId.set(callId, id || callId);
+            }
+        }
+        const normalizedOutputs = normalizeSubmittedToolOutputs(toolOutputs, callIdToFunctionItemId);
         mergedInput.push(...normalizedOutputs.items);
         const payload = cloneDeep(entry.basePayload);
         payload.input = mergedInput;
-        payload.stream = true;
+        // Preserve the caller's streaming intent for the resume request.
+        // Do not force-enable streaming here: some upstreams return JSON even when we send `Accept: text/event-stream`,
+        // and forcing `stream=true` can trip SSE decoders on non-SSE bodies.
+        payload.stream =
+            typeof submitPayload.stream === 'boolean'
+                ? Boolean(submitPayload.stream)
+                : typeof entry.basePayload.stream === 'boolean'
+                    ? Boolean(entry.basePayload.stream)
+                    : false;
         payload.previous_response_id = responseId;
         if (Array.isArray(entry.tools) && entry.tools.length) {
             payload.tools = cloneDeep(entry.tools);

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

@@ -1,4 +1,4 @@
-import { normalizeFunctionCallId } from './bridge-id-utils.js';
+import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from './bridge-id-utils.js';
 import { normalizeContentPart } from './output-content-normalizer.js';
 import { expandResponsesMessageItem } from '../../sse/shared/responses-output-normalizer.js';
 function buildToolOutputIndex(response) {
@@ -134,10 +134,18 @@ export function buildResponsesOutputFromChat(options) {
     const pendingToolCalls = normalizedToolCalls.filter((entry) => !executedIds.has(entry.id));
     const hasNormalizedToolCalls = pendingToolCalls.length > 0;
     if (hasNormalizedToolCalls) {
+        const pendingIds = new Set(pendingToolCalls.map((entry) => entry.id));
         for (const item of outputItems) {
-            if (item.type === 'message') {
+            const type = item.type;
+            if (type === 'message') {
                 item.status = 'in_progress';
             }
+            if (type === 'function_call') {
+                const callId = item.call_id;
+                if (typeof callId === 'string' && pendingIds.has(callId)) {
+                    item.status = 'in_progress';
+                }
+            }
         }
     }
     const requiredAction = hasNormalizedToolCalls
@@ -221,14 +229,22 @@ function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, b
         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);
-        const callId = normalizeFunctionCallId({
-            callId: originalCallId,
-            fallback: `fc_call_${baseCount + offset}`
+        // Preserve original tool call IDs when present (OpenAI Responses contract expects stable call_id
+        // across tool_call → submit_tool_outputs). Only generate/normalize when missing.
+        const callId = typeof originalCallId === 'string' && originalCallId.trim().length
+            ? originalCallId.trim()
+            : normalizeFunctionCallId({
+                callId: originalCallId,
+                fallback: `fc_call_${baseCount + offset}`
+            });
+        const outputId = normalizeFunctionCallOutputId({
+            callId,
+            fallback: allocateOutputId('fc')
         });
         const output = {
-            id: allocateOutputId('function_call'),
+            id: outputId,
             type: 'function_call',
-            status: 'in_progress',
+            status: 'completed',
             name: sanitized,
             call_id: callId,
             arguments: argsStr

package/dist/conversion/shared/responses-tool-utils.d.ts

@@ -2,6 +2,7 @@ export type ToolCallIdStyle = 'preserve' | 'fc';
 type BridgeInputItem = Record<string, unknown>;
 export interface CallIdTransformer {
     normalizeCallId(raw: unknown): string;
+    normalizeItemId(raw: unknown, callId: string): string;
     normalizeOutputId(callId: string, raw: unknown): string;
 }
 export declare function createToolCallIdTransformer(style: ToolCallIdStyle): CallIdTransformer | null;

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

@@ -1,25 +1,33 @@
-import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from './bridge-id-utils.js';
+import { normalizeFunctionCallId, normalizeFunctionCallOutputId, normalizeResponsesCallId } from './bridge-id-utils.js';
 export function createToolCallIdTransformer(style) {
     if (style !== 'fc') {
         return null;
     }
     let callCounter = 0;
+    let itemCounter = 0;
     let outputCounter = 0;
-    const alias = new Map();
+    const callAlias = new Map();
     const normalizeCallId = (raw) => {
         const rawStr = typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined;
-        if (rawStr && alias.has(rawStr)) {
-            return alias.get(rawStr);
+        if (rawStr && callAlias.has(rawStr)) {
+            return callAlias.get(rawStr);
         }
-        const normalized = normalizeFunctionCallId({
+        const normalized = normalizeResponsesCallId({
             callId: rawStr,
-            fallback: `fc_call_${++callCounter}`
+            fallback: `call_${++callCounter}`
         });
         if (rawStr) {
-            alias.set(rawStr, normalized);
+            callAlias.set(rawStr, normalized);
         }
         return normalized;
     };
+    const normalizeItemId = (raw, callId) => {
+        const rawStr = typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined;
+        return normalizeFunctionCallId({
+            callId: rawStr ?? callId,
+            fallback: `fc_item_${++itemCounter}`
+        });
+    };
     const normalizeOutputId = (callId, raw) => {
         const rawStr = typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined;
         return normalizeFunctionCallOutputId({
@@ -29,6 +37,7 @@ export function createToolCallIdTransformer(style) {
     };
     return {
         normalizeCallId,
+        normalizeItemId,
         normalizeOutputId
     };
 }
@@ -38,19 +47,27 @@ export function enforceToolCallIdStyle(input, transformer) {
             continue;
         const type = typeof entry.type === 'string' ? entry.type.toLowerCase() : '';
         if (type === 'function_call') {
-            const normalized = transformer.normalizeCallId(entry.call_id ?? entry.id);
-            entry.call_id = normalized;
-            entry.id = normalized;
+            const normalizedCallId = transformer.normalizeCallId(entry.call_id ?? entry.id);
+            entry.call_id = normalizedCallId;
+            entry.id = transformer.normalizeItemId(entry.id ?? normalizedCallId, normalizedCallId);
             continue;
         }
         if (type === 'function_call_output' || type === 'tool_result' || type === 'tool_message') {
-            const normalized = transformer.normalizeCallId(entry.call_id ?? entry.id);
-            entry.call_id = normalized;
-            entry.id = transformer.normalizeOutputId(normalized, entry.id);
+            const normalizedCallId = transformer.normalizeCallId(entry.call_id ?? entry.tool_call_id ?? entry.id);
+            entry.call_id = normalizedCallId;
+            // OpenAI `/v1/responses` request schema uses `call_id` for tool outputs.
+            // Some internal carriers may include `tool_call_id`; strip it before sending upstream
+            // to avoid strict schema errors (e.g. "Unknown parameter: input[N].tool_call_id").
+            if (entry.tool_call_id !== undefined) {
+                delete entry.tool_call_id;
+            }
+            entry.id = transformer.normalizeOutputId(normalizedCallId, entry.id);
         }
     }
 }
 export function resolveToolCallIdStyle(metadata) {
+    // Standard OpenAI `/v1/responses` requires function_call item ids to start with `fc_`.
+    // Default to `fc` unless explicitly overridden (e.g. LM Studio compat).
     if (!metadata)
         return 'fc';
     const raw = metadata.toolCallIdStyle;

package/dist/conversion/shared/text-markup-normalizer.d.ts

@@ -21,4 +21,5 @@ export declare function extractXMLToolCallsFromText(text: string): ToolCallLite[
  * 仅针对已知工具名（目前为 list_directory），避免误伤普通 XML 文本。
  */
 export declare function extractSimpleXmlToolsFromText(text: string): ToolCallLite[] | null;
+export declare function extractQwenToolCallTokensFromText(text: string): ToolCallLite[] | null;
 export declare function normalizeAssistantTextToToolCalls(message: Record<string, any>): Record<string, any>;

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

@@ -117,6 +117,151 @@ function enabled() {
         return true;
     }
 }
+function escapeControlCharsInsideJsonStrings(raw) {
+    try {
+        if (typeof raw !== 'string' || !raw)
+            return null;
+        let out = '';
+        let changed = false;
+        let inString = false;
+        let escaped = false;
+        for (let i = 0; i < raw.length; i++) {
+            const ch = raw[i];
+            if (inString) {
+                if (!escaped && ch === '"') {
+                    inString = false;
+                    out += ch;
+                    continue;
+                }
+                if (!escaped && ch === '\\') {
+                    escaped = true;
+                    out += ch;
+                    continue;
+                }
+                // JSON disallows unescaped control chars inside strings; models sometimes emit raw newlines/tabs.
+                if (!escaped) {
+                    if (ch === '\n') {
+                        out += '\\n';
+                        changed = true;
+                        continue;
+                    }
+                    if (ch === '\r') {
+                        if (raw[i + 1] === '\n') {
+                            i++;
+                        }
+                        out += '\\n';
+                        changed = true;
+                        continue;
+                    }
+                    if (ch === '\t') {
+                        out += '\\t';
+                        changed = true;
+                        continue;
+                    }
+                    const code = ch.charCodeAt(0);
+                    if (code >= 0 && code < 0x20) {
+                        out += `\\u${code.toString(16).padStart(4, '0')}`;
+                        changed = true;
+                        continue;
+                    }
+                }
+                // fallthrough: normal character inside string
+                out += ch;
+                escaped = false;
+                continue;
+            }
+            if (ch === '"') {
+                inString = true;
+                out += ch;
+                continue;
+            }
+            out += ch;
+        }
+        return changed ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+function tryParseJsonWithModelRepairs(raw) {
+    try {
+        if (typeof raw !== 'string')
+            return null;
+        const text = raw.trim();
+        if (!text)
+            return null;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            const repaired = escapeControlCharsInsideJsonStrings(text);
+            if (!repaired)
+                return null;
+            try {
+                return JSON.parse(repaired);
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+}
+function salvageToolArgsFromRawText(toolName, rawArgs) {
+    try {
+        const lname = String(toolName || '').toLowerCase();
+        const text = String(rawArgs || '');
+        const out = {};
+        const pickString = (re) => {
+            const m = text.match(re);
+            if (!m)
+                return undefined;
+            return String(m[1] ?? '');
+        };
+        const pickNumber = (re) => {
+            const m = text.match(re);
+            if (!m)
+                return undefined;
+            const n = Number.parseInt(String(m[1] ?? ''), 10);
+            return Number.isFinite(n) ? n : undefined;
+        };
+        if (lname === 'exec_command') {
+            const cmd = pickString(/"(?:cmd|command)"\s*:\s*"([\s\S]*?)"\s*(?:,|})/i);
+            const workdir = pickString(/"(?:workdir|cwd)"\s*:\s*"([\s\S]*?)"\s*(?:,|})/i);
+            const timeout = pickNumber(/"(?:timeout_ms|timeout)"\s*:\s*(\d+)\s*(?:,|})/i);
+            if (cmd !== undefined)
+                out.cmd = cmd;
+            if (cmd !== undefined)
+                out.command = cmd;
+            if (workdir !== undefined)
+                out.workdir = workdir;
+            if (timeout !== undefined)
+                out.timeout_ms = timeout;
+            return Object.keys(out).length ? out : null;
+        }
+        if (lname === 'write_stdin') {
+            const sessionId = pickNumber(/"(?:session_id|sessionId)"\s*:\s*(\d+)\s*(?:,|})/i);
+            const chars = pickString(/"(?:chars|text|input|data)"\s*:\s*"([\s\S]*?)"\s*(?:,|})/i);
+            if (sessionId !== undefined)
+                out.session_id = sessionId;
+            if (chars !== undefined)
+                out.chars = chars;
+            return Object.keys(out).length ? out : null;
+        }
+        if (lname === 'apply_patch') {
+            const patch = pickString(/"(?:patch|text|input|instructions)"\s*:\s*"([\s\S]*?)"\s*(?:,|})/i);
+            if (patch !== undefined)
+                out.patch = patch;
+            return Object.keys(out).length ? out : null;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 // 已移除所有 rcc.tool.v1 相关处理：不再识别或剥离 rcc 封装
 // Extract <tool:NAME>...</tool:NAME> blocks used by some tool-mode outputs.
 // Example:
@@ -1054,6 +1199,128 @@ export function extractSimpleXmlToolsFromText(text) {
         return null;
     }
 }
+// Extract Qwen-style tool call tokens that appear in plain text, e.g.:
+//   <|tool_calls_section_begin|>
+//   <|tool_call_begin|> functions.exec_command:66 <|tool_call_argument_begin|> {"cmd":"pwd"} <|tool_call_end|>
+//   <|tool_calls_section_end|>
+// Some upstreams emit this even when OpenAI tool_calls are supported; we harvest it into tool_calls.
+export function extractQwenToolCallTokensFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        // Upstreams (notably Qwen-family models behind OpenAI-compatible shells) may insert
+        // whitespace/newlines inside token markers, e.g. "<|  tool_call_begin|>".
+        // Avoid brittle substring checks; do a cheap regex presence test instead.
+        if (!/<\|\s*tool_call_begin\s*\|>/i.test(text) && !/<\|\s*tool_call_argument_begin\s*\|>/i.test(text)) {
+            return null;
+        }
+        const out = [];
+        // tolerate whitespace/newlines and missing argument_end token
+        const re = /<\|\s*tool_call_begin\s*\|>\s*([A-Za-z0-9_.-]+)(?::(\d+))?\s*(?:<\|\s*tool_call_argument_begin\s*\|>\s*([\s\S]*?)\s*)?<\|\s*tool_call_end\s*\|>/gi;
+        let m;
+        while ((m = re.exec(text)) !== null) {
+            const rawName = String(m[1] || '').trim();
+            const numericId = typeof m[2] === 'string' && m[2].trim().length ? m[2].trim() : undefined;
+            const rawArgs = typeof m[3] === 'string' ? String(m[3]).trim() : '';
+            if (!rawName)
+                continue;
+            let name = rawName;
+            if (name.startsWith('functions.')) {
+                name = name.slice('functions.'.length);
+            }
+            const lname = name.toLowerCase();
+            if (!lname)
+                continue;
+            let parsedArgs = null;
+            if (!rawArgs) {
+                parsedArgs = {};
+            }
+            else {
+                parsedArgs = tryParseJsonWithModelRepairs(rawArgs);
+                if (parsedArgs === null) {
+                    parsedArgs = salvageToolArgsFromRawText(lname, rawArgs) ?? { _raw: rawArgs };
+                }
+            }
+            const argsObj = parsedArgs && typeof parsedArgs === 'object' && !Array.isArray(parsedArgs)
+                ? parsedArgs
+                : { value: parsedArgs };
+            // Alias normalization (models often use "command" instead of "cmd", etc.)
+            if (lname === 'exec_command') {
+                const cmd = typeof argsObj.cmd === 'string' ? String(argsObj.cmd) : '';
+                const command = typeof argsObj.command === 'string' ? String(argsObj.command) : '';
+                if (!cmd && command) {
+                    argsObj.cmd = command;
+                }
+                const cwd = typeof argsObj.cwd === 'string' ? String(argsObj.cwd) : '';
+                const workdir = typeof argsObj.workdir === 'string' ? String(argsObj.workdir) : '';
+                if (!workdir && cwd) {
+                    argsObj.workdir = cwd;
+                }
+            }
+            if (lname === 'write_stdin') {
+                const chars = typeof argsObj.chars === 'string' ? String(argsObj.chars) : '';
+                const textVal = typeof argsObj.text === 'string' ? String(argsObj.text) : '';
+                const input = typeof argsObj.input === 'string' ? String(argsObj.input) : '';
+                if (!chars && (textVal || input)) {
+                    argsObj.chars = textVal || input;
+                }
+                const sid = argsObj.session_id;
+                const sidAlt = argsObj.sessionId;
+                if ((sid === undefined || sid === null || String(sid).trim() === '') && (sidAlt !== undefined && sidAlt !== null)) {
+                    argsObj.session_id = sidAlt;
+                }
+            }
+            if (lname === 'apply_patch') {
+                const patch = typeof argsObj.patch === 'string' ? String(argsObj.patch) : '';
+                const textPatch = typeof argsObj.text === 'string' ? String(argsObj.text) : '';
+                const inputPatch = typeof argsObj.input === 'string' ? String(argsObj.input) : '';
+                const instructions = typeof argsObj.instructions === 'string' ? String(argsObj.instructions) : '';
+                if (!patch && (textPatch || inputPatch || instructions)) {
+                    argsObj.patch = textPatch || inputPatch || instructions;
+                }
+            }
+            const filtered = filterArgsForTool(lname, argsObj);
+            // Basic guards for known tools
+            if (lname === 'exec_command') {
+                const cmd = typeof filtered?.cmd === 'string' ? String(filtered.cmd).trim() : '';
+                if (!cmd)
+                    continue;
+            }
+            if (lname === 'write_stdin') {
+                // Allow empty args: our servertool schema may inject session_id automatically when a session is active.
+                // Some models emit polling writes as `{}`.
+            }
+            if (lname === 'apply_patch') {
+                const patchText = typeof filtered?.patch === 'string' ? String(filtered.patch).trim() : '';
+                if (!patchText)
+                    continue;
+            }
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify(filtered);
+            }
+            catch {
+                argsStr = '{}';
+            }
+            const stableId = (() => {
+                if (numericId && /^[0-9]{1,10}$/.test(numericId)) {
+                    const namePart = lname.replace(/[^A-Za-z0-9_-]/g, '_');
+                    const id = `call_${namePart}_${numericId}`
+                        .replace(/_{2,}/g, '_')
+                        .replace(/^_+/, '')
+                        .replace(/_+$/, '');
+                    return id || undefined;
+                }
+                return undefined;
+            })();
+            out.push({ id: stableId ?? `call_${Math.random().toString(36).slice(2, 10)}`, name: lname, args: argsStr });
+        }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function normalizeAssistantTextToToolCalls(message) {
     if (!enabled())
         return message;
@@ -1094,7 +1361,8 @@ export function normalizeAssistantTextToToolCalls(message) {
         for (const text of candidates) {
             // Order: xml-like <tool_call> → apply_patch → execute blocks → 简单 XML 工具（list_directory 等） → bare command salvage
             calls =
-                extractToolNamespaceXmlBlocksFromText(text) ||
+                extractQwenToolCallTokensFromText(text) ||
+                    extractToolNamespaceXmlBlocksFromText(text) ||
                     extractParameterXmlToolsFromText(text) ||
                     extractInvokeToolsFromText(text) ||
                     extractXMLToolCallsFromText(text) ||

package/dist/router/virtual-router/bootstrap.js

@@ -515,7 +515,13 @@ function normalizeProvider(providerId, raw) {
     const compatibilityProfile = resolveCompatibilityProfile(providerId, provider);
     const headers = maybeInjectClaudeCodeHeaders(providerId, providerType, compatibilityProfile, normalizeHeaders(provider.headers));
     const responsesNode = asRecord(provider.responses);
-    const responsesConfig = normalizeResponsesConfig(provider, responsesNode);
+    const responsesConfig = normalizeResponsesConfig({
+        providerId,
+        providerType,
+        compatibilityProfile,
+        provider,
+        node: responsesNode
+    });
     const processMode = normalizeProcessMode(provider.process);
     const streaming = resolveProviderStreamingPreference(provider, responsesNode);
     const modelStreaming = normalizeModelStreaming(provider);
@@ -660,16 +666,23 @@ function coerceStreamingPreference(value) {
     }
     return undefined;
 }
-function normalizeResponsesConfig(provider, node) {
-    const source = node ?? asRecord(provider.responses);
-    if (!source) {
-        return undefined;
-    }
+function normalizeResponsesConfig(options) {
+    const source = options.node ?? asRecord(options.provider.responses);
     const rawStyle = typeof source.toolCallIdStyle === 'string' ? source.toolCallIdStyle.trim().toLowerCase() : undefined;
     if (rawStyle === 'fc' || rawStyle === 'preserve') {
         return { toolCallIdStyle: rawStyle };
     }
-    return undefined;
+    const providerType = typeof options.providerType === 'string' ? options.providerType.trim().toLowerCase() : '';
+    if (!providerType.includes('responses')) {
+        return undefined;
+    }
+    const providerId = typeof options.providerId === 'string' ? options.providerId.trim().toLowerCase() : '';
+    const compat = typeof options.compatibilityProfile === 'string' ? options.compatibilityProfile.trim().toLowerCase() : '';
+    // Default tool-call id style:
+    // - Standard OpenAI /v1/responses requires function_call ids to start with "fc_".
+    // - LM Studio (OpenAI-compatible) often emits `call_*` ids and expects them to be preserved.
+    const isLmstudio = providerId === 'lmstudio' || compat === 'chat:lmstudio';
+    return { toolCallIdStyle: isLmstudio ? 'preserve' : 'fc' };
 }
 function resolveProviderStreamingPreference(provider, responsesNode) {
     const configNode = asRecord(provider.config);
@@ -1046,6 +1059,17 @@ function extractProviderAuthEntries(providerId, raw) {
             pushEntry(undefined, buildAuthCandidate(baseTypeSource, fallbackExtras));
         }
     }
+    // Allow explicit apiKey auth with empty value (local no-auth providers like LM Studio).
+    // If the config declares an auth node (even with an empty apiKey), treat it as an intentional no-auth setup.
+    if (!entries.length && baseType === 'apiKey') {
+        const authDeclared = Object.prototype.hasOwnProperty.call(provider, 'auth') ||
+            Object.prototype.hasOwnProperty.call(provider, 'apiKey') ||
+            Object.prototype.hasOwnProperty.call(provider, 'apiKeys') ||
+            Object.prototype.hasOwnProperty.call(provider, 'authType');
+        if (authDeclared) {
+            pushEntry(undefined, buildAuthCandidate(baseTypeSource, { value: '' }));
+        }
+    }
     if (!entries.length) {
         throw new VirtualRouterError(`Provider ${providerId} is missing auth configuration`, VirtualRouterErrorCode.CONFIG_ERROR);
     }