@jsonstudio/llms 0.6.795 → 0.6.938

package/dist/tools/apply-patch/validator.js

@@ -86,7 +86,8 @@ const convertGitDiffToApplyPatch = (text) => {
             current = null;
             return;
         }
-        if (current.path && current.lines.length) {
+        // Include rename-only diffs (no hunks) when we have a move target.
+        if (current.path && (current.lines.length || current.moveTo)) {
             files.push(current);
         }
         current = null;
@@ -95,19 +96,30 @@ const convertGitDiffToApplyPatch = (text) => {
         const v = String(value || '').trim();
         if (!v)
             return '';
-        const m = v.match(/^(?:a\/|b\/)?(.+)$/);
-        return (m && m[1] ? m[1] : v).trim();
+        const head = v.split('\t')[0] ?? v;
+        const m = String(head).trim().match(/^(?:a\/|b\/)?(.+)$/);
+        return (m && m[1] ? m[1] : String(head)).trim();
     };
     for (const line of lines) {
         const diffMatch = line.match(/^diff --git\s+a\/(.+?)\s+b\/(.+)$/);
         if (diffMatch) {
             sawDiff = true;
             flush();
-            current = { path: extractPath(diffMatch[2]), kind: 'update', lines: [] };
+            current = {
+                path: extractPath(diffMatch[2]),
+                kind: 'update',
+                lines: [],
+                oldPath: extractPath(diffMatch[1]),
+                newPath: extractPath(diffMatch[2]),
+            };
             continue;
         }
         if (!current)
             continue;
+        if (line.startsWith('GIT binary patch') || line.startsWith('Binary files ')) {
+            current.binary = true;
+            continue;
+        }
         const delMatch = line.match(/^deleted file mode\s+/);
         const newMatch = line.match(/^new file mode\s+/);
         if (delMatch) {
@@ -118,7 +130,39 @@ const convertGitDiffToApplyPatch = (text) => {
             current.kind = 'add';
             continue;
         }
-        if (line.startsWith('--- ') || line.startsWith('+++ ') || line.startsWith('index ')) {
+        if (line.startsWith('rename from ')) {
+            const p = extractPath(line.slice('rename from '.length));
+            if (p)
+                current.oldPath = p;
+            continue;
+        }
+        if (line.startsWith('rename to ')) {
+            const p = extractPath(line.slice('rename to '.length));
+            if (p) {
+                current.newPath = p;
+                current.moveTo = p;
+            }
+            continue;
+        }
+        if (line.startsWith('--- ')) {
+            const p = extractPath(line.slice(4));
+            if (p) {
+                current.oldPath = p;
+                if (p === '/dev/null')
+                    current.kind = 'add';
+            }
+            continue;
+        }
+        if (line.startsWith('+++ ')) {
+            const p = extractPath(line.slice(4));
+            if (p) {
+                current.newPath = p;
+                if (p === '/dev/null')
+                    current.kind = 'delete';
+            }
+            continue;
+        }
+        if (line.startsWith('index ') || line.startsWith('similarity index ') || line.startsWith('dissimilarity index ')) {
             continue;
         }
         if (line.startsWith('@@')) {
@@ -133,21 +177,35 @@ const convertGitDiffToApplyPatch = (text) => {
     flush();
     if (!sawDiff || files.length === 0)
         return null;
+    if (files.some((f) => f.binary))
+        return null;
     const out = ['*** Begin Patch'];
     for (const file of files) {
+        const oldPath = typeof file.oldPath === 'string' ? file.oldPath : '';
+        const newPath = typeof file.newPath === 'string' ? file.newPath : '';
+        const resolvedPath = file.kind === 'add'
+            ? (newPath && newPath !== '/dev/null' ? newPath : file.path)
+            : file.kind === 'delete'
+                ? (oldPath && oldPath !== '/dev/null' ? oldPath : file.path)
+                : (file.moveTo && oldPath && oldPath !== '/dev/null'
+                    ? oldPath
+                    : (newPath && newPath !== '/dev/null' ? newPath : file.path));
         if (file.kind === 'delete') {
-            out.push(`*** Delete File: ${file.path}`);
+            out.push(`*** Delete File: ${resolvedPath}`);
             continue;
         }
         if (file.kind === 'add') {
-            out.push(`*** Add File: ${file.path}`);
+            out.push(`*** Add File: ${resolvedPath}`);
             for (const l of file.lines) {
                 if (l.startsWith('+'))
                     out.push(l);
             }
             continue;
         }
-        out.push(`*** Update File: ${file.path}`);
+        out.push(`*** Update File: ${resolvedPath}`);
+        if (file.moveTo && file.moveTo !== resolvedPath) {
+            out.push(`*** Move to: ${file.moveTo}`);
+        }
         out.push(...file.lines);
     }
     out.push('*** End Patch');
@@ -172,9 +230,18 @@ export const normalizeApplyPatchText = (raw) => {
         const minusMatch = text.match(/^---\s+(.*)$/m);
         const plusMatch = text.match(/^\+\+\+\s+(.*)$/m);
         if (minusMatch && plusMatch) {
-            const rawPlus = plusMatch[1] || '';
-            const pathMatch = rawPlus.match(/^(?:b\/)?(.+)$/);
-            const filePath = (pathMatch && pathMatch[1] ? pathMatch[1] : rawPlus).trim();
+            const rawMinus = (minusMatch[1] || '').split('\t')[0] || '';
+            const rawPlus = (plusMatch[1] || '').split('\t')[0] || '';
+            const normalizeHeaderPath = (value) => {
+                const v = String(value || '').trim();
+                if (!v)
+                    return '';
+                const m = v.match(/^(?:a\/|b\/)?(.+)$/);
+                return (m && m[1] ? m[1] : v).trim();
+            };
+            const minusPath = normalizeHeaderPath(rawMinus);
+            const plusPath = normalizeHeaderPath(rawPlus);
+            const filePath = plusPath === '/dev/null' ? minusPath : plusPath;
             if (filePath) {
                 const synthetic = `diff --git a/${filePath} b/${filePath}\n${text}`;
                 const converted = convertGitDiffToApplyPatch(synthetic);
@@ -304,6 +371,129 @@ const tryParseJson = (value) => {
         return undefined;
     }
 };
+const escapeUnescapedQuotesInJsonStrings = (input) => {
+    // Best-effort: when JSON is almost valid but contains unescaped `"` inside string values
+    // (e.g. JSX snippets like className="..."), escape quotes that are not followed by a
+    // valid JSON token delimiter. Deterministic; does not attempt to fix structural issues.
+    let out = '';
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i] ?? '';
+        if (!inString) {
+            if (ch === '"') {
+                inString = true;
+                escaped = false;
+            }
+            out += ch;
+            continue;
+        }
+        if (escaped) {
+            out += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\') {
+            out += ch;
+            escaped = true;
+            continue;
+        }
+        if (ch === '"') {
+            let j = i + 1;
+            while (j < input.length && /\s/.test(input[j] ?? ''))
+                j += 1;
+            const next = j < input.length ? input[j] : '';
+            if (next === '' || next === ':' || next === ',' || next === '}' || next === ']') {
+                inString = false;
+                out += ch;
+            }
+            else {
+                out += '\\"';
+            }
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+};
+const balanceJsonContainers = (input) => {
+    // Best-effort bracket/brace balancing for JSON-like strings.
+    // Only operates outside string literals. When encountering a closing token that doesn't
+    // match the current stack top, inserts the missing closer(s) to recover.
+    let out = '';
+    let inString = false;
+    let escaped = false;
+    const stack = [];
+    const closeFor = (open) => (open === '{' ? '}' : ']');
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i] ?? '';
+        if (inString) {
+            out += ch;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === '{' || ch === '[') {
+            stack.push(ch);
+            out += ch;
+            continue;
+        }
+        if (ch === '}' || ch === ']') {
+            const expectedOpen = ch === '}' ? '{' : '[';
+            while (stack.length && stack[stack.length - 1] !== expectedOpen) {
+                const open = stack.pop();
+                out += closeFor(open);
+            }
+            if (stack.length && stack[stack.length - 1] === expectedOpen) {
+                stack.pop();
+            }
+            out += ch;
+            continue;
+        }
+        out += ch;
+    }
+    while (stack.length) {
+        const open = stack.pop();
+        out += closeFor(open);
+    }
+    return out;
+};
+const tryParseJsonLoose = (value) => {
+    const parsed = tryParseJson(value);
+    if (parsed !== undefined)
+        return parsed;
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    if (!(trimmed.startsWith('{') || trimmed.startsWith('[')))
+        return undefined;
+    let repaired = escapeUnescapedQuotesInJsonStrings(trimmed);
+    repaired = balanceJsonContainers(repaired);
+    if (!repaired || repaired === trimmed)
+        return undefined;
+    try {
+        return JSON.parse(repaired);
+    }
+    catch {
+        return undefined;
+    }
+};
 const coerceChangesArray = (value) => {
     const parsed = tryParseJson(value);
     if (!parsed)
@@ -378,29 +568,77 @@ export function validateApplyPatchArgs(argsString, rawArgs) {
     // Raw patch text without JSON wrapper
     if (!looksJsonContainer && looksLikePatch(rawTrimmed)) {
         const patchText = normalizeApplyPatchText(rawTrimmed);
+        if (!patchText.includes('*** Begin Patch')) {
+            return { ok: false, reason: 'unsupported_patch_format' };
+        }
         return { ok: true, normalizedArgs: toJson({ patch: patchText, input: patchText }) };
     }
     const extractFromRecord = (rec) => {
         // Special case: argsString claims to be JSON but isn't parseable and raw text looks like a patch.
         if (looksJsonContainer && Object.keys(rec).length === 0 && looksLikePatch(rawTrimmed)) {
-            return { patchText: normalizeApplyPatchText(rawTrimmed) };
+            const patchText = normalizeApplyPatchText(rawTrimmed);
+            if (!patchText.includes('*** Begin Patch'))
+                return { failureReason: 'unsupported_patch_format' };
+            return { patchText };
         }
         const patchField = asString(rec.patch);
         if (patchField && looksLikePatch(patchField)) {
-            return { patchText: normalizeApplyPatchText(patchField) };
+            const patchText = normalizeApplyPatchText(patchField);
+            if (!patchText.includes('*** Begin Patch'))
+                return { failureReason: 'unsupported_patch_format' };
+            return { patchText };
         }
         const diffField = asString(rec.diff) ?? asString(rec.patchText) ?? asString(rec.body);
         if (diffField && looksLikePatch(diffField)) {
-            return { patchText: normalizeApplyPatchText(diffField) };
+            const patchText = normalizeApplyPatchText(diffField);
+            if (!patchText.includes('*** Begin Patch'))
+                return { failureReason: 'unsupported_patch_format' };
+            return { patchText };
         }
         const inputField = asString(rec.input);
         if (inputField && looksLikePatch(inputField)) {
-            return { patchText: normalizeApplyPatchText(inputField) };
+            const patchText = normalizeApplyPatchText(inputField);
+            if (!patchText.includes('*** Begin Patch'))
+                return { failureReason: 'unsupported_patch_format' };
+            return { patchText };
         }
         // Common shape: patch text stored under `instructions` (e.g. "*** Update File: ...").
         const instructionsField = asString(rec.instructions);
         if (instructionsField && looksLikePatch(instructionsField)) {
-            return { patchText: normalizeApplyPatchText(instructionsField) };
+            const patchText = normalizeApplyPatchText(instructionsField);
+            if (!patchText.includes('*** Begin Patch'))
+                return { failureReason: 'unsupported_patch_format' };
+            return { patchText };
+        }
+        // Common wrapper shape (seen in codex samples): { _raw: "{...json...}" }.
+        // `_raw` may contain either patch text or a JSON-encoded structured payload.
+        const rawEnvelope = asString(rec._raw);
+        if (rawEnvelope) {
+            const trimmed = rawEnvelope.trim();
+            if (looksLikePatch(trimmed)) {
+                const patchText = normalizeApplyPatchText(trimmed);
+                if (!patchText.includes('*** Begin Patch'))
+                    return { failureReason: 'unsupported_patch_format' };
+                return { patchText };
+            }
+            const parsed = tryParseJsonLoose(trimmed);
+            if (parsed && isRecord(parsed)) {
+                return extractFromRecord(parsed);
+            }
+            if (Array.isArray(parsed) && parsed.length > 0) {
+                const changesArray = parsed.filter((entry) => isRecord(entry));
+                if (changesArray.length && changesArray.some((c) => typeof c.kind === 'string')) {
+                    const payload = { changes: changesArray };
+                    try {
+                        return { patchText: buildStructuredPatch(payload) };
+                    }
+                    catch (error) {
+                        if (!(error instanceof StructuredApplyPatchError))
+                            throw error;
+                        return { failureReason: error.reason || 'structured_apply_patch_error' };
+                    }
+                }
+            }
         }
         const payload = coerceStructuredPayload(rec);
         if (payload) {
@@ -448,7 +686,13 @@ export function validateApplyPatchArgs(argsString, rawArgs) {
         }
     }
     else if (typeof rawArgs === 'string' && looksLikePatch(rawArgs)) {
-        patchText = normalizeApplyPatchText(rawArgs);
+        const normalized = normalizeApplyPatchText(rawArgs);
+        if (normalized.includes('*** Begin Patch')) {
+            patchText = normalized;
+        }
+        else {
+            failureReason = 'unsupported_patch_format';
+        }
     }
     if (!patchText) {
         if (failureReason)

package/dist/tools/tool-registry.d.ts

@@ -0,0 +1,8 @@
+export interface ToolValidationResult {
+    ok: boolean;
+    reason?: string;
+    warnings?: Array<Record<string, unknown>>;
+    normalizedArgs?: string;
+}
+export declare function getAllowedToolNames(): string[];
+export declare function validateToolCall(name: string, argsString: string): ToolValidationResult;

package/dist/tools/tool-registry.js

@@ -116,7 +116,8 @@ export function validateToolCall(name, argsString) {
                     originalArgs: typeof argsString === 'string' ? argsString : String(argsString ?? ''),
                     normalizedArgs: typeof argsString === 'string' ? argsString : String(argsString ?? ''),
                     validationError: reason,
-                    source: 'tool-registry.validateToolCall'
+                    source: 'tool-registry.validateToolCall',
+                    meta: { applyPatchToolMode: 'freeform' }
                 });
                 return { ok: false, reason };
             }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.795",
+  "version": "0.6.938",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "node scripts/bump-version.mjs && tsc -p tsconfig.json && node scripts/tools/copy-compat-profiles.mjs",
-    "build:dev": "node scripts/bump-version.mjs && tsc -p tsconfig.json && node scripts/tools/copy-compat-profiles.mjs",
+    "build": "node scripts/clean-dist.mjs && node scripts/bump-version.mjs && tsc -p tsconfig.json && node scripts/tools/copy-compat-profiles.mjs",
+    "build:dev": "node scripts/clean-dist.mjs && node scripts/bump-version.mjs && tsc -p tsconfig.json && node scripts/tools/copy-compat-profiles.mjs",
     "lint": "eslint --no-eslintrc -c .eslintrc.json src --ext .ts --no-cache",
     "lint:fix": "eslint --no-eslintrc -c .eslintrc.json src --ext .ts --no-cache --fix",
     "postbuild": "node scripts/tests/run-matrix-ci.mjs",
@@ -25,7 +25,7 @@
     "test:looprt:gemini": "npm run build && node scripts/tests/loop-rt-gemini.mjs",
     "replay:responses:chat-sse": "node scripts/exp3-responses-sse-to-chat-sse.mjs",
     "replay:responses:loop": "node scripts/exp4-responses-sse-loop.mjs",
-    "test:virtual-router": "npm run build:dev && node scripts/tests/virtual-router-dry-run.mjs && node scripts/tests/virtual-router-context.mjs",
+    "test:virtual-router": "npm run build:dev && node scripts/tests/virtual-router-prefer-autoclear.mjs && node scripts/tests/virtual-router-dry-run.mjs && node scripts/tests/virtual-router-context.mjs",
     "test:virtual-router-health": "npm run build:dev && node scripts/tests/virtual-router-health.mjs"
   },
   "dependencies": {

package/dist/conversion/compat/actions/apply-patch-format-fixer.js

@@ -1,233 +0,0 @@
-import { registerBridgeAction } from '../../shared/bridge-actions.js';
-import { ensureMessagesArray } from '../../shared/bridge-message-utils.js';
-/**
- * apply-patch-format-fixer.ts
- *
- * 专门处理 apply_patch 的格式错误修复，包括：
- * 1. 修复缺失 '*** Begin Patch' 包装的 raw diff
- * 2. 修复混用 git diff 头部的情况
- * 3. 修复 hunk 中缺少前缀的代码行
- *
- * 注意：仅修复格式问题，不修复上下文匹配问题
- */
-import { captureApplyPatchRegression } from '../../../tools/patch-regression-capturer.js';
-/**
- * 检测是否是裸 diff 格式（没有 Begin Patch 包装）
- */
-function isBareDiff(text) {
-    const trimmed = text.trim();
-    // 检测典型的 git diff 标记
-    const hasGitDiffMarkers = trimmed.startsWith('diff --git') ||
-        /^---\s+a\//.test(trimmed) ||
-        /^\+\+\+\s+b\//.test(trimmed) ||
-        /^@@\s+-\d+,\d+\s+\+\d+,\d+\s+@@/.test(trimmed);
-    // 确保不是标准的 apply_patch 格式
-    const hasApplyPatchMarkers = trimmed.includes('*** Begin Patch') ||
-        trimmed.includes('*** Update File:') ||
-        trimmed.includes('*** Add File:');
-    return hasGitDiffMarkers && !hasApplyPatchMarkers;
-}
-/**
- * 转换裸 diff 为 apply_patch 格式
- */
-function convertBareDiffToApplyPatch(diffText) {
-    const lines = diffText.replace(/\r\n/g, '\n').split('\n');
-    const patches = new Map();
-    let currentFile = '';
-    let currentHunk = [];
-    let inHunk = false;
-    for (const line of lines) {
-        // 检测文件头
-        const diffMatch = line.match(/^diff --git\s+a\/(.+?)\s+b\/(.+)$/);
-        if (diffMatch) {
-            // 保存上一个文件的 hunk
-            if (currentFile && currentHunk.length > 0) {
-                patches.set(currentFile, {
-                    header: `*** Update File: ${diffMatch[2]}`,
-                    hunk: [...currentHunk]
-                });
-            }
-            currentFile = diffMatch[2];
-            currentHunk = [];
-            inHunk = false;
-            continue;
-        }
-        // 检测 hunk 头
-        if (/^@@\s+-\d+/.test(line)) {
-            currentHunk.push(line);
-            inHunk = true;
-            continue;
-        }
-        // 在 hunk 中收集行
-        if (inHunk) {
-            // 确保每行都有正确的前缀
-            if (line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
-                currentHunk.push(line);
-            }
-            else if (line.trim() === '') {
-                currentHunk.push(' ');
-            }
-            else {
-                // 行缺少前缀，作为上下文行处理
-                currentHunk.push(' ' + line);
-            }
-        }
-    }
-    // 保存最后一个文件
-    if (currentFile && currentHunk.length > 0) {
-        patches.set(currentFile, {
-            header: `*** Update File: ${currentFile}`,
-            hunk: [...currentHunk]
-        });
-    }
-    if (patches.size === 0) {
-        // 如果无法解析，返回原始文本包装
-        return `*** Begin Patch\n${diffText}\n*** End Patch`;
-    }
-    // 构建 apply_patch 格式
-    const result = ['*** Begin Patch'];
-    for (const [file, { header, hunk }] of patches.entries()) {
-        result.push(header);
-        result.push(...hunk);
-    }
-    result.push('*** End Patch');
-    return result.join('\n');
-}
-/**
- * 修复 hunk 中缺少前缀的行
- */
-function fixHunkPrefixes(patchText) {
-    const lines = patchText.split('\n');
-    const result = [];
-    let inUpdateSection = false;
-    let afterHeader = false;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (line.startsWith('*** Begin Patch')) {
-            result.push(line);
-            continue;
-        }
-        if (line.startsWith('*** End Patch')) {
-            result.push(line);
-            inUpdateSection = false;
-            afterHeader = false;
-            continue;
-        }
-        if (line.startsWith('*** Update File:') || line.startsWith('*** Add File:') || line.startsWith('*** Delete File:')) {
-            result.push(line);
-            inUpdateSection = true;
-            afterHeader = true;
-            continue;
-        }
-        if (inUpdateSection) {
-            // 跳过紧跟在 header 后的空行
-            if (afterHeader && line.trim() === '') {
-                continue;
-            }
-            afterHeader = false;
-            // 检查是否是 hunk 行
-            if (/^@@\s+-\d+,\d+\s+\+\d+,\d+\s+@@/.test(line)) {
-                result.push(line);
-                continue;
-            }
-            // 检查是否已经有正确前缀
-            if (/^[+-]\s/.test(line) || /^\s/.test(line)) {
-                result.push(line);
-                continue;
-            }
-            // 行缺少前缀，作为上下文行处理
-            if (line.trim() === '') {
-                result.push(' ');
-            }
-            else {
-                result.push(' ' + line);
-            }
-        }
-        else {
-            result.push(line);
-        }
-    }
-    return result.join('\n');
-}
-/**
- * 主要的修复函数
- */
-function fixApplyPatchFormat(argsStr) {
-    try {
-        let args;
-        try {
-            args = JSON.parse(argsStr);
-        }
-        catch {
-            return { fixed: argsStr }; // 无法解析，返回原值
-        }
-        if (!args || typeof args !== 'object') {
-            return { fixed: argsStr };
-        }
-        let patch = args.patch || args.input || '';
-        if (typeof patch !== 'string') {
-            return { fixed: argsStr };
-        }
-        let modified = false;
-        let errorType;
-        // 修复 1: 裸 diff 缺少包装
-        if (isBareDiff(patch)) {
-            patch = convertBareDiffToApplyPatch(patch);
-            modified = true;
-            errorType = 'missing_begin_patch';
-        }
-        // 修复 2: hunk 中缺少前缀的行
-        const hasInvalidHunkLine = /"(.*?)".*Unexpected line found in update hunk/.test(patch);
-        if (hasInvalidHunkLine || !patch.match(/^@@/m)) {
-            const originalLength = patch.length;
-            patch = fixHunkPrefixes(patch);
-            if (patch.length !== originalLength) {
-                modified = true;
-                errorType = errorType || 'invalid_hunk_prefix';
-            }
-        }
-        if (modified) {
-            const newArgs = { ...args, patch, input: patch };
-            return { fixed: JSON.stringify(newArgs), errorType };
-        }
-        return { fixed: argsStr };
-    }
-    catch {
-        return { fixed: argsStr };
-    }
-}
-/**
- * Bridge action: 遍历消息，修复 apply_patch 格式问题
- */
-const fixApplyPatchFormatAction = (ctx) => {
-    const messages = ensureMessagesArray(ctx.state);
-    for (const message of messages) {
-        if (message.role !== 'assistant')
-            continue;
-        if (!Array.isArray(message.tool_calls))
-            continue;
-        for (const toolCall of message.tool_calls) {
-            if (toolCall.type !== 'function')
-                continue;
-            const fn = toolCall.function;
-            if (!fn || fn.name !== 'apply_patch')
-                continue;
-            const rawArgs = fn.arguments;
-            if (typeof rawArgs !== 'string')
-                continue;
-            const { fixed, errorType } = fixApplyPatchFormat(rawArgs);
-            if (fixed !== rawArgs) {
-                // 保存可修复样本
-                captureApplyPatchRegression({
-                    errorType: errorType || 'unknown_format_issue',
-                    originalArgs: rawArgs,
-                    fixerResult: fixed,
-                    source: 'compat.fix-apply-patch-format'
-                });
-                fn.arguments = fixed;
-                toolCall._format_fixed = true;
-            }
-        }
-    }
-};
-registerBridgeAction('compat.fix-apply-patch-format', fixApplyPatchFormatAction);