@jsonstudio/llms 0.6.473 → 0.6.568

package/dist/conversion/shared/streaming-text-extractor.d.ts

@@ -0,0 +1,25 @@
+export interface StreamingToolCall {
+    id?: string;
+    type: 'function';
+    function: {
+        name?: string;
+        arguments?: string;
+    };
+}
+export interface StreamingToolExtractorOptions {
+    idPrefix?: string;
+}
+export declare class StreamingTextToolExtractor {
+    private opts;
+    private buffer;
+    private idCounter;
+    constructor(opts?: StreamingToolExtractorOptions);
+    reset(): void;
+    feedText(text: string): StreamingToolCall[];
+    private genId;
+    private toToolCall;
+    private tryExtractStructuredBlocks;
+    private tryExtractFunctionExecuteBlocks;
+    private splitCommand;
+}
+export declare function createStreamingToolExtractor(opts?: StreamingToolExtractorOptions): StreamingTextToolExtractor;

package/dist/conversion/shared/streaming-text-extractor.js

@@ -1,6 +1,7 @@
 // Streaming textual tool intent extractor (对齐)
-// Detects <function=execute> blocks and unified diff patches
+// Detects <function=execute> blocks and structured apply_patch payloads
 // and converts them into OpenAI tool_calls incrementally.
+import { isStructuredApplyPatchPayload } from '../../tools/apply-patch-structured.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -8,22 +9,20 @@ export class StreamingTextToolExtractor {
     opts;
     buffer = '';
     idCounter = 0;
-    pendingPatch = { active: false, lines: [] };
     constructor(opts = {}) {
         this.opts = opts;
     }
     reset() {
         this.buffer = '';
         this.idCounter = 0;
-        this.pendingPatch = { active: false, lines: [] };
     }
     feedText(text) {
         const out = [];
         if (typeof text !== 'string' || !text)
             return out;
         this.buffer += text;
-        // 1) Unified diff apply_patch block detection (*** Begin Patch ... *** End Patch)
-        out.push(...this.tryExtractUnifiedDiffBlocks());
+        // 1) Structured apply_patch block detection (```json ... ```)
+        out.push(...this.tryExtractStructuredBlocks());
         // 2) <function=execute> compact blocks detection
         out.push(...this.tryExtractFunctionExecuteBlocks());
         return out;
@@ -42,42 +41,36 @@ export class StreamingTextToolExtractor {
         }
         return { id: this.genId(), type: 'function', function: { name, arguments: argStr } };
     }
