@jsonstudio/llms 0.6.954 → 0.6.1164

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

@@ -3,6 +3,8 @@ export type ToolCallLite = {
     name: string;
     args: string;
 };
+export declare function extractParameterXmlToolsFromText(text: string): ToolCallLite[] | null;
+export declare function extractBareExecCommandFromText(text: string): ToolCallLite[] | null;
 export declare function extractApplyPatchCallsFromText(text: string): ToolCallLite[] | null;
 export declare function extractExecuteBlocksFromText(text: string): ToolCallLite[] | null;
 export declare function extractXMLToolCallsFromText(text: string): ToolCallLite[] | null;

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

@@ -6,6 +6,8 @@ import { isStructuredApplyPatchPayload } from '../../tools/apply-patch-structure
 // stray markup or free-form text as JSON keys (reduces false positives).
 const KNOWN_TOOLS = new Set([
     'shell',
+    'exec_command',
+    'write_stdin',
     'apply_patch',
     'update_plan',
     'view_image',
@@ -17,7 +19,22 @@ const KNOWN_TOOLS = new Set([
 ]);
 const ALLOWED_KEYS = {
     shell: new Set(['command', 'justification', 'timeout_ms', 'with_escalated_permissions', 'workdir']),
-    apply_patch: new Set(['file', 'instructions', 'changes']),
+    exec_command: new Set([
+        'cmd',
+        'command',
+        'workdir',
+        'justification',
+        'login',
+        'tty',
+        'shell',
+        'yield_time_ms',
+        'max_output_tokens',
+        'sandbox_permissions',
+        'timeout_ms'
+    ]),
+    write_stdin: new Set(['session_id', 'chars', 'text', 'yield_time_ms', 'max_output_tokens']),
+    // apply_patch supports both freeform patch text (patch/input/instructions/text) and structured payloads (file/changes)
+    apply_patch: new Set(['patch', 'input', 'instructions', 'text', 'file', 'changes']),
     update_plan: new Set(['explanation', 'plan']),
     view_image: new Set(['path']),
     list_mcp_resources: new Set(['server', 'cursor', 'filter', 'root']),
@@ -38,13 +55,40 @@ function normalizeKey(raw) {
         return String(raw || '');
     }
 }
+function readDefaultWorkdirFromEnv() {
+    try {
+        const env = String(process?.env?.ROUTECODEX_WORKDIR || '').trim() ||
+            String(process?.env?.RCC_WORKDIR || '').trim() ||
+            String(process?.env?.CLAUDE_WORKDIR || '').trim();
+        return env ? env : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function filterArgsForTool(name, args) {
     try {
         const nm = String(name || '').toLowerCase();
         const allow = ALLOWED_KEYS[nm];
         if (!allow) {
             // Unknown tool; be conservative: keep only simple safe keys if present
-            const safe = new Set(['command', 'patch', 'plan', 'explanation', 'path', 'server', 'uri', 'cursor', 'filter', 'root']);
+            const safe = new Set([
+                'cmd',
+                'command',
+                'workdir',
+                'patch',
+                'input',
+                'instructions',
+                'text',
+                'plan',
+                'explanation',
+                'path',
+                'server',
+                'uri',
+                'cursor',
+                'filter',
+                'root'
+            ]);
             const out = {};
             for (const [k, v] of Object.entries(args || {})) {
                 const key = normalizeKey(k);
@@ -102,6 +146,266 @@ function extractStructuredApplyPatchPayloads(text) {
     catch { /* ignore */ }
     return payloads;
 }
+function tryParseJsonValue(text) {
+    try {
+        const trimmed = String(text || '').trim();
+        if (!trimmed)
+            return null;
+        if (!(trimmed.startsWith('{') || trimmed.startsWith('[') || trimmed.startsWith('"'))) {
+            return null;
+        }
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+}
+function coerceCommandValueToString(value) {
+    try {
+        if (value === null || value === undefined)
+            return '';
+        if (typeof value === 'string')
+            return value.trim();
+        if (Array.isArray(value)) {
+            return value.map((v) => String(v)).join(' ').trim();
+        }
+        if (typeof value === 'object') {
+            const rec = value;
+            const direct = typeof rec.cmd === 'string'
+                ? String(rec.cmd)
+                : typeof rec.command === 'string'
+                    ? String(rec.command)
+                    : '';
+            if (direct.trim().length)
+                return direct.trim();
+            try {
+                return JSON.stringify(value);
+            }
+            catch {
+                return String(value);
+            }
+        }
+        return String(value).trim();
+    }
+    catch {
+        return '';
+    }
+}
+function looksLikeBrokenToolMarkup(text) {
+    try {
+        const t = String(text || '');
+        if (!t)
+            return false;
+        return (t.includes('<exec_command') ||
+            t.includes('<parameter') ||
+            t.includes('<tool_call') ||
+            t.includes('</tool_call') ||
+            t.includes('<arg_value') ||
+            t.includes('</arg_value') ||
+            t.includes('</func_call') ||
+            /\bRan\b\s+\[/.test(t));
+    }
+    catch {
+        return false;
+    }
+}
+function stripTrailingXmlGarbage(line) {
+    try {
+        const idx = line.indexOf('<');
+        if (idx >= 0) {
+            return line.slice(0, idx).trim();
+        }
+        return line.trim();
+    }
+    catch {
+        return String(line || '').trim();
+    }
+}
+function normalizePossibleCommandLine(raw) {
+    try {
+        let line = String(raw || '');
+        line = line.replace(/^\s*(?:[•*+-]\s*)?/, '');
+        line = line.replace(/^\s*\$\s*/, '');
+        return stripTrailingXmlGarbage(line);
+    }
+    catch {
+        return '';
+    }
+}
+function looksLikeShellCommand(line) {
+    try {
+        const t = String(line || '').trim();
+        if (!t)
+            return false;
+        if (t.startsWith('```') || t.startsWith('>'))
+            return false;
+        if (t.startsWith('zsh:') || t.startsWith('bash:'))
+            return false;
+        // Conservative allowlist: commands commonly emitted by Codex/Claude in tool-mode.
+        return /^(?:rg|ls|cat|node|npm|pnpm|yarn|git|find|sed|head|tail|wc|mkdir|rm|cp|mv|pwd)\b/.test(t);
+    }
+    catch {
+        return false;
+    }
+}
+// Extract Anthropic/GLM-style XML tool tags that use <parameter name="...">...</parameter>, e.g.:
+//   <exec_command>
+//     <parameter name="command">["cd","/repo","&&","npm","run","build"]</parameter>
+//     <parameter name="workdir">/repo</parameter>
+//   </exec_command>
+export function extractParameterXmlToolsFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        const out = [];
+        // Some providers/models emit mismatched closing tags like </func_call>; accept a small set of known variants.
+        const toolRe = /<\s*(exec_command)\s*>([\s\S]*?)<\/\s*(?:\1|func_call|tool_call)\s*>/gi;
+        let tm;
+        while ((tm = toolRe.exec(text)) !== null) {
+            const rawName = (tm[1] || '').trim();
+            const inner = (tm[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] || '').trim();
+                if (!rawVal)
+                    continue;
+                const parsed = tryParseJsonValue(rawVal);
+                if (key.toLowerCase() === 'command' || key.toLowerCase() === 'cmd') {
+                    const cmd = coerceCommandValueToString(parsed ?? rawVal);
+                    if (cmd.trim().length) {
+                        argsObj.cmd = cmd;
+                        argsObj.command = cmd;
+                    }
+                    continue;
+                }
+                if (key.toLowerCase() === 'workdir') {
+                    argsObj.workdir = rawVal;
+                    continue;
+                }
+                argsObj[key] = parsed ?? rawVal;
+            }
+            const filtered = filterArgsForTool(lname, argsObj);
+            if (!filtered || typeof filtered !== 'object' || Array.isArray(filtered))
+                continue;
+            const cmd = typeof filtered.cmd === 'string' ? String(filtered.cmd).trim() : '';
+            if (!cmd)
+                continue;
+            // If caller didn't provide workdir, fallback to a conservative env-derived workdir.
+            try {
+                if (!filtered.workdir) {
+                    const envWorkdir = readDefaultWorkdirFromEnv();
+                    if (envWorkdir)
+                        filtered.workdir = envWorkdir;
+                }
+            }
+            catch {
+                /* ignore */
+            }
+            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();
+        if (!trimmed.startsWith('[') || !trimmed.endsWith(']'))
+            return null;
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed))
+            return null;
+        const out = [];
+        for (const entry of parsed) {
+            if (entry == null)
+                continue;
+            out.push(String(entry));
+        }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function extractBareExecCommandFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        // Only attempt this when we see clear evidence of a broken tool markup (avoid turning examples into tool calls).
+        if (!looksLikeBrokenToolMarkup(text))
+            return null;
+        const candidates = [];
+        const lines = text.split(/\r?\n/);
+        for (let i = 0; i < lines.length; i += 1) {
+            const raw = String(lines[i] || '');
+            const line = normalizePossibleCommandLine(raw);
+            if (!line)
+                continue;
+            // Pattern A: "Ran [\"ls\", \"-l\", ...]"
+            const ran = line.match(/\bRan\b\s+(\[[\s\S]*\])\s*$/i);
+            if (ran && ran[1]) {
+                const arr = tryParseJsonArrayOnLine(ran[1]);
+                if (arr) {
+                    candidates.push({ cmd: arr.join(' ').trim() });
+                    continue;
+                }
+            }
+            // Pattern B: a single-line shell command (rg/ls/node/...)
+            if (looksLikeShellCommand(line)) {
+                candidates.push({ cmd: line.trim() });
+                continue;
+            }
+        }
+        if (!candidates.length)
+            return null;
+        const picked = candidates[candidates.length - 1];
+        const argsObj = { cmd: picked.cmd };
+        const envWorkdir = readDefaultWorkdirFromEnv();
+        if (envWorkdir) {
+            argsObj.workdir = envWorkdir;
+        }
+        const filtered = filterArgsForTool('exec_command', argsObj);
+        let argsStr = '{}';
+        try {
+            argsStr = JSON.stringify(filtered);
+        }
+        catch {
+            argsStr = '{}';
+        }
+        return [
+            {
+                id: `call_${Math.random().toString(36).slice(2, 10)}`,
+                name: 'exec_command',
+                args: argsStr
+            }
+        ];
+    }
+    catch {
+        return null;
+    }
+}
 export function extractApplyPatchCallsFromText(text) {
     try {
         if (typeof text !== 'string' || !text)
@@ -392,14 +696,46 @@ export function normalizeAssistantTextToToolCalls(message) {
         if (Array.isArray(message.tool_calls) && message.tool_calls.length)
             return message;
         const content = message.content;
-        const text = typeof content === 'string' ? content : null;
-        if (!text)
+        const candidates = [];
+        if (typeof content === 'string') {
+            candidates.push(content);
+        }
+        else if (Array.isArray(content)) {
+            for (const part of content) {
+                if (!part || typeof part !== 'object')
+                    continue;
+                const p = part;
+                if (typeof p.text === 'string' && p.text.trim()) {
+                    candidates.push(p.text);
+                    continue;
+                }
+                if (typeof p.content === 'string' && p.content.trim()) {
+                    candidates.push(p.content);
+                    continue;
+                }
+            }
+        }
+        if (typeof message.reasoning === 'string' && message.reasoning.trim()) {
+            candidates.push(String(message.reasoning));
+        }
+        if (typeof message.thinking === 'string' && message.thinking.trim()) {
+            candidates.push(String(message.thinking));
+        }
+        if (!candidates.length)
             return message;
-        // Order: xml-like <tool_call> → apply_patch → execute blocks → 简单 XML 工具（list_directory 等）
-        const calls = (extractXMLToolCallsFromText(text) ||
-            extractApplyPatchCallsFromText(text) ||
-            extractExecuteBlocksFromText(text) ||
-            extractSimpleXmlToolsFromText(text));
+        let calls = null;
+        for (const text of candidates) {
+            // Order: xml-like <tool_call> → apply_patch → execute blocks → 简单 XML 工具（list_directory 等） → bare command salvage
+            calls =
+                extractParameterXmlToolsFromText(text) ||
+                    extractXMLToolCallsFromText(text) ||
+                    extractApplyPatchCallsFromText(text) ||
+                    extractExecuteBlocksFromText(text) ||
+                    extractSimpleXmlToolsFromText(text) ||
+                    extractBareExecCommandFromText(text);
+            if (calls && calls.length)
+                break;
+        }
         if (calls && calls.length) {
             const toolCalls = calls.map((c) => ({ id: c.id, type: 'function', function: { name: c.name, arguments: c.args } }));
             const copy = { ...message };

package/dist/conversion/shared/thought-signature-validator.d.ts

@@ -0,0 +1,52 @@
+/**
+ * ThoughtSignature Validator
+ *
+ * 提供严格的 thoughtSignature 验证功能，用于 Claude/Gemini thinking 块的签名验证。
+ * 参考 gcli2api 的实现，确保与上游 API 的兼容性。
+ */
+import type { JsonObject, JsonValue } from '../hub/types/json.js';
+export interface ThoughtSignatureValidationOptions {
+    /**
+     * 最小签名长度（默认 10 个字符）
+     */
+    minLength?: number;
+    /**
+     * 是否允许空 thinking + 任意签名（trailing signature case）
+     * 默认 true
+     */
+    allowEmptyThinkingWithSignature?: boolean;
+    /**
+     * 是否在验证失败时将 thinking 转换为文本
+     * 默认 true
+     */
+    convertToTextOnFailure?: boolean;
+}
+/**
+ * 检查 thinking 块是否有有效的 thoughtSignature
+ *
+ * @param block - thinking 块对象
+ * @param options - 验证选项
+ * @returns 是否有效
+ */
+export declare function hasValidThoughtSignature(block: unknown, options?: ThoughtSignatureValidationOptions): boolean;
+/**
+ * 清理 thinking 块，移除额外字段，保留有效签名
+ *
+ * @param block - thinking 块对象
+ * @returns 清理后的块
+ */
+export declare function sanitizeThinkingBlock(block: unknown): JsonObject;
+/**
+ * 过滤消息中的无效 thinking 块
+ *
+ * @param messages - Anthropic messages 列表（会被修改）
+ * @param options - 验证选项
+ */
+export declare function filterInvalidThinkingBlocks(messages: JsonValue[], options?: ThoughtSignatureValidationOptions): void;
+/**
+ * 移除末尾未签名的 thinking 块
+ *
+ * @param blocks - content blocks 列表（会被修改）
+ * @param options - 验证选项
+ */
+export declare function removeTrailingUnsignedThinkingBlocks(blocks: JsonValue[], options?: ThoughtSignatureValidationOptions): void;

package/dist/conversion/shared/thought-signature-validator.js

@@ -0,0 +1,170 @@
+/**
+ * ThoughtSignature Validator
+ *
+ * 提供严格的 thoughtSignature 验证功能，用于 Claude/Gemini thinking 块的签名验证。
+ * 参考 gcli2api 的实现，确保与上游 API 的兼容性。
+ */
+const DEFAULT_OPTIONS = {
+    minLength: 10,
+    allowEmptyThinkingWithSignature: true,
+    convertToTextOnFailure: true
+};
+/**
+ * 检查 thinking 块是否有有效的 thoughtSignature
+ *
+ * @param block - thinking 块对象
+ * @param options - 验证选项
+ * @returns 是否有效
+ */
+export function hasValidThoughtSignature(block, options) {
+    if (!block || typeof block !== 'object') {
+        return true; // 非 thinking 块默认有效
+    }
+    const obj = block;
+    const blockType = obj.type;
+    if (blockType !== 'thinking' && blockType !== 'reasoning' && blockType !== 'redacted_thinking') {
+        return true; // 非 thinking 块默认有效
+    }
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const thinking = String(obj.thinking || obj.text || '');
+    const signature = coerceThoughtSignature(obj.thoughtSignature || obj.signature);
+    // 空 thinking + 任意签名 = 有效 (trailing signature case)
+    if (!thinking.trim() && signature !== undefined && opts.allowEmptyThinkingWithSignature) {
+        return true;
+    }
+    // 有内容 + 足够长度的 signature = 有效
+    if (signature && signature.length >= opts.minLength) {
+        return true;
+    }
+    return false;
+}
+/**
+ * 清理 thinking 块，移除额外字段，保留有效签名
+ *
+ * @param block - thinking 块对象
+ * @returns 清理后的块
+ */
+export function sanitizeThinkingBlock(block) {
+    if (!block || typeof block !== 'object') {
+        return block;
+    }
+    const obj = block;
+    const blockType = obj.type;
+    if (blockType !== 'thinking' && blockType !== 'reasoning' && blockType !== 'redacted_thinking') {
+        return obj;
+    }
+    const sanitized = {
+        type: blockType,
+        thinking: String(obj.thinking || obj.text || '')
+    };
+    const signature = coerceThoughtSignature(obj.thoughtSignature || obj.signature);
+    if (signature) {
+        sanitized.thoughtSignature = signature;
+    }
+    return sanitized;
+}
+/**
+ * 过滤消息中的无效 thinking 块
+ *
+ * @param messages - Anthropic messages 列表（会被修改）
+ * @param options - 验证选项
+ */
+export function filterInvalidThinkingBlocks(messages, options) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    let totalFiltered = 0;
+    for (const msg of messages) {
+        if (!msg || typeof msg !== 'object')
+            continue;
+        const msgObj = msg;
+        const role = msgObj.role;
+        // 只处理 assistant 和 model 消息
+        if (role !== 'assistant' && role !== 'model')
+            continue;
+        const content = msgObj.content;
+        if (!Array.isArray(content))
+            continue;
+        const originalLen = content.length;
+        const newBlocks = [];
+        for (const block of content) {
+            if (!block || typeof block !== 'object') {
+                newBlocks.push(block);
+                continue;
+            }
+            const blockType = block.type;
+            if (blockType !== 'thinking' && blockType !== 'reasoning' && blockType !== 'redacted_thinking') {
+                newBlocks.push(block);
+                continue;
+            }
+            // 检查 thinking 块的有效性
+            if (hasValidThoughtSignature(block, opts)) {
+                // 有效签名，清理后保留
+                newBlocks.push(sanitizeThinkingBlock(block));
+            }
+            else {
+                // 无效签名
+                const thinkingText = String(block.thinking || block.text || '');
+                if (thinkingText.trim() && opts.convertToTextOnFailure) {
+                    // 有内容，转换为文本
+                    newBlocks.push({ type: 'text', text: thinkingText });
+                }
+                // 否则丢弃（空 thinking + 无效签名）
+            }
+        }
+        msgObj.content = newBlocks;
+        const filteredCount = originalLen - newBlocks.length;
+        totalFiltered += filteredCount;
+        // 如果过滤后为空，添加一个空文本块以保持消息有效
+        if (!newBlocks.length) {
+            msgObj.content = [{ type: 'text', text: '' }];
+        }
+    }
+    if (totalFiltered > 0) {
+        // 可以在这里添加日志记录
+        console.debug(`[ThoughtSignatureValidator] Filtered ${totalFiltered} invalid thinking block(s)`);
+    }
+}
+/**
+ * 移除末尾未签名的 thinking 块
+ *
+ * @param blocks - content blocks 列表（会被修改）
+ * @param options - 验证选项
+ */
+export function removeTrailingUnsignedThinkingBlocks(blocks, options) {
+    if (!Array.isArray(blocks) || !blocks.length)
+        return;
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    let end_index = blocks.length;
+    // 从末尾向前查找第一个有效签名的 thinking 块
+    for (let i = blocks.length - 1; i >= 0; i--) {
+        const block = blocks[i];
+        if (!block || typeof block !== 'object')
+            continue;
+        const blockType = block.type;
+        if (blockType === 'thinking' || blockType === 'reasoning' || blockType === 'redacted_thinking') {
+            if (!hasValidThoughtSignature(block, opts)) {
+                end_index = i;
+            }
+            else {
+                break; // 遇到有效签名的 thinking 块，停止
+            }
+        }
+        else {
+            break; // 遇到非 thinking 块，停止
+        }
+    }
+    // 移除末尾未签名的 thinking 块
+    if (end_index < blocks.length) {
+        const removed = blocks.length - end_index;
+        blocks.splice(end_index);
+        console.debug(`[ThoughtSignatureValidator] Removed ${removed} trailing unsigned thinking block(s)`);
+    }
+}
+/**
+ * 提取并强制转换 thoughtSignature
+ */
+function coerceThoughtSignature(value) {
+    if (typeof value === 'string' && value.trim().length) {
+        return value.trim();
+    }
+    return undefined;
+}

package/dist/conversion/shared/tool-argument-repairer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Tool Argument Repairer
+ *
+ * Tool calls require `function.arguments` to be a JSON string. Models often emit JSON-ish
+ * payloads (single quotes, fenced blocks, comments, trailing commas, etc.).
+ *
+ * This module provides a deterministic, best-effort repair surface that returns a JSON string
+ * or `{}` and never throws.
+ */
+export interface RepairResult {
+    repaired: string;
+    success: boolean;
+    error?: string;
+}
+export declare class ToolArgumentRepairer {
+    repairToString(args: unknown): string;
+    validateAndRepair(toolName: string, args: unknown): RepairResult;
+    /**
+     * 批量修复工具参数
+     *
+     * @param toolCalls - 工具调用列表
+     * @returns 修复后的工具调用列表
+     */
+    repairToolCalls(toolCalls: Array<{
+        name?: string;
+        arguments?: unknown;
+    }>): Array<{
+        name?: string;
+        arguments: string;
+    }>;
+}
+/**
+ * 快捷函数：修复工具参数
+ */
+export declare function repairToolArguments(args: unknown): string;
+/**
+ * 快捷函数：验证并修复工具参数
+ */
+export declare function validateToolArguments(toolName: string, args: unknown): RepairResult;