@jsonstudio/llms 0.6.633 → 0.6.743

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 */ }

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

@@ -17,6 +17,393 @@ function readString(value) {
     }
     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 文本）。
  *
@@ -42,94 +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;
-                        let patchText;
-                        if (typeof argIn === 'string') {
-                            const trimmed = argIn.trim();
-                            if (!trimmed)
-                                continue;
-                            try {
-                                // 尝试作为 JSON 解析
-                                parsed = JSON.parse(trimmed);
-                            }
-                            catch {
-                                // 非 JSON 字符串：如果看起来就是统一 diff，则直接视为 patch 文本
-                                if (trimmed.includes('*** Begin Patch') && trimmed.includes('*** End Patch')) {
-                                    patchText = trimmed;
-                                }
-                                else {
-                                    // 退而求其次：当作原始补丁文本传递给客户端，由本地 apply_patch 决定是否接受
-                                    patchText = trimmed;
-                                }
-                            }
-                        }
-                        else if (isObject(argIn)) {
-                            parsed = argIn;
-                        }
-                        else {
-                            continue;
-                        }
-                        if (!patchText && !isObject(parsed))
-                            continue;
-                        const record = isObject(parsed) ? parsed : {};
-                        // 优先处理 toon: "<patch text>" 形态（兼容旧 TOON 协议）
-                        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(record)) {
-                            try {
-                                patchText = buildStructuredPatch(record);
-                            }
-                            catch (error) {
-                                if (error instanceof StructuredApplyPatchError) {
-                                    // 结构化 payload 无法构建补丁时，保留原始 arguments，
-                                    // 由下游工具或客户端根据自身策略报错；这里不吞掉错误。
-                                    continue;
-                                }
-                                continue;
-                            }
-                        }
-                        // 处理 { patch }, { input, patch } 形态 —— Responses 入口常见形状
-                        if (!patchText) {
-                            const patchField = readString(record.patch);
-                            const inputField = readString(record.input);
-                            patchText = patchField || inputField;
-                        }
-                        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 {