-    tryExtractUnifiedDiffBlocks() {
+    tryExtractStructuredBlocks() {
         const out = [];
-        // Stream-friendly: if we see Begin Patch, start accumulating until End Patch
-        const beginIdx = this.buffer.indexOf('*** Begin Patch');
-        if (beginIdx >= 0) {
-            // Start patch if not already active
-            if (!this.pendingPatch.active) {
-                this.pendingPatch.active = true;
-                this.pendingPatch.lines = [];
-                this.pendingPatch.lines.push(this.buffer.slice(beginIdx));
-                // trim buffer before begin to reduce size
-                this.buffer = this.buffer.slice(beginIdx);
-            }
-            else {
-                // append new data
-                this.pendingPatch.lines.push(this.buffer);
-            }
-        }
-        if (this.pendingPatch.active) {
-            const joined = this.pendingPatch.lines.join('');
-            const endIdx = joined.indexOf('*** End Patch');
-            if (endIdx >= 0) {
-                const patchEnd = endIdx + '*** End Patch'.length;
-                const patchText = joined.slice(0, patchEnd);
-                out.push(this.toToolCall('apply_patch', { patch: patchText }));
-                // consume used part
-                const remainder = joined.slice(patchEnd);
-                this.pendingPatch = { active: false, lines: [] };
-                this.buffer = remainder;
-            }
-            else {
-                // keep accumulating, but limit memory
-                if (joined.length > 200000) {
-                    this.pendingPatch.lines = [joined.slice(-100000)];
+        let searchIdx = 0;
+        while (searchIdx < this.buffer.length) {
+            const startIdx = this.buffer.indexOf('```', searchIdx);
+            if (startIdx < 0)
+                break;
+            const headerEnd = this.buffer.indexOf('\n', startIdx + 3);
+            if (headerEnd < 0)
+                break;
+            const language = this.buffer.slice(startIdx + 3, headerEnd).trim().toLowerCase();
+            const endIdx = this.buffer.indexOf('```', headerEnd + 1);
+            if (endIdx < 0)
+                break;
+            const body = this.buffer.slice(headerEnd + 1, endIdx);
+            if (!language || language === 'json' || language === 'apply_patch' || language === 'toon') {
+                try {
+                    const parsed = JSON.parse(body);
+                    if (isStructuredApplyPatchPayload(parsed)) {
+                        out.push(this.toToolCall('apply_patch', parsed));
+                        this.buffer = this.buffer.slice(0, startIdx) + this.buffer.slice(endIdx + 3);
+                        searchIdx = 0;
+                        continue;
+                    }
+                }
+                catch {
+                    /* ignore parse errors */
                 }
             }
+            searchIdx = endIdx + 3;
         }
         return out;
     }

package/dist/conversion/shared/text-markup-normalizer.js

@@ -1,6 +1,7 @@
 // Normalize textual markup into OpenAI tool_calls shape.
 // Gated by RCC_TEXT_MARKUP_COMPAT=1 to avoid overreach.
 import { isImagePath } from './media.js';
+import { isStructuredApplyPatchPayload } from '../../tools/apply-patch-structured.js';
 // Strict allowlist for tool names and their argument keys to avoid picking up
 // stray markup or free-form text as JSON keys (reduces false positives).
 const KNOWN_TOOLS = new Set([
@@ -14,7 +15,7 @@ const KNOWN_TOOLS = new Set([
 ]);
 const ALLOWED_KEYS = {
     shell: new Set(['command', 'justification', 'timeout_ms', 'with_escalated_permissions', 'workdir']),
-    apply_patch: new Set(['patch']),
+    apply_patch: new Set(['file', 'instructions', 'changes']),
     update_plan: new Set(['explanation', 'plan']),
     view_image: new Set(['path']),
     list_mcp_resources: new Set(['server', 'cursor', 'filter', 'root']),
@@ -70,40 +71,54 @@ function enabled() {
     }
 }
 // 已移除所有 rcc.tool.v1 相关处理：不再识别或剥离 rcc 封装
-export function extractApplyPatchCallsFromText(text) {
+function extractStructuredApplyPatchPayloads(text) {
+    const payloads = [];
     try {
-        if (typeof text !== 'string' || !text)
-            return null;
-        const out = [];
-        const candidates = [];
-        const fenceRe = /```(?:patch)?\s*([\s\S]*?)\s*```/gi;
+        const fenceRe = /```(?:json|apply_patch|toon)?\s*([\s\S]*?)\s*```/gi;
         let fm;
         while ((fm = fenceRe.exec(text)) !== null) {
             const body = fm[1] || '';
-            if (/\*\*\*\s+Begin Patch[\s\S]*?\*\*\*\s+End Patch/.test(body))
-                candidates.push(body);
-        }
-        if (/\*\*\*\s+Begin Patch[\s\S]*?\*\*\*\s+End Patch/.test(text))
-            candidates.push(text);
-        const genId = () => `call_${Math.random().toString(36).slice(2, 10)}`;
-        for (const src of candidates) {
-            const pg = /\*\*\*\s+Begin Patch[\s\S]*?\*\*\*\s+End Patch/gm;
-            let pm;
-            while ((pm = pg.exec(src)) !== null) {
-                const patch = pm[0];
-                if (!patch || patch.length < 32)
-                    continue;
-                let argsStr = '{}';
-                try {
-                    argsStr = JSON.stringify({ patch });
+            try {
+                const parsed = JSON.parse(body);
+                if (isStructuredApplyPatchPayload(parsed)) {
+                    payloads.push(parsed);
                 }
-                catch {
-                    argsStr = '{"patch":""}';
+            }
+            catch { /* ignore invalid JSON */ }
+        }
+        if (!payloads.length && typeof text === 'string' && text.includes('"changes"')) {
+            try {
+                const parsed = JSON.parse(text);
+                if (isStructuredApplyPatchPayload(parsed)) {
+                    payloads.push(parsed);
                 }
-                out.push({ id: genId(), name: 'apply_patch', args: argsStr });
             }
+            catch { /* ignore */ }
         }
-        return out.length ? out : null;
+    }
+    catch { /* ignore */ }
+    return payloads;
+}
+export function extractApplyPatchCallsFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        const payloads = extractStructuredApplyPatchPayloads(text);
+        if (!payloads.length)
+            return null;
+        const out = [];
+        const genId = () => `call_${Math.random().toString(36).slice(2, 10)}`;
+        for (const payload of payloads) {
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify(payload);
+            }
+            catch {
+                argsStr = '{"changes":[]}';
+            }
+            out.push({ id: genId(), name: 'apply_patch', args: argsStr });
+        }
+        return out;
     }
     catch {
         return null;

package/dist/conversion/shared/tool-filter-pipeline.js

@@ -212,8 +212,9 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
     const { ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } = await import('../../filters/index.js');
     register(new ResponseToolTextCanonicalizeFilter());
     try {
-        const { ResponseToolArgumentsToonDecodeFilter, ResponseToolArgumentsBlacklistFilter, ResponseToolArgumentsSchemaConvergeFilter } = await import('../../filters/index.js');
+        const { ResponseToolArgumentsToonDecodeFilter, ResponseApplyPatchToonDecodeFilter, ResponseToolArgumentsBlacklistFilter, ResponseToolArgumentsSchemaConvergeFilter } = await import('../../filters/index.js');
         register(new ResponseToolArgumentsToonDecodeFilter());
+        register(new ResponseApplyPatchToonDecodeFilter());
         try {
             register(new ResponseToolArgumentsSchemaConvergeFilter());
         }

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

@@ -3,6 +3,7 @@
 // canonicalizer 按需加载（避免在请求侧仅注入时引入不必要的模块）
 // enforceChatBudget: 为避免在请求侧引入多余依赖，这里提供最小实现（保留形状，不裁剪）。
 import { augmentOpenAITools } from '../../guidance/index.js';
+import { validateToolCall } from '../../tools/tool-registry.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; }
@@ -173,8 +174,7 @@ export function processChatRequestTools(request, opts) {
                     continue;
                 const typeStr = String(t.type || '').toLowerCase();
                 const nameStr = typeof fn.name === 'string' ? String(fn.name).toLowerCase() : '';
-                const shouldPatch = typeStr === 'function' ||
-                    nameStr === 'apply_patch';
+                const shouldPatch = typeStr === 'function' || nameStr === 'apply_patch';
                 if (!shouldPatch)
                     continue;
                 if (!Object.prototype.hasOwnProperty.call(fn, 'parameters')) {
@@ -208,7 +208,8 @@ export function processChatRequestTools(request, opts) {
         catch { /* ignore */ }
         // 4) Enforce payload budget (context bytes) with minimal loss policy
         const modelId = typeof canonical?.model === 'string' ? String(canonical.model) : 'unknown';
-        return enforceChatBudget(canonical, modelId);
+        const budgeted = enforceChatBudget(canonical, modelId);
+        return normalizeApplyPatchToolCallsOnRequest(budgeted);
     }
     catch {
         return out;
@@ -219,6 +220,75 @@ 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) {
+    try {
+        const out = JSON.parse(JSON.stringify(chat));
+        const choices = Array.isArray(out?.choices) ? out.choices : [];
+        for (const ch of choices) {
+            const msg = ch && ch.message ? ch.message : undefined;
+            const tcs = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
+            if (!tcs.length)
+                continue;
+            for (const tc of tcs) {
+                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;
+                    }
+                }
+                catch {
+                    // best-effort per tool_call
+                }
+            }
+        }
+        return out;
+    }
+    catch {
+        return chat;
+    }
+}
+function normalizeApplyPatchToolCallsOnRequest(request) {
+    try {
+        const out = JSON.parse(JSON.stringify(request));
+        const messages = Array.isArray(out?.messages) ? out.messages : [];
+        for (const msg of messages) {
+            if (!msg || typeof msg !== 'object')
+                continue;
+            if (msg.role !== 'assistant')
+                continue;
+            const tcs = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+            if (!tcs.length)
+                continue;
+            for (const tc of tcs) {
+                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;
+                    }
+                }
+                catch {
+                    // best-effort per tool_call
+                }
+            }
+        }
+        return out;
+    }
+    catch {
+        return request;
+    }
+}
 function enhanceResponseToolArguments(chat) {
     try {
         const enable = String(process?.env?.RCC_TOOL_ENHANCE ?? '1').trim() !== '0';
@@ -336,7 +406,8 @@ export function processChatResponseTools(resp) {
     try {
         const { canonicalizeChatResponseTools } = require('./tool-canonicalizer.js');
         const canon = canonicalizeChatResponseTools(resp);
-        return enhanceResponseToolArguments(canon);
+        const withPatch = normalizeApplyPatchToolCallsOnResponse(canon);
+        return enhanceResponseToolArguments(withPatch);
     }
     catch {
         return resp;

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

@@ -1,8 +1,9 @@
 // Unified tool harvesting (对齐, single entry)
 // - First-time harvesting only (no late-stage repair)
-// - Handles textual markers (<function=execute>, unified diff)
+// - Handles textual markers (<function=execute>, structured apply_patch payloads)
 // - Handles structural shapes (function_call legacy, tool_calls)
 // - Normalizes arguments (single JSON string), sets finish_reason when applicable
+import { isStructuredApplyPatchPayload } from '../../tools/apply-patch-structured.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -48,17 +49,19 @@ function extractFromTextual(content, ctx) {
     const events = [];
     if (typeof content !== 'string' || !content)
         return events;
-    // 1) unified diff
-    const beginIdx = content.indexOf('*** Begin Patch');
-    const endIdx = content.indexOf('*** End Patch');
-    if (beginIdx >= 0 && endIdx > beginIdx) {
-        const patchText = content.slice(beginIdx, endIdx + '*** End Patch'.length);
-        const id = genId(ctx, 0);
-        const argStr = toJsonString({ patch: patchText });
-        events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { name: 'apply_patch' } }] });
-        const parts = chunkString(argStr, Math.max(32, Math.min(1024, ctx?.chunkSize || 256)));
-        for (const d of parts) {
-            events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { arguments: d } }] });
+    // 1) structured apply_patch payload
+    const structuredPayloads = extractStructuredApplyPatchPayloads(content);
+    if (structuredPayloads.length) {
+        let idx = 0;
+        for (const payload of structuredPayloads) {
+            const id = genId(ctx, idx);
+            const argStr = toJsonString(payload);
+            events.push({ tool_calls: [{ index: idx, id, type: 'function', function: { name: 'apply_patch' } }] });
+            const parts = chunkString(argStr, Math.max(32, Math.min(1024, ctx?.chunkSize || 256)));
+            for (const d of parts) {
+                events.push({ tool_calls: [{ index: idx, id, type: 'function', function: { arguments: d } }] });
+            }
+            idx += 1;
         }
         return events;
     }
@@ -157,6 +160,34 @@ function extractFromTextual(content, ctx) {
     catch { /* ignore textual tool_call parse errors */ }
     return events;
 }
+function extractStructuredApplyPatchPayloads(text) {
+    const payloads = [];
+    try {
+        const fenceRe = /```(?:json|apply_patch|toon)?\s*([\s\S]*?)\s*```/gi;
+        let fm;
+        while ((fm = fenceRe.exec(text)) !== null) {
+            const body = fm[1] || '';
+            try {
+                const parsed = JSON.parse(body);
+                if (isStructuredApplyPatchPayload(parsed)) {
+                    payloads.push(parsed);
+                }
+            }
+            catch { /* ignore invalid JSON */ }
+        }
+        if (!payloads.length && typeof text === 'string' && text.includes('"changes"')) {
+            try {
+                const parsed = JSON.parse(text);
+                if (isStructuredApplyPatchPayload(parsed)) {
+                    payloads.push(parsed);
+                }
+            }
+            catch { /* ignore */ }
+        }
+    }
+    catch { /* ignore */ }
+    return payloads;
+}
 function splitCommand(s) {
     try {
         const out = [];

package/dist/conversion/shared/tool-mapping.d.ts

@@ -13,6 +13,7 @@ export declare function stringifyArgs(args: unknown): string;
 export interface BridgeToolMapOptions {
     sanitizeName?: (raw: unknown) => string | undefined;
 }
+export declare function ensureApplyPatchSchema(seed?: Record<string, unknown>): Record<string, unknown>;
 export declare function bridgeToolToChatDefinition(rawTool: BridgeToolDefinition | Record<string, unknown> | null | undefined, options?: BridgeToolMapOptions): ChatToolDefinition | null;
 export declare function mapBridgeToolsToChat(rawTools: unknown, options?: BridgeToolMapOptions): ChatToolDefinition[] | undefined;
 export declare function chatToolToBridgeDefinition(rawTool: ChatToolDefinition | Record<string, unknown> | null | undefined, options?: BridgeToolMapOptions): BridgeToolDefinition | null;

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

@@ -25,24 +25,44 @@ function asSchema(value) {
     }
     return undefined;
 }
-function ensureApplyPatchSchema(seed) {
+export function ensureApplyPatchSchema(seed) {
     const schema = seed ? { ...seed } : {};
     schema.type = typeof schema.type === 'string' ? schema.type : 'object';
     const properties = isPlainObject(schema.properties) ? { ...schema.properties } : {};
-    properties.input = {
-        type: 'string',
-        description: 'Unified diff patch body between *** Begin Patch/*** End Patch.'
+    properties.file = { type: 'string', description: 'Optional default file path for all changes' };
+    properties.instructions = { type: 'string', description: 'Optional summary of the edit' };
+    properties.changes = {
+        type: 'array',
+        minItems: 1,
+        items: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['kind'],
+            properties: {
+                file: { type: 'string', description: 'Relative path for this change' },
+                kind: {
+                    type: 'string',
+                    description: 'insert_after | insert_before | replace | delete | create_file | delete_file'
+                },
+                anchor: { type: 'string', description: 'Context snippet for insert operations' },
+                target: { type: 'string', description: 'Snippet to replace/delete' },
+                lines: {
+                    description: 'New content for insert/replace/create operations',
+                    oneOf: [
+                        { type: 'string' },
+                        { type: 'array', items: { type: 'string' } }
+                    ]
+                },
+                use_anchor_indent: { type: 'boolean', description: 'Reuse indentation from the anchor snippet' }
+            }
+        }
     };
-    if (!properties.patch || typeof properties.patch !== 'object') {
-        properties.patch = {
-            type: 'string',
-            description: 'Alias of input for backwards compatibility.'
-        };
-    }
     schema.properties = properties;
-    const requiredList = Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === 'string') : [];
-    if (!requiredList.includes('input')) {
-        requiredList.push('input');
+    const requiredList = Array.isArray(schema.required)
+        ? schema.required.filter((entry) => typeof entry === 'string')
+        : [];
+    if (!requiredList.includes('changes')) {
+        requiredList.push('changes');
     }
     schema.required = requiredList;
     if (typeof schema.additionalProperties !== 'boolean') {

package/dist/filters/index.d.ts

@@ -12,6 +12,7 @@ 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

@@ -15,6 +15,7 @@ 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-toolcalls-stringify.js

@@ -27,12 +27,14 @@ export class RequestToolCallsStringifyFilter {
                             const fnName = typeof fn.name === 'string' ? fn.name.trim() : '';
                             // Case 1: non-string arguments → stringify directly
                             if (currentArgs !== undefined && typeof currentArgs !== 'string') {
+                                let argsJson = '{}';
                                 try {
-                                    fn.arguments = JSON.stringify(currentArgs ?? {});
+                                    argsJson = JSON.stringify(currentArgs ?? {});
                                 }
                                 catch {
-                                    fn.arguments = '{}';
+                                    argsJson = '{}';
                                 }
+                                fn.arguments = argsJson;
                                 tc.function = fn;
                                 continue;
                             }
@@ -61,9 +63,6 @@ export class RequestToolCallsStringifyFilter {
                                         if (fnName === 'shell') {
                                             fn.arguments = JSON.stringify({ command: currentArgs });
                                         }
-                                        else if (fnName === 'apply_patch') {
-                                            fn.arguments = JSON.stringify({ patch: currentArgs });
-                                        }
                                         else {
                                             fn.arguments = JSON.stringify({ input: currentArgs });
                                         }
@@ -74,56 +73,7 @@ export class RequestToolCallsStringifyFilter {
                                     tc.function = fn;
                                     continue;
                                 }
-                                // 已经是合法 JSON 的场景下，仅对特定工具做形状修复。
-                                if (parsedOk && fnName === 'apply_patch') {
-                                    try {
-                                        let obj = parsedValue;
-                                        // 1) 若整体是字符串，则视为补丁文本
-                                        if (typeof obj === 'string') {
-                                            obj = { patch: obj };
-                                        }
-                                        if (obj && typeof obj === 'object') {
-                                            const container = obj;
-                                            const rawPatch = container.patch;
-                                            const rawInput = container.input;
-                                            // 2) 若 patch 是形如 JSON 的字符串，尝试解包 {"input": "..."} 或 {"patch": "..."}
-                                            if (typeof rawPatch === 'string') {
-                                                const ptrim = rawPatch.trim();
-                                                if (ptrim.startsWith('{') && ptrim.endsWith('}')) {
-                                                    try {
-                                                        const inner = JSON.parse(ptrim);
-                                                        if (typeof inner.patch === 'string') {
-                                                            container.patch = inner.patch;
-                                                        }
-                                                        else if (typeof inner.input === 'string') {
-                                                            container.patch = inner.input;
-                                                        }
-                                                        else {
-                                                            container.patch = ptrim;
-                                                        }
-                                                    }
-                                                    catch {
-                                                        container.patch = rawPatch;
-                                                    }
-                                                }
-                                            }
-                                            else if (rawPatch === undefined && typeof rawInput === 'string') {
-                                                // 3) 若只有 input 字段，则复制一份到 patch，避免双层包装
-                                                container.patch = rawInput;
-                                            }
-                                            fn.arguments = JSON.stringify(container);
-                                            tc.function = fn;
-                                            continue;
-                                        }
-                                    }
-                                    catch {
-                                        // 回退到原始字符串形状
-                                        fn.arguments = trimmed;
-                                        tc.function = fn;
-                                        continue;
-                                    }
-                                }
-                                // 其它合法 JSON 场景保持原样
+                                // 合法 JSON 场景保持原样
                                 fn.arguments = trimmed;
                                 tc.function = fn;
                             }