@jsonstudio/llms 0.6.631 → 0.6.633

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/index.js

@@ -84,6 +84,12 @@ function buildToolOutputSnapshot(payload, providerProtocol) {
     const snapshot = {
         providerProtocol: providerProtocol ?? 'unknown'
     };
+    try {
+        injectApplyPatchDiagnostics(payload);
+    }
+    catch {
+        // diagnostics are best-effort; never block main flow
+    }
     const toolOutputs = collectToolOutputs(payload);
     if (toolOutputs.length) {
         snapshot.tool_outputs = toolOutputs;
@@ -102,12 +108,14 @@ function collectToolOutputs(payload) {
         try {
             const name = typeof entry.name === 'string' ? entry.name.trim() : undefined;
             const output = typeof entry.output === 'string' ? entry.output : undefined;
-            if (name === 'apply_patch' &&
-                output &&
-                output.toLowerCase().includes('apply_patch verification failed')) {
-                const firstLine = output.split('\n')[0] ?? output;
-                // eslint-disable-next-line no-console
-                console.error(`\x1b[31m[apply_patch][tool_error] tool_call_id=${id} ${firstLine}\x1b[0m`);
+            if (name === 'apply_patch' && output) {
+                const lower = output.toLowerCase();
+                if (lower.includes('apply_patch verification failed') ||
+                    lower.includes('failed to parse function arguments')) {
+                    const firstLine = output.split('\n')[0] ?? output;
+                    // eslint-disable-next-line no-console
+                    console.error(`\x1b[31m[apply_patch][tool_error] tool_call_id=${id} ${firstLine}\x1b[0m`);
+                }
             }
         }
         catch {
@@ -282,3 +290,106 @@ function normalizeToolOutputEntry(entry) {
         name
     };
 }
+function buildApplyPatchDiagnostics(output) {
+    if (!output || typeof output !== 'string') {
+        return undefined;
+    }
+    const lower = output.toLowerCase();
+    if (!lower.includes('failed to parse function arguments')) {
+        return undefined;
+    }
+    if (output.includes('missing field `input`')) {
+        return '\n\n[RouteCodex precheck] apply_patch 参数解析失败：缺少字段 "input"。当前 RouteCodex 期望 { input, patch } 或 { toon: \"<*** Begin Patch ... *** End Patch>\" } 形态。请将统一 diff 文本同时填入 \"patch\" 和 \"input\"，或改用 toon 形态。';
+    }
+    if (output.includes('invalid type: map, expected a string')) {
+        return '\n\n[RouteCodex precheck] apply_patch 参数类型错误：检测到 JSON 对象（map），但客户端期望字符串。请先对参数做 JSON.stringify 再写入 arguments，或直接提供 { patch: \"<统一 diff>\" } / { toon: \"<*** Begin Patch ... *** End Patch>\" }。';
+    }
+    return undefined;
+}
+function appendDiagnosticsToRecord(record) {
+    const name = typeof record.name === 'string' ? record.name.trim() : undefined;
+    if (name !== 'apply_patch') {
+        return;
+    }
+    let text;
+    if (typeof record.output === 'string') {
+        text = record.output;
+    }
+    else if (typeof record.content === 'string') {
+        text = record.content;
+    }
+    if (!text || text.includes('[RouteCodex precheck]')) {
+        return;
+    }
+    const diag = buildApplyPatchDiagnostics(text);
+    if (!diag) {
+        return;
+    }
+    const merged = `${text}${diag}`;
+    if (typeof record.output === 'string') {
+        record.output = merged;
+    }
+    else if (typeof record.content === 'string') {
+        record.content = merged;
+    }
+    else {
+        record.output = merged;
+    }
+}
+function injectApplyPatchDiagnostics(payload) {
+    const root = payload;
+    const topOutputs = root.tool_outputs;
+    if (Array.isArray(topOutputs)) {
+        for (const entry of topOutputs) {
+            if (entry && typeof entry === 'object') {
+                appendDiagnosticsToRecord(entry);
+            }
+        }
+    }
+    const required = root.required_action;
+    if (required && typeof required === 'object') {
+        const submit = required.submit_tool_outputs;
+        if (submit && typeof submit === 'object') {
+            const submitOutputs = submit.tool_outputs;
+            if (Array.isArray(submitOutputs)) {
+                for (const entry of submitOutputs) {
+                    if (entry && typeof entry === 'object') {
+                        appendDiagnosticsToRecord(entry);
+                    }
+                }
+            }
+        }
+    }
+    const messages = root.messages;
+    if (Array.isArray(messages)) {
+        for (const entry of messages) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const record = entry;
+            const role = typeof record.role === 'string' ? record.role.toLowerCase() : '';
+            if (role === 'tool') {
+                appendDiagnosticsToRecord(record);
+            }
+            const content = record.content;
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (!block || typeof block !== 'object')
+                        continue;
+                    appendDiagnosticsToRecord(block);
+                }
+            }
+        }
+    }
+    const responsesInput = root.input;
+    if (Array.isArray(responsesInput)) {
+        for (const entry of responsesInput) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const record = entry;
+            const type = typeof record.type === 'string' ? record.type.toLowerCase() : '';
+            if (type === 'tool_result' || type === 'tool_message' || type === 'function_call_output') {
+                appendDiagnosticsToRecord(record);
+            }
+        }
+    }
+}

