@jsonstudio/llms 0.6.1164 → 0.6.1354

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

@@ -118,6 +118,105 @@ function enabled() {
     }
 }
 // 已移除所有 rcc.tool.v1 相关处理：不再识别或剥离 rcc 封装
+// Extract <tool:NAME>...</tool:NAME> blocks used by some tool-mode outputs.
+// Example:
+//   <tool:exec_command>
+//     <command>cd /repo && npm test</command>
+//     <timeout_ms>120000</timeout_ms>
+//     <requires_approval>false</requires_approval>
+//   </tool:exec_command>
+export function extractToolNamespaceXmlBlocksFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        if (!text.includes('<tool:'))
+            return null;
+        const out = [];
+        const blockRe = /<\s*tool:([A-Za-z0-9_]+)\s*>([\s\S]*?)<\/\s*tool:\s*\1\s*>/gi;
+        let bm;
+        while ((bm = blockRe.exec(text)) !== null) {
+            const rawName = String(bm[1] || '').trim();
+            const lname = rawName.toLowerCase();
+            if (!lname || !KNOWN_TOOLS.has(lname))
+                continue;
+            const inner = String(bm[2] || '');
+            const argsObj = {};
+            const kvRe = /<\s*([A-Za-z_][A-Za-z0-9_]*)\s*>([\s\S]*?)<\/\s*\1\s*>/g;
+            let km;
+            while ((km = kvRe.exec(inner)) !== null) {
+                const rawKey = String(km[1] || '').trim();
+                const key = normalizeKey(rawKey).toLowerCase();
+                if (!key)
+                    continue;
+                if (key === 'requires_approval')
+                    continue;
+                const rawVal = String(km[2] ?? '');
+                const value = tryParsePrimitiveValue(rawVal);
+                if (lname === 'exec_command' && (key === 'command' || key === 'cmd')) {
+                    const cmd = coerceCommandValueToString(value);
+                    if (cmd.trim().length) {
+                        argsObj.cmd = cmd;
+                        argsObj.command = cmd;
+                    }
+                    continue;
+                }
+                if (lname === 'exec_command' && (key === 'cwd' || key === 'workdir')) {
+                    const wd = String(value ?? rawVal).trim();
+                    if (wd)
+                        argsObj.workdir = wd;
+                    continue;
+                }
+                if (lname === 'write_stdin') {
+                    if (key === 'input' || key === 'data' || key === 'chars' || key === 'text') {
+                        argsObj.chars = rawVal;
+                        continue;
+                    }
+                    if (key === 'session_id') {
+                        const n = Number.parseInt(String(value), 10);
+                        argsObj.session_id = Number.isFinite(n) ? n : value;
+                        continue;
+                    }
+                }
+                if (lname === 'apply_patch' && (key === 'patch' || key === 'input' || key === 'text' || key === 'instructions')) {
+                    const patchText = typeof value === 'string' ? value : rawVal;
+                    if (typeof patchText === 'string' && patchText.trim().length) {
+                        argsObj.patch = patchText;
+                    }
+                    continue;
+                }
+                argsObj[key] = value;
+            }
+            const filtered = filterArgsForTool(lname, argsObj);
+            if (lname === 'exec_command') {
+                const cmd = typeof filtered?.cmd === 'string' ? String(filtered.cmd).trim() : '';
+                if (!cmd)
+                    continue;
+            }
+            if (lname === 'write_stdin') {
+                const sid = filtered?.session_id;
+                if (sid === undefined || sid === null || String(sid).trim().length === 0)
+                    continue;
+            }
+            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 = '{}';
+            }
+            out.push({ id: `call_${Math.random().toString(36).slice(2, 10)}`, name: lname, args: argsStr });
+        }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
 function extractStructuredApplyPatchPayloads(text) {
     const payloads = [];
     try {
@@ -160,6 +259,27 @@ function tryParseJsonValue(text) {
         return null;
     }
 }
+function tryParsePrimitiveValue(text) {
+    try {
+        const trimmed = String(text ?? '').trim();
+        if (trimmed.length === 0)
+            return '';
+        const parsed = tryParseJsonValue(trimmed);
+        if (parsed !== null)
+            return parsed;
+        if (trimmed === 'true' || trimmed === 'false')
+            return trimmed === 'true';
+        if (/^-?\d+(?:\.\d+)?$/.test(trimmed)) {
+            const n = Number(trimmed);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return trimmed;
+    }
+    catch {
+        return String(text ?? '');
+    }
+}
 function coerceCommandValueToString(value) {
     try {
         if (value === null || value === undefined)
@@ -197,6 +317,8 @@ function looksLikeBrokenToolMarkup(text) {
         if (!t)
             return false;
         return (t.includes('<exec_command') ||
+            t.includes('<invoke') ||
+            t.includes('<function_calls') ||
             t.includes('<parameter') ||
             t.includes('<tool_call') ||
             t.includes('</tool_call') ||
@@ -329,6 +451,162 @@ export function extractParameterXmlToolsFromText(text) {
         return null;
     }
 }
+function applyInvokeParameterAliases(toolName, argsObj) {
+    try {
+        const lname = String(toolName || '').toLowerCase();
+        if (lname === 'write_stdin') {
+            // Some models emit `data` / `wait` instead of our canonical `chars` / `yield_time_ms`.
+            if (Object.prototype.hasOwnProperty.call(argsObj, 'data')) {
+                const data = argsObj.data;
+                if (!Object.prototype.hasOwnProperty.call(argsObj, 'chars') && !Object.prototype.hasOwnProperty.call(argsObj, 'text')) {
+                    argsObj.chars = data == null ? '' : String(data);
+                }
+                delete argsObj.data;
+            }
+            if (Object.prototype.hasOwnProperty.call(argsObj, 'wait') && !Object.prototype.hasOwnProperty.call(argsObj, 'yield_time_ms')) {
+                const wait = argsObj.wait;
+                let ms;
+                if (typeof wait === 'number' && Number.isFinite(wait)) {
+                    // Heuristic: small values are usually seconds; large values are likely already ms.
+                    ms = wait <= 1000 ? Math.round(wait * 1000) : Math.round(wait);
+                }
+                else if (typeof wait === 'string' && wait.trim().length) {
+                    const num = Number(wait.trim());
+                    if (Number.isFinite(num)) {
+                        ms = num <= 1000 ? Math.round(num * 1000) : Math.round(num);
+                    }
+                }
+                if (typeof ms === 'number' && Number.isFinite(ms) && ms >= 0) {
+                    argsObj.yield_time_ms = ms;
+                }
+                delete argsObj.wait;
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+// Extract <function_calls><invoke name="..."><parameter name="...">...</parameter>...</invoke> blocks.
+// Example seen in Gemini CLI / antigravity compact output:
+//   <function_calls>
+//     <invoke name="write_stdin">
+//       <parameter name="session_id">91806</parameter>
+//       <parameter name="data"></parameter>
+//       <parameter name="wait">10</parameter>
+//     </invoke>
+//   </function_calls>
+export function extractInvokeToolsFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        const out = [];
+        const invokeRe = /<\s*invoke\s+name\s*=\s*"([^">]+)"\s*>([\s\S]*?)<\/\s*invoke\s*>/gi;
+        let im;
+        while ((im = invokeRe.exec(text)) !== null) {
+            const rawName = (im[1] || '').trim();
+            const inner = (im[2] || '').trim();
+            if (!rawName || !inner)
+                continue;
+            const lname = rawName.toLowerCase();
+            const argsObj = {};
+            const paramRe = /<\s*parameter\s+name\s*=\s*"([^">]+)"\s*>([\s\S]*?)<\/\s*parameter\s*>/gi;
+            let pm;
+            while ((pm = paramRe.exec(inner)) !== null) {
+                const rawKey = (pm[1] || '').trim();
+                const key = normalizeKey(rawKey);
+                if (!key)
+                    continue;
+                const rawVal = (pm[2] ?? '').toString();
+                const value = tryParsePrimitiveValue(rawVal);
+                if (lname === 'exec_command' && (key.toLowerCase() === 'command' || key.toLowerCase() === 'cmd')) {
+                    const cmd = coerceCommandValueToString(value);
+                    if (cmd.trim().length) {
+                        argsObj.cmd = cmd;
+                        argsObj.command = cmd;
+                    }
+                    continue;
+                }
+                argsObj[key] = value;
+            }
+            applyInvokeParameterAliases(lname, argsObj);
+            const filtered = filterArgsForTool(lname, argsObj);
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify(filtered);
+            }
+            catch {
+                argsStr = '{}';
+            }
+            out.push({ id: `call_${Math.random().toString(36).slice(2, 10)}`, name: lname, args: argsStr });
+        }
+        // Some Gemini CLI / antigravity variants emit a looser XML shape:
+        // <function_calls>
+        //   <invoke>
+        //     <tool_name>exec_command</tool_name>
+        //     <parameters>
+        //       <command>echo hi</command>
+        //     </parameters>
+        //   </invoke>
+        // </function_calls>
+        //
+        // Best-effort: only accept known tools, and only read simple <parameters><k>v</k></parameters>.
+        if (out.length === 0) {
+            const invokeBareRe = /<\s*invoke\s*>([\s\S]*?)<\/\s*invoke\s*>/gi;
+            let bm;
+            while ((bm = invokeBareRe.exec(text)) !== null) {
+                const inner = (bm[1] || '').trim();
+                if (!inner)
+                    continue;
+                const toolNameMatch = /<\s*(?:tool_name|toolname|tool)\s*>\s*([\s\S]*?)\s*<\/\s*(?:tool_name|toolname|tool)\s*>/i.exec(inner);
+                const rawName = (toolNameMatch?.[1] || '').trim();
+                if (!rawName)
+                    continue;
+                const lname = rawName.toLowerCase();
+                if (!KNOWN_TOOLS.has(lname))
+                    continue;
+                const argsObj = {};
+                const paramsMatch = /<\s*parameters\s*>([\s\S]*?)<\/\s*parameters\s*>/i.exec(inner);
+                if (paramsMatch && paramsMatch[1]) {
+                    const paramsInner = String(paramsMatch[1] || '');
+                    const kvRe = /<\s*([A-Za-z_][A-Za-z0-9_]*)\s*>([\s\S]*?)<\/\s*\1\s*>/g;
+                    let km;
+                    while ((km = kvRe.exec(paramsInner)) !== null) {
+                        const rawKey = (km[1] || '').trim();
+                        const key = normalizeKey(rawKey);
+                        if (!key)
+                            continue;
+                        const rawVal = (km[2] ?? '').toString();
+                        const value = tryParsePrimitiveValue(rawVal);
+                        if (lname === 'exec_command' && (key.toLowerCase() === 'command' || key.toLowerCase() === 'cmd')) {
+                            const cmd = coerceCommandValueToString(value);
+                            if (cmd.trim().length) {
+                                argsObj.cmd = cmd;
+                                argsObj.command = cmd;
+                            }
+                            continue;
+                        }
+                        argsObj[key] = value;
+                    }
+                }
+                applyInvokeParameterAliases(lname, argsObj);
+                const filtered = filterArgsForTool(lname, argsObj);
+                let argsStr = '{}';
+                try {
+                    argsStr = JSON.stringify(filtered);
+                }
+                catch {
+                    argsStr = '{}';
+                }
+                out.push({ id: `call_${Math.random().toString(36).slice(2, 10)}`, name: lname, args: argsStr });
+            }
+        }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
 function tryParseJsonArrayOnLine(line) {
     try {
         const trimmed = String(line || '').trim();
@@ -477,14 +755,14 @@ export function extractXMLToolCallsFromText(text) {
                 continue;
             // 1) try function/name tags
             let name = '';
-            const fnTag = inner.match(/<\s*(?:function|name)\s*>\s*([a-zA-Z0-9_\-\.]+)\s*<\/(?:function|name)\s*>/i);
+            const fnTag = inner.match(/<\s*(?:function|name)\s*>\s*([a-zA-Z0-9_.-]+)\s*<\/(?:function|name)\s*>/i);
             if (fnTag && fnTag[1]) {
                 name = String(fnTag[1]).trim();
             }
             else {
                 // 2) else pick the first non-empty line without tags as the name
                 const lines = inner.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
-                const candidate = lines.find(l => !l.startsWith('<') && /^[a-zA-Z0-9_\-\.]+$/.test(l));
+                const candidate = lines.find(l => !l.startsWith('<') && /^[a-zA-Z0-9_.-]+$/.test(l));
                 if (candidate)
                     name = candidate;
             }
@@ -562,7 +840,7 @@ export function extractXMLToolCallsFromText(text) {
                     const before = text.slice(0, start);
                     const lines = before.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
                     const cand = lines.length ? lines[lines.length - 1] : '';
-                    if (/^[a-zA-Z0-9_\-\.]{2,}$/.test(cand))
+                    if (/^[a-zA-Z0-9_.-]{2,}$/.test(cand))
                         name = cand;
                 }
                 catch { /* ignore */ }
@@ -727,7 +1005,9 @@ 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 =
-                extractParameterXmlToolsFromText(text) ||
+                extractToolNamespaceXmlBlocksFromText(text) ||
+                    extractParameterXmlToolsFromText(text) ||
+                    extractInvokeToolsFromText(text) ||
                     extractXMLToolCallsFromText(text) ||
                     extractApplyPatchCallsFromText(text) ||
                     extractExecuteBlocksFromText(text) ||

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

@@ -14,8 +14,9 @@ export function canonicalizeChatResponseTools(payload) {
                 continue;
             // ensure arguments is string and content is null when tool_calls present
             try {
-                if (!ch.finish_reason)
+                if (String(ch.finish_reason || '').toLowerCase() !== 'tool_calls') {
                     ch.finish_reason = 'tool_calls';
+                }
             }
             catch { /* ignore */ }
             try {

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

@@ -1,5 +1,5 @@
 // Unified tool governance API (标准)
-// Centralizes tool augmentation, guidance injection/refinement, and textual→tool_calls canonicalization
+// Centralizes tool augmentation, guidance injection/refinement, and structured tool_calls canonicalization
 // canonicalizer 按需加载（避免在请求侧仅注入时引入不必要的模块）
 // enforceChatBudget: 为避免在请求侧引入多余依赖，这里提供最小实现（保留形状，不裁剪）。
 import { augmentOpenAITools } from '../../guidance/index.js';
@@ -45,7 +45,7 @@ function tryWriteSnapshot(options, stage, data) {
  * Process OpenAI Chat request (messages/tools) with unified 标准 governance.
  * - Augment tools (strict schemas)
  * - Inject/Refine system tool guidance (idempotent)
- * - Canonicalize textual tool markup to tool_calls; set content=null when applicable
+ * - Canonicalize structured tool_calls; set content=null when applicable
  */
 const IMAGE_EXT_RE = /\.(png|jpe?g|gif|webp|bmp|svg)(?:[?#].*)?$/i;
 function hasImageReference(messages) {
@@ -223,7 +223,7 @@ export function processChatRequestTools(request, opts) {
 }
 /**
  * Process OpenAI Chat response (choices[0].message) with unified 标准 governance.
- * - Canonicalize textual tool markup to tool_calls; ensure finish_reason and content=null policy
+ * - Canonicalize structured tool_calls; ensure finish_reason and content=null policy
  */
 import { repairArgumentsToString, parseLenient } from './jsonish.js';
 export function normalizeApplyPatchToolCallsOnResponse(chat) {

package/dist/filters/engine.js

@@ -13,7 +13,7 @@ export class FilterEngine {
         try {
             await writeFilterSnapshot({ requestId: ctx.requestId, endpoint: ctx.endpoint, profile: ctx.profile, stage, tag: 'begin', data: out });
         }
-        catch { }
+        catch { /* ignore */ }
         // stage pre filters
         for (const f of this.filters) {
             if (f.stage !== stage)
@@ -25,7 +25,7 @@ export class FilterEngine {
             try {
                 await writeFilterSnapshot({ requestId: ctx.requestId, endpoint: ctx.endpoint, profile: ctx.profile, stage, name: f.name, tag: 'after', data: out });
             }
-            catch { }
+            catch { /* ignore */ }
         }
         // field map in map stages
         if (stage === 'request_map' || stage === 'response_map') {
@@ -33,17 +33,17 @@ export class FilterEngine {
             try {
                 await writeFilterSnapshot({ requestId: ctx.requestId, endpoint: ctx.endpoint, profile: ctx.profile, stage, tag: 'map_before', data: out });
             }
-            catch { }
+            catch { /* ignore */ }
             out = this.applyFieldMap(out, rules);
             try {
                 await writeFilterSnapshot({ requestId: ctx.requestId, endpoint: ctx.endpoint, profile: ctx.profile, stage, tag: 'map_after', data: out });
             }
-            catch { }
+            catch { /* ignore */ }
         }
         try {
             await writeFilterSnapshot({ requestId: ctx.requestId, endpoint: ctx.endpoint, profile: ctx.profile, stage, tag: 'end', data: out });
         }
-        catch { }
+        catch { /* ignore */ }
         return out;
     }
     applyFieldMap(input, rules) {