@jsonstudio/llms 0.6.631 → 0.6.743

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

@@ -4,6 +4,7 @@
 // enforceChatBudget: 为避免在请求侧引入多余依赖，这里提供最小实现（保留形状，不裁剪）。
 import { augmentOpenAITools } from '../../guidance/index.js';
 import { validateToolCall } from '../../tools/tool-registry.js';
+import { repairFindMeta } from './tooling.js';
 function isObject(v) { return !!v && typeof v === 'object' && !Array.isArray(v); }
 // Note: tool schema strict augmentation removed per alignment
 function enforceChatBudget(chat, _modelId) { return chat; }
@@ -25,8 +26,8 @@ function tryWriteSnapshot(options, stage, data) {
         const ep = String(snap.endpoint || 'chat').toLowerCase();
         const group = ep.includes('responses') ? 'openai-responses' : ep.includes('messages') ? 'anthropic-messages' : 'openai-chat';
         const rid = String(snap.requestId || `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`);
-        const dir = path.join(base, group);
-        const file = path.join(dir, `${rid}_govern-${stage}.json`);
+        const dir = path.join(base, group, '__pending__', rid);
+        const file = path.join(dir, `govern-${stage}.json`);
         if (fs.existsSync(file))
             return; // 不重复
         fs.mkdirSync(dir, { recursive: true });
@@ -209,7 +210,7 @@ export function processChatRequestTools(request, opts) {
         // 4) Enforce payload budget (context bytes) with minimal loss policy
         const modelId = typeof canonical?.model === 'string' ? String(canonical.model) : 'unknown';
         const budgeted = enforceChatBudget(canonical, modelId);
-        return normalizeApplyPatchToolCallsOnRequest(budgeted);
+        return normalizeSpecialToolCallsOnRequest(budgeted);
     }
     catch {
         return out;
@@ -220,7 +221,7 @@ export function processChatRequestTools(request, opts) {
  * - Canonicalize textual tool markup to tool_calls; ensure finish_reason and content=null policy
  */
 import { repairArgumentsToString, parseLenient } from './jsonish.js';
-function normalizeApplyPatchToolCallsOnResponse(chat) {
+export function normalizeApplyPatchToolCallsOnResponse(chat) {
     try {
         const out = JSON.parse(JSON.stringify(chat));
         const choices = Array.isArray(out?.choices) ? out.choices : [];
@@ -241,6 +242,19 @@ function normalizeApplyPatchToolCallsOnResponse(chat) {
                     if (validation && validation.ok && typeof validation.normalizedArgs === 'string') {
                         fn.arguments = validation.normalizedArgs;
                     }
+                    else if (validation && !validation.ok) {
+                        try {
+                            const reason = validation.reason ?? 'unknown';
+                            const snippet = typeof argsStr === 'string' && argsStr.trim().length
+                                ? argsStr.trim().slice(0, 200).replace(/\s+/g, ' ')
+                                : '';
+                            // eslint-disable-next-line no-console
+                            console.error(`\x1b[31m[apply_patch][precheck][response] validation_failed reason=${reason}${snippet ? ` args=${snippet}` : ''}\x1b[0m`);
+                        }
+                        catch {
+                            // logging best-effort
+                        }
+                    }
                 }
                 catch {
                     // best-effort per tool_call
@@ -253,14 +267,32 @@ function normalizeApplyPatchToolCallsOnResponse(chat) {
         return chat;
     }
 }
-function normalizeApplyPatchToolCallsOnRequest(request) {
+export function normalizeApplyPatchToolCallsOnRequest(request) {
+    return normalizeSpecialToolCallsOnRequest(request);
+}
+function normalizeSpecialToolCallsOnRequest(request) {
     try {
         const out = JSON.parse(JSON.stringify(request));
         const messages = Array.isArray(out?.messages) ? out.messages : [];
-        for (const msg of messages) {
+        // 仅针对「当轮」工具调用做校验与形态修复：选择最后一条 assistant 消息
+        let lastAssistantIndex = -1;
+        for (let i = messages.length - 1; i >= 0; i -= 1) {
+            const candidate = messages[i];
+            if (!candidate || typeof candidate !== 'object')
+                continue;
+            if (candidate.role === 'assistant') {
+                lastAssistantIndex = i;
+                break;
+            }
+        }
+        if (lastAssistantIndex === -1) {
+            return out;
+        }
+        for (let i = 0; i < messages.length; i += 1) {
+            const msg = messages[i];
             if (!msg || typeof msg !== 'object')
                 continue;
-            if (msg.role !== 'assistant')
+            if (i !== lastAssistantIndex)
                 continue;
             const tcs = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
             if (!tcs.length)
@@ -269,13 +301,48 @@ function normalizeApplyPatchToolCallsOnRequest(request) {
                 try {
                     const fn = tc && tc.function ? tc.function : undefined;
                     const name = typeof fn?.name === 'string' ? String(fn.name).trim().toLowerCase() : '';
-                    if (name !== 'apply_patch')
-                        continue;
                     const rawArgs = fn?.arguments;
-                    const argsStr = repairArgumentsToString(rawArgs);
-                    const validation = validateToolCall('apply_patch', argsStr);
-                    if (validation && validation.ok && typeof validation.normalizedArgs === 'string') {
-                        fn.arguments = validation.normalizedArgs;
+                    // apply_patch 兼容：统一生成 { patch, input }
+                    if (name === 'apply_patch') {
+                        const argsStr = repairArgumentsToString(rawArgs);
+                        const validation = validateToolCall('apply_patch', argsStr);
+                        if (validation && validation.ok && typeof validation.normalizedArgs === 'string') {
+                            fn.arguments = validation.normalizedArgs;
+                        }
+                        else if (validation && !validation.ok) {
+                            try {
+                                const reason = validation.reason ?? 'unknown';
+                                const snippet = typeof argsStr === 'string' && argsStr.trim().length
+                                    ? argsStr.trim().slice(0, 200).replace(/\s+/g, ' ')
+                                    : '';
+                                // eslint-disable-next-line no-console
+                                console.error(`\x1b[31m[apply_patch][precheck][request] validation_failed reason=${reason}${snippet ? ` args=${snippet}` : ''}\x1b[0m`);
+                            }
+                            catch {
+                                // logging best-effort
+                            }
+                        }
+                        continue;
+                    }
+                    // exec_command 兼容：TOON / map / string 一律收敛为 { cmd, command, workdir, ... }
+                    if (name === 'exec_command') {
+                        const argsStr = repairArgumentsToString(rawArgs);
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(argsStr);
+                        }
+                        catch {
+                            parsed = parseLenient(argsStr);
+                        }
+                        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                            const normalized = normalizeExecCommandArgs(parsed);
+                            try {
+                                fn.arguments = JSON.stringify(normalized ?? {});
+                            }
+                            catch {
+                                fn.arguments = '{}';
+                            }
+                        }
                     }
                 }
                 catch {
@@ -289,6 +356,27 @@ function normalizeApplyPatchToolCallsOnRequest(request) {
         return request;
     }
 }
+function normalizeExecCommandArgs(args) {
+    try {
+        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 args;
+    }
+}
 function enhanceResponseToolArguments(chat) {
     try {
         const enable = String(process?.env?.RCC_TOOL_ENHANCE ?? '1').trim() !== '0';

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

@@ -80,8 +80,48 @@ function extractFromTextual(content, ctx) {
         }
         return events;
     }
-    // 3) rcc.tool.v1 JSON envelope (removed)
-    // 4) Generic <tool_call> textual block with <arg_key>/<arg_value>
+    // 3) <invoke name="tool"> wrapper with <parameter name="key">value</parameter>
+    try {
+        const invokeRe = /<invoke\s+name="([^">]+)"[^>]*>([\s\S]*?)<\/invoke>/gi;
+        let mInvoke;
+        const invokeEvents = [];
+        let idx = 0;
+        while ((mInvoke = invokeRe.exec(content)) !== null) {
+            const toolName = (mInvoke[1] || '').trim();
+            const inner = mInvoke[2] || '';
+            if (!toolName || !inner)
+                continue;
+            const paramRe = /<parameter\s+name="([^">]+)"[^>]*>([\s\S]*?)<\/parameter>/gi;
+            const argsObj = {};
+            let mParam;
+            while ((mParam = paramRe.exec(inner)) !== null) {
+                const key = String((mParam[1] || '').trim());
+                const raw = (mParam[2] || '').trim();
+                if (!key)
+                    continue;
+                let value = raw;
+                try {
+                    value = JSON.parse(raw);
+                }
+                catch { /* keep string */ }
+                argsObj[key] = value;
+            }
+            const id = genId(ctx, idx);
+            invokeEvents.push({ tool_calls: [{ index: idx, id, type: 'function', function: { name: toolName } }] });
+            const argStr = toJsonString(argsObj);
+            const parts = chunkString(argStr, Math.max(32, Math.min(1024, ctx?.chunkSize || 256)));
+            for (const d of parts) {
+                invokeEvents.push({ tool_calls: [{ index: idx, id, type: 'function', function: { arguments: d } }] });
+            }
+            idx += 1;
+        }
+        if (invokeEvents.length) {
+            return invokeEvents;
+        }
+    }
+    catch { /* ignore textual invoke parse errors */ }
+    // 4) rcc.tool.v1 JSON envelope (removed)
+    // 5) Generic <tool_call> textual block with <arg_key>/<arg_value>
     try {
         // Explicit wrapper form
         const blockRe = /<tool_call[^>]*>[\s\S]*?<\/tool_call>/gi;

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/index.d.ts

@@ -12,8 +12,6 @@ export * from './special/response-tool-text-canonicalize.js';
 export * from './special/response-tool-arguments-stringify.js';
 export * from './special/response-finish-invariants.js';
 export * from './special/request-tools-normalize.js';
-export * from './special/response-tool-arguments-toon-decode.js';
-export * from './special/response-apply-patch-toon-decode.js';
 export * from './special/response-tool-arguments-blacklist.js';
 export * from './special/response-tool-arguments-schema-converge.js';
 export * from './special/response-tool-arguments-whitelist.js';

package/dist/filters/index.js

@@ -14,8 +14,6 @@ export * from './special/response-tool-arguments-stringify.js';
 export * from './special/response-finish-invariants.js';
 // TOON support (default ON via RCC_TOON_ENABLE unless explicitly disabled)
 export * from './special/request-tools-normalize.js';
-export * from './special/response-tool-arguments-toon-decode.js';
-export * from './special/response-apply-patch-toon-decode.js';
 // Arguments policy filters (synced)
 export * from './special/response-tool-arguments-blacklist.js';
 export * from './special/response-tool-arguments-schema-converge.js';

package/dist/filters/special/request-tools-normalize.d.ts

@@ -0,0 +1,11 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * Normalize OpenAI tools definitions at the final request stage.
+ * - Enforces { command: string | string[], workdir?: string } shape for shell-like tools.
+ * - Best-effort; never throws.
+ */
+export declare class RequestOpenAIToolsNormalizeFilter implements Filter<JsonObject> {
+    readonly name = "request_openai_tools_normalize";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject): Promise<FilterResult<JsonObject>>;
+}

package/dist/filters/special/request-tools-normalize.js

@@ -1,11 +1,10 @@
-import { appendApplyPatchReminder, buildShellDescription, hasApplyPatchToolDeclared, isShellToolName, normalizeToolName } from '../../tools/tool-description-utils.js';
+import { buildShellDescription, hasApplyPatchToolDeclared, isShellToolName } from '../../tools/tool-description-utils.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
 /**
  * Normalize OpenAI tools definitions at the final request stage.
- * - Switches shell parameters schema to TOON ({ toon: string }) when enabled and not heredoc.
- * - Otherwise enforces { command: string | string[], workdir?: string } shape.
+ * - Enforces { command: string | string[], workdir?: string } shape for shell-like tools.
  * - Best-effort; never throws.
  */
 export class RequestOpenAIToolsNormalizeFilter {
@@ -14,23 +13,6 @@ export class RequestOpenAIToolsNormalizeFilter {
     async apply(input) {
         try {
             const out = JSON.parse(JSON.stringify(input || {}));
-            const messages = Array.isArray(out.messages) ? out.messages : [];
-            const lastUser = [...messages].reverse().find((m) => m && m.role === 'user');
-            let lastText = '';
-            if (typeof lastUser?.content === 'string') {
-                lastText = lastUser.content;
-            }
-            else if (Array.isArray(lastUser?.content)) {
-                for (const p of lastUser.content) {
-                    if (p && typeof p.text === 'string' && p.text.trim()) {
-                        lastText = p.text;
-                        break;
-                    }
-                }
-            }
-            const looksHeredoc = /<<[-']?\w+/.test(lastText);
-            const toonEnv = String(process?.env?.RCC_TOON_ENABLE || process?.env?.ROUTECODEX_TOON_ENABLE || '').toLowerCase();
-            const toonEnabled = toonEnv ? !(toonEnv === '0' || toonEnv === 'false' || toonEnv === 'off') : true; // default ON
             const tools = Array.isArray(out.tools) ? out.tools : [];
             const hasApplyPatchTool = hasApplyPatchToolDeclared(tools);
             if (!tools.length) {
@@ -79,37 +61,18 @@ export class RequestOpenAIToolsNormalizeFilter {
                     try {
                         const rawToolName = String(dst.function.name || '');
                         const isShell = isShellToolName(rawToolName);
-                        const isApplyPatch = normalizeToolName(rawToolName) === 'apply_patch';
                         if (isShell) {
-                            const wantToon = toonEnabled && !looksHeredoc;
-                            if (wantToon) {
-                                dst.function.parameters = {
-                                    type: 'object',
-                                    properties: {
-                                        toon: {
-                                            type: 'string',
-                                            description: 'TOON-encoded arguments (multi-line key: value). Example: command: bash -lc "echo ok"\\nworkdir: .'
-                                        }
-                                    },
-                                    required: ['toon'],
-                                    additionalProperties: false
-                                };
-                                const toonDescription = 'Use TOON: put arguments into arguments.toon as multi-line key: value (e.g., command / workdir).';
-                                dst.function.description = appendApplyPatchReminder(toonDescription, hasApplyPatchTool);
-                            }
-                            else {
-                                dst.function.parameters = {
-                                    type: 'object',
-                                    properties: {
-                                        command: { oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }] },
-                                        workdir: { type: 'string' }
-                                    },
-                                    required: ['command'],
-                                    additionalProperties: false
-                                };
-                                const label = rawToolName && rawToolName.trim().length > 0 ? rawToolName.trim() : 'shell';
-                                dst.function.description = buildShellDescription(label, hasApplyPatchTool);
-                            }
+                            dst.function.parameters = {
+                                type: 'object',
+                                properties: {
+                                    command: { oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }] },
+                                    workdir: { type: 'string' }
+                                },
+                                required: ['command'],
+                                additionalProperties: false
+                            };
+                            const label = rawToolName && rawToolName.trim().length > 0 ? rawToolName.trim() : 'shell';
+                            dst.function.description = buildShellDescription(label, hasApplyPatchTool);
                         }
                     }
                     catch { /* ignore */ }