package/dist/conversion/shared/tooling.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared helpers for standard tool normalization (shell packing rules).
+ * The goal is deterministic, minimal shaping so executors succeed consistently.
+ */
+export interface ShellArgs {
+    command: string | string[];
+    workdir?: string;
+    timeout_ms?: number;
+}
+/**
+ * Minimal, idempotent repairs for common `find` invocations inside shell scripts:
+ * - ensure `-exec … ;` is escaped as `-exec … \;`
+ * - collapse multiple backslashes before `;` into a single backslash
+ * - escape bare parentheses used in predicates: `(` / `)` → `\(` / `\)`
+ */
+export declare function repairFindMeta(script: string): string;
+export declare function splitCommandString(input: string): string[];
+/**
+ * Pack shell arguments per unified rules:
+ * - command: string -> ["bash","-lc","<string>"]
+ * - command: tokens[]
+ *   - if starts with ["cd", path, ...rest]:
+ *       - set workdir to path when absent
+ *       - if rest empty => command=["pwd"]
+ *       - else if rest has control tokens => command=["bash","-lc", join(rest)]
+ *       - else command=rest (argv)
+ *   - else if tokens contain control tokens => command=["bash","-lc", join(tokens)]
+ *   - else command=tokens (argv)
+ * - join(rest) uses single-space join without extra quoting
+ */
+export declare function packShellArgs(input: Record<string, unknown>): Record<string, unknown>;
+export declare function flattenByComma(arr: string[]): string[];
+export declare function chunkString(s: string, minParts?: number, maxParts?: number, targetChunk?: number): string[];

package/dist/conversion/shared/tooling.js

@@ -5,6 +5,33 @@
 // We intentionally do NOT evaluate shell control operators (&&, |, etc.).
 // Codex CLI executor runs argv directly (execvp-like), not through a shell.
 // So we avoid wrapping with "bash -lc" and leave such tokens as-is.
+/**
+ * Minimal, idempotent repairs for common `find` invocations inside shell scripts:
+ * - ensure `-exec … ;` is escaped as `-exec … \;`
+ * - collapse multiple backslashes before `;` into a single backslash
+ * - escape bare parentheses used in predicates: `(` / `)` → `\(` / `\)`
+ */
+export function repairFindMeta(script) {
+    try {
+        const s = String(script ?? '');
+        if (!s)
+            return s;
+        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, '\\)');
+        return out;
+    }
+    catch {
+        return script;
+    }
+}
 function toStringArray(v) {
     if (Array.isArray(v))
         return v.map((x) => String(x));

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

@@ -10,6 +10,13 @@ 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;
+}
 /**
  * Response-side apply_patch arguments 规范化（TOON + 结构化 JSON → 统一 diff 文本）。
  *
@@ -50,15 +57,24 @@ export class ResponseApplyPatchToonDecodeFilter {
                         }
                         const argIn = fn.arguments;
                         let parsed;
+                        let patchText;
                         if (typeof argIn === 'string') {
-                            if (!argIn.trim())
+                            const trimmed = argIn.trim();
+                            if (!trimmed)
                                 continue;
                             try {
-                                parsed = JSON.parse(argIn);
+                                // 尝试作为 JSON 解析
+                                parsed = JSON.parse(trimmed);
                             }
                             catch {
-                                // 如果 arguments 不是 JSON 字符串，则保持原样交给下游处理
-                                continue;
+                                // 非 JSON 字符串：如果看起来就是统一 diff，则直接视为 patch 文本
+                                if (trimmed.includes('*** Begin Patch') && trimmed.includes('*** End Patch')) {
+                                    patchText = trimmed;
+                                }
+                                else {
+                                    // 退而求其次：当作原始补丁文本传递给客户端，由本地 apply_patch 决定是否接受
+                                    patchText = trimmed;
+                                }
                             }
                         }
                         else if (isObject(argIn)) {
@@ -67,20 +83,20 @@ export class ResponseApplyPatchToonDecodeFilter {
                         else {
                             continue;
                         }
-                        if (!isObject(parsed))
+                        if (!patchText && !isObject(parsed))
                             continue;
+                        const record = isObject(parsed) ? parsed : {};
                         // 优先处理 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')) {
+                        if (!patchText) {
+                            const toon = readString(record.toon);
+                            if (toon && toon.includes('*** Begin Patch') && toon.includes('*** End Patch')) {
                                 patchText = toon;
                             }
                         }
-                        // 否则尝试结构化 JSON（changes 数组 → 统一 diff）
-                        if (!patchText && isStructuredApplyPatchPayload(parsed)) {
+                        // 处理结构化 JSON（changes 数组 → 统一 diff）
+                        if (!patchText && isStructuredApplyPatchPayload(record)) {
                             try {
-                                patchText = buildStructuredPatch(parsed);
+                                patchText = buildStructuredPatch(record);
                             }
                             catch (error) {
                                 if (error instanceof StructuredApplyPatchError) {
@@ -91,6 +107,12 @@ export class ResponseApplyPatchToonDecodeFilter {
                                 continue;
                             }
                         }
+                        // 处理 { patch }, { input, patch } 形态 —— Responses 入口常见形状
+                        if (!patchText) {
+                            const patchField = readString(record.patch);
+                            const inputField = readString(record.input);
+                            patchText = patchField || inputField;
+                        }
                         if (!patchText) {
                             continue;
                         }

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,5 @@
 import { isShellToolName, normalizeToolName } from '../../tools/tool-description-utils.js';
+import { repairFindMeta } from '../../conversion/shared/tooling.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();
@@ -156,7 +157,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.631",
+  "version": "0.6.633",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",