@jsonstudio/llms 0.6.567 → 0.6.568

package/dist/conversion/shared/responses-output-builder.js

@@ -153,29 +153,50 @@ export function buildResponsesOutputFromChat(options) {
     };
 }
 function normalizeUsage(usageRaw) {
-    if (usageRaw && typeof usageRaw === 'object') {
-        const usage = { ...usageRaw };
-        if (usage.input_tokens != null && usage.prompt_tokens == null) {
-            usage.prompt_tokens = usage.input_tokens;
-        }
-        if (usage.output_tokens != null && usage.completion_tokens == null) {
-            usage.completion_tokens = usage.output_tokens;
-        }
-        if (usage.prompt_tokens != null && usage.completion_tokens != null && usage.total_tokens == null) {
-            const total = Number(usage.prompt_tokens) + Number(usage.completion_tokens);
-            if (!Number.isNaN(total))
-                usage.total_tokens = total;
-        }
-        try {
-            delete usage.input_tokens;
-            delete usage.output_tokens;
-        }
-        catch {
-            /* ignore */
+    if (!usageRaw || typeof usageRaw !== 'object') {
+        return usageRaw;
+    }
+    const usage = { ...usageRaw };
+    // 统一 Responses 与 Chat 两种 usage 形态：
+    // - Responses: input_tokens / output_tokens / total_tokens
+    // - Chat: prompt_tokens / completion_tokens / total_tokens
+    const inputTokens = typeof usage.input_tokens === 'number'
+        ? usage.input_tokens
+        : typeof usage.prompt_tokens === 'number'
+            ? usage.prompt_tokens
+            : undefined;
+    const outputTokens = typeof usage.output_tokens === 'number'
+        ? usage.output_tokens
+        : typeof usage.completion_tokens === 'number'
+            ? usage.completion_tokens
+            : undefined;
+    let totalTokens = typeof usage.total_tokens === 'number'
+        ? usage.total_tokens
+        : undefined;
+    if (totalTokens === undefined && inputTokens !== undefined && outputTokens !== undefined) {
+        const total = Number(inputTokens) + Number(outputTokens);
+        if (!Number.isNaN(total)) {
+            totalTokens = total;
         }
-        return usage;
     }
-    return usageRaw;
+    // Responses 规范字段：input_tokens / output_tokens / total_tokens
+    if (inputTokens !== undefined) {
+        usage.input_tokens = inputTokens;
+    }
+    if (outputTokens !== undefined) {
+        usage.output_tokens = outputTokens;
+    }
+    if (totalTokens !== undefined) {
+        usage.total_tokens = totalTokens;
+    }
+    // 为了兼容内部统计逻辑，保留 prompt_tokens / completion_tokens 映射（如果原本没有）
+    if (usage.prompt_tokens == null && inputTokens !== undefined) {
+        usage.prompt_tokens = inputTokens;
+    }
+    if (usage.completion_tokens == null && outputTokens !== undefined) {
+        usage.completion_tokens = outputTokens;
+    }
+    return usage;
 }
 function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, baseCount, offset) {
     try {

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-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,30 +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 } : {};
-    delete properties.input;
-    delete properties.patch;
-    properties.patch = {
-        type: 'string',
-        description: 'Unified diff patch text. The first line MUST be exactly "*** Begin Patch", followed by one or more file sections starting with ' +
-            '"*** Add File: {path}", "*** Update File: {path}", or "*** Delete File: {path}", using hunks with lines prefixed by " ", "+", or "-". ' +
-            'The last non-empty line MUST be exactly "*** End Patch". Git-style headers like "--- a/file" / "+++ b/file" and merge markers ' +
-            '"<<<<<<<", "=======", ">>>>>>>" are NOT allowed.'
+    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 (!isPlainObject(properties.paths)) {
-        properties.paths = {
-            type: 'array',
-            description: 'Optional explicit list of relative file paths that the patch touches. Each entry must be a relative workspace path (packages/foo/file.ts).',
-            items: { type: 'string' }
-        };
-    }
     schema.properties = properties;
-    const requiredList = Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === 'string') : [];
-    if (!requiredList.includes('patch')) {
-        requiredList.push('patch');
+    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-tools-normalize.js

@@ -1,3 +1,4 @@
+import { appendApplyPatchReminder, buildShellDescription, hasApplyPatchToolDeclared, isShellToolName, normalizeToolName } from '../../tools/tool-description-utils.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -31,6 +32,7 @@ export class RequestOpenAIToolsNormalizeFilter {
             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) {
                 // No tools present: drop tool_choice to avoid provider-side validation errors
                 try {
@@ -75,19 +77,25 @@ export class RequestOpenAIToolsNormalizeFilter {
                     catch { /* ignore */ }
                     // Switch schema for specific built-in tools at unified shaping point
                     try {
-                        const name = String(dst.function.name || '').toLowerCase();
-                        if (name === 'shell') {
+                        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: .' }
+                                        toon: {
+                                            type: 'string',
+                                            description: 'TOON-encoded arguments (multi-line key: value). Example: command: bash -lc "echo ok"\\nworkdir: .'
+                                        }
                                     },
                                     required: ['toon'],
                                     additionalProperties: false
                                 };
-                                dst.function.description = 'Use TOON: put arguments into arguments.toon as multi-line key: value (e.g., command / workdir).';
+                                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 = {
@@ -99,6 +107,8 @@ export class RequestOpenAIToolsNormalizeFilter {
                                     required: ['command'],
                                     additionalProperties: false
                                 };
+                                const label = rawToolName && rawToolName.trim().length > 0 ? rawToolName.trim() : 'shell';
+                                dst.function.description = buildShellDescription(label, hasApplyPatchTool);
                             }
                         }
                     }

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

@@ -0,0 +1,23 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * Response-side apply_patch arguments 规范化（TOON + 结构化 JSON → 统一 diff 文本）。
+ *
+ * 目标：
+ * - 对上游模型：仍然可以使用结构化 JSON（changes 数组）或 toon 字段输出补丁；
+ * - 对下游客户端（Codex CLI 等）：始终看到 { input, patch } 形式的统一 diff 文本，
+ *   与本地 apply_patch 工具的旧语义完全一致（对客户端透明）。
+ *
+ * 支持两种入参形态（arguments 反序列化后）：
+ * 1) { toon: "<*** Begin Patch ... *** End Patch>" }
+ * 2) StructuredApplyPatchPayload（含 changes 数组等字段）
+ *
+ * 输出：
+ * - arguments 统一替换为 JSON 字符串：{ input: patchText, patch: patchText }。
+ *
+ * Stage: response_pre（在 arguments stringify 之前运行）。
+ */
+export declare class ResponseApplyPatchToonDecodeFilter implements Filter<JsonObject> {
+    readonly name = "response_apply_patch_toon_decode";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject): FilterResult<JsonObject>;
+}