@jsonstudio/llms 0.6.567 → 0.6.586

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

@@ -0,0 +1,20 @@
+export type ToolCallLite = {
+    id?: string;
+    name: string;
+    args: string;
+};
+export declare function extractApplyPatchCallsFromText(text: string): ToolCallLite[] | null;
+export declare function extractExecuteBlocksFromText(text: string): ToolCallLite[] | null;
+export declare function extractXMLToolCallsFromText(text: string): ToolCallLite[] | null;
+/**
+ * 提取简单 XML 形式的工具调用块，例如：
+ *
+ *   <list_directory>
+ *     <path>/path/to/dir</path>
+ *     <recursive>false</recursive>
+ *   </list_directory>
+ *
+ * 仅针对已知工具名（目前为 list_directory），避免误伤普通 XML 文本。
+ */
+export declare function extractSimpleXmlToolsFromText(text: string): ToolCallLite[] | null;
+export declare function normalizeAssistantTextToToolCalls(message: Record<string, any>): Record<string, any>;

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([
@@ -10,16 +11,19 @@ const KNOWN_TOOLS = new Set([
     'view_image',
     'list_mcp_resources',
     'read_mcp_resource',
-    'list_mcp_resource_templates'
+    'list_mcp_resource_templates',
+    // 文件/目录类工具（CLI 侧已有约定；此处只做文本→tool_calls 收割）
+    'list_directory'
 ]);
 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']),
     read_mcp_resource: new Set(['server', 'uri', 'cursor']),
-    list_mcp_resource_templates: new Set(['server', 'cursor'])
+    list_mcp_resource_templates: new Set(['server', 'cursor']),
+    list_directory: new Set(['path', 'recursive'])
 };
 function normalizeKey(raw) {
     try {
@@ -70,40 +74,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;
@@ -290,6 +308,74 @@ export function extractXMLToolCallsFromText(text) {
         return null;
     }
 }
+/**
+ * 提取简单 XML 形式的工具调用块，例如：
+ *
+ *   <list_directory>
+ *     <path>/path/to/dir</path>
+ *     <recursive>false</recursive>
+ *   </list_directory>
+ *
+ * 仅针对已知工具名（目前为 list_directory），避免误伤普通 XML 文本。
+ */
+export function extractSimpleXmlToolsFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        const out = [];
+        const blockRe = /<\s*([A-Za-z0-9_.-]+)\s*>([\s\S]*?)<\/\s*\1\s*>/gi;
+        let bm;
+        while ((bm = blockRe.exec(text)) !== null) {
+            const rawName = (bm[1] || '').trim();
+            const lname = rawName.toLowerCase();
+            if (!lname || lname === 'tool_call')
+                continue;
+            // 目前仅支持 list_directory，后续按需扩展
+            if (lname !== 'list_directory')
+                continue;
+            const inner = bm[2] || '';
+            const args = {};
+            const argRe = /<\s*([A-Za-z0-9_]+)\s*>([\s\S]*?)<\/\s*\1\s*>/gi;
+            let am;
+            while ((am = argRe.exec(inner)) !== null) {
+                const key = normalizeKey((am[1] || '').trim());
+                if (!key)
+                    continue;
+                let rawVal = (am[2] || '').trim();
+                let v = rawVal;
+                if ((rawVal.startsWith('[') && rawVal.endsWith(']')) || (rawVal.startsWith('{') && rawVal.endsWith('}'))) {
+                    try {
+                        v = JSON.parse(rawVal);
+                    }
+                    catch {
+                        v = rawVal;
+                    }
+                }
+                else if (rawVal === 'true' || rawVal === 'false') {
+                    v = rawVal === 'true';
+                }
+                args[key] = v;
+            }
+            const filtered = filterArgsForTool(lname, args);
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify(filtered);
+            }
+            catch {
+                argsStr = '{}';
+            }
+            out.push({
+                id: `call_${Math.random().toString(36).slice(2, 10)}`,
+                name: lname,
+                args: argsStr
+            });
+        }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function normalizeAssistantTextToToolCalls(message) {
     if (!enabled())
         return message;
@@ -302,10 +388,11 @@ export function normalizeAssistantTextToToolCalls(message) {
         const text = typeof content === 'string' ? content : null;
         if (!text)
             return message;
-        // Order: xml-like tool_call → apply_patch → execute blocks
+        // Order: xml-like <tool_call> → apply_patch → execute blocks → 简单 XML 工具（list_directory 等）
         const calls = (extractXMLToolCallsFromText(text) ||
             extractApplyPatchCallsFromText(text) ||
-            extractExecuteBlocksFromText(text));
+            extractExecuteBlocksFromText(text) ||
+            extractSimpleXmlToolsFromText(text));
         if (calls && calls.length) {
             const toolCalls = calls.map((c) => ({ id: c.id, type: 'function', function: { name: c.name, arguments: c.args } }));
             const copy = { ...message };

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

@@ -134,42 +134,67 @@ function applyLocalToolGovernance(chatRequest, rawPayload) {
     };
 }
 function detectImageHint(messages, rawPayload) {
-    const candidates = [];
-    const collect = (value) => {
-        if (typeof value === 'string' && value) {
-            candidates.push(value);
-        }
+    const patterns = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg'];
+    const hasImageExt = (value) => {
+        if (typeof value !== 'string' || !value)
+            return false;
+        const lower = value.toLowerCase();
+        return patterns.some(ext => lower.includes(ext));
     };
-    if (Array.isArray(messages)) {
-        for (const msg of messages) {
-            if (msg && typeof msg === 'object') {
-                const text = msg.content;
-                if (typeof text === 'string') {
-                    collect(text);
-                }
-                else if (Array.isArray(text)) {
-                    for (const part of text) {
-                        if (part && typeof part === 'object') {
-                            collect(part.text);
-                        }
-                    }
+    const hasImageInMessage = (msg) => {
+        if (!msg || typeof msg !== 'object')
+            return false;
+        const m = msg;
+        const content = m.content;
+        if (typeof content === 'string') {
+            if (hasImageExt(content))
+                return true;
+        }
+        else if (Array.isArray(content)) {
+            for (const part of content) {
+                if (!part || typeof part !== 'object')
+                    continue;
+                const p = part;
+                const t = String(p.type || '').toLowerCase();
+                if (t.includes('image')) {
+                    return true;
                 }
+                if (hasImageExt(p.text))
+                    return true;
+                const imageUrl = typeof p.image_url === 'string'
+                    ? p.image_url
+                    : p.image_url && typeof p.image_url.url === 'string'
+                        ? p.image_url.url
+                        : typeof p.url === 'string'
+                            ? p.url
+                            : undefined;
+                if (hasImageExt(imageUrl))
+                    return true;
+                if (hasImageExt(p.path))
+                    return true;
             }
         }
-    }
-    if (rawPayload && typeof rawPayload === 'object') {
-        collect(rawPayload.content);
-    }
-    if (!candidates.length) {
         return false;
-    }
-    const patterns = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg'];
-    for (const text of candidates) {
-        const lower = text.toLowerCase();
-        for (const ext of patterns) {
-            if (lower.includes(ext)) {
+    };
+    // 仅考虑“当前这一轮”的用户输入是否包含图片链接或图片负载，避免因为历史上下文中曾经出现过图片而在后续轮次持续暴露 view_image。
+    if (Array.isArray(messages)) {
+        for (let i = messages.length - 1; i >= 0; i -= 1) {
+            const msg = messages[i];
+            if (!msg || typeof msg !== 'object')
+                continue;
+            const role = String(msg.role || '').toLowerCase();
+            if (role !== 'user')
+                continue;
+            if (hasImageInMessage(msg)) {
                 return true;
             }
+            break;
+        }
+    }
+    if (rawPayload && typeof rawPayload === 'object') {
+        const text = rawPayload.content;
+        if (hasImageExt(text)) {
+            return true;
         }
     }
     return false;
@@ -212,8 +237,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';