@jsonstudio/llms 0.6.631 → 0.6.743

package/dist/filters/special/response-apply-patch-toon-decode.js

@@ -10,6 +10,400 @@ function envEnabled() {
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
+function readString(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed ? trimmed : undefined;
+    }
+    return undefined;
+}
+function stripCodeFences(text) {
+    const trimmed = text.trim();
+    const fenceRe = /```(?:diff|patch|apply_patch|toon|text|json)?\s*([\s\S]*?)```/gi;
+    const candidates = [];
+    let match = null;
+    while ((match = fenceRe.exec(trimmed))) {
+        if (match[1]) {
+            candidates.push(match[1].trim());
+        }
+    }
+    if (!candidates.length) {
+        return text;
+    }
+    for (const candidate of candidates) {
+        if (candidate.includes('*** Begin Patch') ||
+            candidate.includes('*** Update File:') ||
+            candidate.includes('diff --git')) {
+            return candidate;
+        }
+    }
+    return candidates[0] ?? text;
+}
+function looksLikePatch(text) {
+    if (!text)
+        return false;
+    const t = text.trim();
+    if (!t)
+        return false;
+    return (t.includes('*** Begin Patch') ||
+        t.includes('*** Update File:') ||
+        t.includes('*** Add File:') ||
+        t.includes('*** Delete File:') ||
+        t.includes('diff --git') ||
+        /^(?:@@|\+\+\+\s|---\s)/m.test(t));
+}
+function convertGitDiffToApplyPatch(text) {
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    const files = [];
+    let current = null;
+    let sawDiff = false;
+    const flush = () => {
+        if (!current)
+            return;
+        if (current.path && current.kind === 'delete') {
+            files.push(current);
+            current = null;
+            return;
+        }
+        if (!current.path || (current.kind === 'update' && current.lines.length === 0)) {
+            current = null;
+            return;
+        }
+        files.push(current);
+        current = null;
+    };
+    for (const raw of lines) {
+        const line = raw;
+        const diffMatch = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+        if (diffMatch) {
+            sawDiff = true;
+            flush();
+            const path = diffMatch[2] || diffMatch[1];
+            current = { path, kind: 'update', lines: [] };
+            continue;
+        }
+        if (!current) {
+            continue;
+        }
+        if (line.startsWith('new file mode')) {
+            current.kind = 'add';
+            continue;
+        }
+        if (line.startsWith('deleted file mode')) {
+            current.kind = 'delete';
+            continue;
+        }
+        if (line.startsWith('index ') || line.startsWith('old mode') || line.startsWith('new mode')) {
+            continue;
+        }
+        if (line.startsWith('--- ')) {
+            if (line.includes('/dev/null')) {
+                current.kind = 'add';
+            }
+            continue;
+        }
+        if (line.startsWith('+++ ')) {
+            if (line.includes('/dev/null')) {
+                current.kind = 'delete';
+            }
+            else {
+                const plusMatch = line.match(/^\+\+\+\s+(?:b\/)?(.+)$/);
+                if (plusMatch && plusMatch[1]) {
+                    current.path = plusMatch[1];
+                }
+            }
+            continue;
+        }
+        if (current.kind === 'delete') {
+            continue;
+        }
+        if (current.kind === 'add') {
+            if (line.startsWith('+') && !line.startsWith('+++')) {
+                current.lines.push(line);
+            }
+            else if (line.startsWith('\\')) {
+                current.lines.push(`+${line}`);
+            }
+            continue;
+        }
+        if (line.startsWith('@@') ||
+            line.startsWith('+') ||
+            line.startsWith('-') ||
+            line.startsWith(' ') ||
+            line.startsWith('\\')) {
+            current.lines.push(line.startsWith('\\') ? ` ${line}` : line);
+        }
+    }
+    flush();
+    if (!sawDiff || files.length === 0) {
+        return null;
+    }
+    const output = ['*** Begin Patch'];
+    for (const file of files) {
+        if (!file.path)
+            continue;
+        if (file.kind === 'add') {
+            output.push(`*** Add File: ${file.path}`);
+            for (const line of file.lines) {
+                if (line.startsWith('+')) {
+                    output.push(line);
+                }
+                else {
+                    output.push(`+${line}`);
+                }
+            }
+            continue;
+        }
+        if (file.kind === 'delete') {
+            output.push(`*** Delete File: ${file.path}`);
+            continue;
+        }
+        output.push(`*** Update File: ${file.path}`);
+        for (const line of file.lines) {
+            if (line.startsWith('@@') || line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
+                output.push(line);
+            }
+            else {
+                output.push(` ${line}`);
+            }
+        }
+    }
+    output.push('*** End Patch');
+    return output.join('\n');
+}
+function normalizeApplyPatchText(raw) {
+    if (!raw)
+        return raw;
+    let text = raw.replace(/\r\n/g, '\n');
+    text = stripCodeFences(text);
+    text = text.trim();
+    if (!text) {
+        return raw;
+    }
+    if (!text.includes('*** Begin Patch') && text.includes('diff --git')) {
+        const converted = convertGitDiffToApplyPatch(text);
+        if (converted) {
+            text = converted;
+        }
+    }
+    if (text.includes('*** Create File:')) {
+        text = text.replace(/\*\*\* Create File:/g, '*** Add File:');
+    }
+    const hasBegin = text.includes('*** Begin Patch');
+    const hasEnd = text.includes('*** End Patch');
+    if (hasBegin && !hasEnd) {
+        text = `${text}\n*** End Patch`;
+    }
+    if (!hasBegin && /^\*\*\* (Add|Update|Delete) File:/m.test(text)) {
+        text = `*** Begin Patch\n${text}\n*** End Patch`;
+    }
+    if (!text.includes('*** Begin Patch')) {
+        return text;
+    }
+    const lines = text.split('\n');
+    const output = [];
+    let inUpdateSection = false;
+    let afterUpdateHeader = false;
+    for (const line of lines) {
+        if (line.startsWith('*** Begin Patch')) {
+            output.push(line);
+            inUpdateSection = false;
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (line.startsWith('*** End Patch')) {
+            output.push(line);
+            inUpdateSection = false;
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (line.startsWith('*** Update File:')) {
+            output.push(line);
+            inUpdateSection = true;
+            afterUpdateHeader = true;
+            continue;
+        }
+        if (line.startsWith('*** Add File:') || line.startsWith('*** Delete File:')) {
+            output.push(line);
+            inUpdateSection = false;
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (inUpdateSection) {
+            if (afterUpdateHeader && line.trim() === '') {
+                continue;
+            }
+            afterUpdateHeader = false;
+            if (line.startsWith('@@') || line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
+                output.push(line);
+            }
+            else {
+                output.push(` ${line}`);
+            }
+            continue;
+        }
+        output.push(line);
+    }
+    return output.join('\n');
+}
+function collectFunctionCallAdapters(payload) {
+    const adapters = [];
+    const anyPayload = payload;
+    const choices = Array.isArray(anyPayload.choices)
+        ? (anyPayload.choices ?? [])
+        : [];
+    for (const choice of choices) {
+        const message = choice && typeof choice === 'object' ? choice.message : undefined;
+        const toolCalls = message && Array.isArray(message.tool_calls) ? message.tool_calls : [];
+        for (const tc of toolCalls) {
+            const fnObj = tc && typeof tc === 'object' ? tc.function : undefined;
+            if (fnObj && typeof fnObj === 'object') {
+                adapters.push({
+                    name: typeof fnObj.name === 'string' ? String(fnObj.name) : undefined,
+                    getArguments: () => fnObj.arguments,
+                    setArguments: (value) => {
+                        fnObj.arguments = value;
+                    }
+                });
+            }
+        }
+    }
+    const output = Array.isArray(anyPayload.output) ? anyPayload.output : [];
+    for (const item of output) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = String(item.type || '').toLowerCase();
+        if (type === 'function_call') {
+            adapters.push({
+                name: typeof item.name === 'string' ? String(item.name) : undefined,
+                getArguments: () => item.arguments,
+                setArguments: (value) => {
+                    item.arguments = value;
+                }
+            });
+            continue;
+        }
+        if (type === 'message' && Array.isArray(item.tool_calls)) {
+            for (const tc of item.tool_calls) {
+                const fnObj = tc && typeof tc === 'object' ? tc.function : undefined;
+                if (!fnObj || typeof fnObj !== 'object')
+                    continue;
+                adapters.push({
+                    name: typeof fnObj.name === 'string' ? String(fnObj.name) : undefined,
+                    getArguments: () => fnObj.arguments,
+                    setArguments: (value) => {
+                        fnObj.arguments = value;
+                    }
+                });
+            }
+        }
+    }
+    return adapters;
+}
+function buildSingleChangePayload(record) {
+    const kindRaw = readString(record.kind);
+    if (!kindRaw)
+        return undefined;
+    const change = {
+        kind: kindRaw.toLowerCase(),
+        lines: record.lines ?? record.text ?? record.body,
+        target: readString(record.target),
+        anchor: readString(record.anchor)
+    };
+    if (typeof record.use_anchor_indent === 'boolean') {
+        change.use_anchor_indent = record.use_anchor_indent;
+    }
+    const changeFile = readString(record.file);
+    if (changeFile) {
+        change.file = changeFile;
+    }
+    return {
+        file: changeFile,
+        changes: [change]
+    };
+}
+function coerceStructuredPayload(record) {
+    if (isStructuredApplyPatchPayload(record)) {
+        return record;
+    }
+    if (Array.isArray(record.changes) && record.changes.length === 0) {
+        return undefined;
+    }
+    const single = buildSingleChangePayload(record);
+    if (single) {
+        return single;
+    }
+    return undefined;
+}
+function maybeNormalizeArguments(argIn) {
+    let parsed;
+    let patchText;
+    if (typeof argIn === 'string') {
+        const trimmed = argIn.trim();
+        if (!trimmed)
+            return undefined;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            if (looksLikePatch(trimmed)) {
+                patchText = trimmed;
+            }
+            else {
+                const stripped = stripCodeFences(trimmed);
+                if (looksLikePatch(stripped)) {
+                    patchText = stripped;
+                }
+            }
+        }
+    }
+    else if (isObject(argIn)) {
+        parsed = argIn;
+    }
+    else {
+        return undefined;
+    }
+    const record = parsed ?? {};
+    if (!patchText) {
+        const toon = readString(record.toon);
+        if (looksLikePatch(toon)) {
+            patchText = toon;
+        }
+    }
+    if (!patchText) {
+        const payload = coerceStructuredPayload(record);
+        if (payload) {
+            try {
+                patchText = buildStructuredPatch(payload);
+            }
+            catch (error) {
+                if (!(error instanceof StructuredApplyPatchError)) {
+                    /* ignore */
+                }
+            }
+        }
+    }
+    if (!patchText) {
+        const patchField = readString(record.patch);
+        if (looksLikePatch(patchField)) {
+            patchText = patchField;
+        }
+    }
+    if (!patchText) {
+        const inputField = readString(record.input);
+        if (looksLikePatch(inputField)) {
+            patchText = inputField;
+        }
+    }
+    if (!patchText) {
+        return undefined;
+    }
+    const normalizedText = normalizeApplyPatchText(patchText);
+    if (!looksLikePatch(normalizedText)) {
+        return undefined;
+    }
+    return JSON.stringify({ input: normalizedText, patch: normalizedText });
+}
 /**
  * Response-side apply_patch arguments 规范化（TOON + 结构化 JSON → 统一 diff 文本）。
  *
@@ -35,79 +429,28 @@ export class ResponseApplyPatchToonDecodeFilter {
             return { ok: true, data: input };
         try {
             const out = JSON.parse(JSON.stringify(input || {}));
-            const choices = Array.isArray(out.choices) ? out.choices : [];
-            for (const ch of choices) {
-                const msg = ch && ch.message ? ch.message : undefined;
-                const tcs = msg && Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
-                for (const tc of tcs) {
+            const adapters = collectFunctionCallAdapters(out);
+            for (const adapter of adapters) {
+                try {
+                    const name = adapter.name ? adapter.name.trim().toLowerCase() : '';
+                    if (name !== 'apply_patch') {
+                        continue;
+                    }
+                    const normalizedArgs = maybeNormalizeArguments(adapter.getArguments());
+                    if (!normalizedArgs) {
+                        continue;
+                    }
                     try {
-                        const fn = tc && tc.function ? tc.function : undefined;
-                        if (!fn || typeof fn !== 'object')
-                            continue;
-                        const nameRaw = fn.name;
-                        if (typeof nameRaw !== 'string' || nameRaw.trim().toLowerCase() !== 'apply_patch') {
-                            continue;
-                        }
-                        const argIn = fn.arguments;
-                        let parsed;
-                        if (typeof argIn === 'string') {
-                            if (!argIn.trim())
-                                continue;
-                            try {
-                                parsed = JSON.parse(argIn);
-                            }
-                            catch {
-                                // 如果 arguments 不是 JSON 字符串，则保持原样交给下游处理
-                                continue;
-                            }
-                        }
-                        else if (isObject(argIn)) {
-                            parsed = argIn;
-                        }
-                        else {
-                            continue;
-                        }
-                        if (!isObject(parsed))
-                            continue;
-                        // 优先处理 toon: "<patch text>" 形态（兼容旧 TOON 协议）
-                        const toon = parsed.toon;
-                        let patchText;
-                        if (typeof toon === 'string' && toon.trim()) {
-                            if (toon.includes('*** Begin Patch') && toon.includes('*** End Patch')) {
-                                patchText = toon;
-                            }
-                        }
-                        // 否则尝试结构化 JSON（changes 数组 → 统一 diff）
-                        if (!patchText && isStructuredApplyPatchPayload(parsed)) {
-                            try {
-                                patchText = buildStructuredPatch(parsed);
-                            }
-                            catch (error) {
-                                if (error instanceof StructuredApplyPatchError) {
-                                    // 结构化 payload 无法构建补丁时，保留原始 arguments，
-                                    // 由下游工具或客户端根据自身策略报错；这里不吞掉错误。
-                                    continue;
-                                }
-                                continue;
-                            }
-                        }
-                        if (!patchText) {
-                            continue;
-                        }
-                        const normalized = { input: patchText, patch: patchText };
-                        try {
-                            fn.arguments = JSON.stringify(normalized);
-                        }
-                        catch {
-                            // stringify 失败时保留原始 arguments
-                        }
+                        adapter.setArguments(normalizedArgs);
                     }
                     catch {
-                        // 针对单个 tool_call 的 best-effort，不影响其他工具
+                        // ignore single adapter failures
                     }
                 }
+                catch {
+                    // 单个 tool_call best-effort
+                }
             }
-            out.choices = choices;
             return { ok: true, data: out };
         }
         catch {

package/dist/filters/special/response-tool-arguments-stringify.js

@@ -1,26 +1,26 @@
+import { repairFindMeta } from '../../conversion/shared/tooling.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
-function repairFindMeta(s) {
-    // Minimal, idempotent repairs for common find expressions within a shell:
-    // - ensure -exec terminator is escaped exactly once: ;  =>  \\;
-    // - collapse multiple backslashes before ; to a single backslash
-    // - escape unescaped parentheses used in predicates: ( ) -> \\( \\)
+function normalizeExecCommandArgs(args) {
     try {
-        const hasFind = /(^|\s)find\s/.test(s);
-        if (!hasFind)
-            return s;
-        let out = s;
-        // Only escape semicolon not already escaped (negative lookbehind)
-        out = out.replace(/-exec([^;]*?)(?<!\\);/g, (_m, g1) => `-exec${g1} \\;`);
-        // Collapse multiple backslashes immediately before ; into a single backslash
-        out = out.replace(/-exec([^;]*?)\\+;/g, (_m, g1) => `-exec${g1} \\;`);
-        // Escape parentheses only when not already escaped
-        out = out.replace(/(?<!\\)\(/g, '\\(').replace(/(?<!\\)\)/g, '\\)');
+        const out = { ...args };
+        const rawCmd = typeof out.cmd === 'string' && out.cmd.trim().length
+            ? String(out.cmd)
+            : typeof out.command === 'string' && out.command.trim().length
+                ? String(out.command)
+                : undefined;
+        if (rawCmd) {
+            const fixed = repairFindMeta(rawCmd);
+            out.cmd = fixed;
+            if (typeof out.command === 'string') {
+                out.command = fixed;
+            }
+        }
         return out;
     }
     catch {
-        return s;
+        return args;
     }
 }
 function packShellCommand(cmd) {
@@ -102,6 +102,15 @@ export class ResponseToolArgumentsStringifyFilter {
                                     fn.arguments = '{}';
                                 }
                             }
+                            else if ((name === 'exec_command' || name === 'shell_command' || name === 'bash') && isObject(parsed)) {
+                                const normalized = normalizeExecCommandArgs(parsed);
+                                try {
+                                    fn.arguments = JSON.stringify(normalized ?? {});
+                                }
+                                catch {
+                                    fn.arguments = '{}';
+                                }
+                            }
                             else {
                                 if (typeof argIn !== 'string') {
                                     try {

package/dist/filters/special/response-tool-arguments-toon-decode.js

@@ -1,4 +1,6 @@
 import { isShellToolName, normalizeToolName } from '../../tools/tool-description-utils.js';
+import { repairFindMeta } from '../../conversion/shared/tooling.js';
+import { decodeToonToKeyValue, coerceToonValue } from '../../utils/toon.js';
 function envEnabled() {
     // Default ON. Allow disabling via env RCC_TOON_ENABLE/ROUTECODEX_TOON_ENABLE = 0|false|off
     const v = String(process?.env?.RCC_TOON_ENABLE || process?.env?.ROUTECODEX_TOON_ENABLE || '').toLowerCase();
@@ -7,71 +9,6 @@ function envEnabled() {
     return !(v === '0' || v === 'false' || v === 'off');
 }
 function isObject(v) { return !!v && typeof v === 'object' && !Array.isArray(v); }
-function decodeToonPairs(toon) {
-    try {
-        const out = {};
-        const lines = String(toon).split(/\r?\n/);
-        let currentKey = null;
-        let currentVal = '';
-        const flush = () => {
-            if (currentKey) {
-                out[currentKey] = currentVal;
-            }
-            currentKey = null;
-            currentVal = '';
-        };
-        for (const raw of lines) {
-            const line = raw.trim();
-            if (!line)
-                continue;
-            const m = line.match(/^([A-Za-z0-9_\-]+)\s*:\s*(.*)$/);
-            if (m) {
-                // 新的 key: value 行，先提交上一段，再开始累积新 key 的值
-                flush();
-                currentKey = m[1];
-                currentVal = m[2] ?? '';
-            }
-            else {
-                // 非 key: value 行视为上一 key 的续行（例如多行脚本）
-                if (!currentKey) {
-                    // 如果一开始就遇到无法识别的行，认为整个 TOON 不是我们支持的形态
-                    return null;
-                }
-                currentVal += (currentVal ? '\n' : '') + raw;
-            }
-        }
-        flush();
-        return Object.keys(out).length ? out : null;
-    }
-    catch {
-        return null;
-    }
-}
-function coerceToPrimitive(value) {
-    const trimmed = value.trim();
-    if (!trimmed)
-        return '';
-    const lower = trimmed.toLowerCase();
-    if (lower === 'true')
-        return true;
-    if (lower === 'false')
-        return false;
-    if (/^[+-]?\d+(\.\d+)?$/.test(trimmed)) {
-        const num = Number(trimmed);
-        if (Number.isFinite(num))
-            return num;
-    }
-    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
-        (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
-        try {
-            return JSON.parse(trimmed);
-        }
-        catch {
-            // fall through
-        }
-    }
-    return value;
-}
 /**
  * Decode arguments.toon to standard JSON ({command, workdir?}) and map tool name 'shell_toon' → 'shell'.
  * Stage: response_pre (before arguments stringify and invariants).
@@ -98,7 +35,6 @@ export class ResponseToolArgumentsToonDecodeFilter {
                         const toolName = typeof rawName === 'string' ? rawName : '';
                         const normalizedName = normalizeToolName(toolName);
                         const isShellLike = isShellToolName(toolName);
-                        const isApplyPatch = normalizedName === 'apply_patch';
                         const argIn = fn.arguments;
                         let parsed = undefined;
                         if (typeof argIn === 'string') {
@@ -117,7 +53,7 @@ export class ResponseToolArgumentsToonDecodeFilter {
                         const toon = parsed.toon;
                         if (typeof toon !== 'string' || !toon.trim())
                             continue;
-                        const kv = decodeToonPairs(toon);
+                        const kv = decodeToonToKeyValue(toon);
                         if (!kv) {
                             const preview = toon.split(/\r?\n/).slice(0, 5).join('\n');
                             const warnMsg = `response_tool_arguments_toon_decode: failed to decode TOON arguments for tool "${fn.name ?? 'unknown'}"`;
@@ -136,10 +72,6 @@ export class ResponseToolArgumentsToonDecodeFilter {
                             }
                             continue; // keep original if decode fails
                         }
-                        // apply_patch 的 toon 由专门的 ResponseApplyPatchToonDecodeFilter 处理，这里跳过，避免覆盖。
-                        if (isApplyPatch) {
-                            continue;
-                        }
                         if (isShellLike) {
                             const commandRaw = (typeof kv['command'] === 'string' && kv['command'].trim()
                                 ? kv['command']
@@ -156,7 +88,7 @@ export class ResponseToolArgumentsToonDecodeFilter {
                                 ? kv['with_escalated_permissions']
                                 : undefined;
                             const justificationRaw = typeof kv['justification'] === 'string' ? kv['justification'] : undefined;
-                            const command = commandRaw.trim();
+                            const command = repairFindMeta(commandRaw.trim());
                             if (command) {
                                 const merged = {
                                     cmd: command,
@@ -190,16 +122,16 @@ export class ResponseToolArgumentsToonDecodeFilter {
                                 catch {
                                     /* keep original */
                                 }
-                                if (typeof fn.name === 'string' && fn.name === 'shell_toon') {
-                                    fn.name = 'shell';
-                                }
+                            }
+                            if (typeof fn.name === 'string' && fn.name === 'shell_toon') {
+                                fn.name = 'shell';
                             }
                         }
                         else {
                             // 通用 TOON → JSON 解码：除 shell / apply_patch 以外的工具，将 key: value 对映射为普通 JSON 字段。
                             const merged = {};
                             for (const [key, value] of Object.entries(kv)) {
-                                merged[key] = coerceToPrimitive(value);
+                                merged[key] = coerceToonValue(value);
                             }
                             try {
                                 fn.arguments = JSON.stringify(merged);