@jsonstudio/llms 0.4.2

package/dist/filters/special/request-tools-normalize.js

@@ -0,0 +1,140 @@
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+/**
+ * Normalize OpenAI tools definitions at the final request stage.
+ * - Switches shell parameters schema to TOON ({ toon: string }) when enabled and not heredoc.
+ * - Otherwise enforces { command: string | string[], workdir?: string } shape.
+ * - Best-effort; never throws.
+ */
+export class RequestOpenAIToolsNormalizeFilter {
+    name = 'request_openai_tools_normalize';
+    stage = 'request_finalize';
+    async apply(input) {
+        try {
+            const out = JSON.parse(JSON.stringify(input || {}));
+            const messages = Array.isArray(out.messages) ? out.messages : [];
+            const lastUser = [...messages].reverse().find((m) => m && m.role === 'user');
+            let lastText = '';
+            if (typeof lastUser?.content === 'string') {
+                lastText = lastUser.content;
+            }
+            else if (Array.isArray(lastUser?.content)) {
+                for (const p of lastUser.content) {
+                    if (p && typeof p.text === 'string' && p.text.trim()) {
+                        lastText = p.text;
+                        break;
+                    }
+                }
+            }
+            const looksHeredoc = /<<[-']?\w+/.test(lastText);
+            const toonEnv = String(process?.env?.RCC_TOON_ENABLE || process?.env?.ROUTECODEX_TOON_ENABLE || '').toLowerCase();
+            const toonEnabled = toonEnv ? !(toonEnv === '0' || toonEnv === 'false' || toonEnv === 'off') : true; // default ON
+            const tools = Array.isArray(out.tools) ? out.tools : [];
+            if (!tools.length) {
+                // No tools present: drop tool_choice to avoid provider-side validation errors
+                try {
+                    if ('tool_choice' in out)
+                        delete out.tool_choice;
+                }
+                catch { /* ignore */ }
+                return { ok: true, data: out };
+            }
+            let normalizedList = [];
+            try {
+                const mod = await import('../../conversion/shared/args-mapping.js');
+                const normalizeTools = mod?.normalizeTools;
+                if (typeof normalizeTools === 'function')
+                    normalizedList = normalizeTools(tools);
+            }
+            catch { /* passthrough on failure */ }
+            const finalTools = [];
+            const max = Math.max(tools.length, normalizedList.length);
+            for (let i = 0; i < max; i++) {
+                const src = tools[i];
+                const dst = normalizedList[i];
+                if (dst && isObject(dst) && isObject(dst.function) && typeof dst.function.name === 'string') {
+                    const fn = dst.function;
+                    // Ensure type and minimal function shape
+                    if (typeof dst.type !== 'string' || !String(dst.type).trim()) {
+                        dst.type = 'function';
+                    }
+                    // Ensure parameters object shape exists
+                    if (!isObject(fn.parameters)) {
+                        dst.function = { ...fn, parameters: { type: 'object', properties: {}, additionalProperties: true } };
+                    }
+                    // Ensure description string exists
+                    if (typeof fn.description !== 'string') {
+                        dst.function = { ...dst.function, description: '' };
+                    }
+                    // Drop non-standard strict flag to pass strict providers that reject unknown tool fields
+                    try {
+                        if ('strict' in dst.function)
+                            delete dst.function.strict;
+                    }
+                    catch { /* ignore */ }
+                    // Switch schema for 'shell' at unified shaping point
+                    try {
+                        const name = String(dst.function.name || '').toLowerCase();
+                        if (name === 'shell') {
+                            const wantToon = toonEnabled && !looksHeredoc;
+                            if (wantToon) {
+                                dst.function.parameters = {
+                                    type: 'object',
+                                    properties: {
+                                        toon: { type: 'string', description: 'TOON-encoded arguments (multi-line key: value). Example: command: bash -lc "echo ok"\\nworkdir: .' }
+                                    },
+                                    required: ['toon'],
+                                    additionalProperties: false
+                                };
+                                dst.function.description = 'Use TOON: put arguments into arguments.toon as multi-line key: value (e.g., command / workdir).';
+                            }
+                            else {
+                                dst.function.parameters = {
+                                    type: 'object',
+                                    properties: {
+                                        command: { oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }] },
+                                        workdir: { type: 'string' }
+                                    },
+                                    required: ['command'],
+                                    additionalProperties: false
+                                };
+                            }
+                        }
+                    }
+                    catch { /* ignore */ }
+                    finalTools.push(dst);
+                }
+                else if (src && isObject(src)) {
+                    // Fallback: minimally enforce required fields on raw src entries
+                    const item = JSON.parse(JSON.stringify(src));
+                    if (typeof item.type !== 'string' || !String(item.type).trim())
+                        item.type = 'function';
+                    if (!isObject(item.function))
+                        item.function = {};
+                    if (typeof item.function.name !== 'string')
+                        item.function.name = String(item.name || 'tool');
+                    if (!isObject(item.function.parameters))
+                        item.function.parameters = { type: 'object', properties: {}, additionalProperties: true };
+                    try {
+                        if ('strict' in item.function)
+                            delete item.function.strict;
+                    }
+                    catch { }
+                    finalTools.push(item);
+                }
+            }
+            out.tools = finalTools;
+            // If tools ended up empty, drop tool_choice to avoid upstream validation issues
+            try {
+                if (Array.isArray(out.tools) && out.tools.length === 0 && 'tool_choice' in out)
+                    delete out.tool_choice;
+            }
+            catch { /* ignore */ }
+            return { ok: true, data: out };
+        }
+        catch {
+            return { ok: true, data: input };
+        }
+    }
+}

package/dist/filters/special/response-finish-invariants.d.ts

@@ -0,0 +1,11 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * Ensure finish_reason and content invariants on response side:
+ * - If tool_calls present, finish_reason defaults to 'tool_calls'
+ * - If tool_calls present, message.content=null (Chat path)
+ */
+export declare class ResponseFinishInvariantsFilter implements Filter<JsonObject> {
+    readonly name = "response_finish_invariants";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject): FilterResult<JsonObject>;
+}

package/dist/filters/special/response-finish-invariants.js

@@ -0,0 +1,30 @@
+/**
+ * Ensure finish_reason and content invariants on response side:
+ * - If tool_calls present, finish_reason defaults to 'tool_calls'
+ * - If tool_calls present, message.content=null (Chat path)
+ */
+export class ResponseFinishInvariantsFilter {
+    name = 'response_finish_invariants';
+    stage = 'response_post';
+    apply(input) {
+        try {
+            const out = JSON.parse(JSON.stringify(input || {}));
+            const choices = Array.isArray(out.choices) ? out.choices : [];
+            for (const ch of choices) {
+                const msg = ch && ch.message ? ch.message : undefined;
+                const tcs = msg && Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+                if (tcs.length > 0) {
+                    if (ch.finish_reason == null)
+                        ch.finish_reason = 'tool_calls';
+                    if (msg && typeof msg === 'object')
+                        msg.content = null;
+                }
+            }
+            out.choices = choices;
+            return { ok: true, data: out };
+        }
+        catch {
+            return { ok: true, data: input };
+        }
+    }
+}

package/dist/filters/special/response-openai-to-responses-bridge.d.ts

@@ -0,0 +1,13 @@
+import type { Filter, FilterContext, JsonObject, FilterResult } from '../types.js';
+/**
+ * ResponseOpenAIToResponsesBridgeFilter
+ * - 将 OpenAI Chat 形状的响应桥接为 OpenAI Responses 形状
+ * - 与 Anthropic 并行：使用 filter 进行形状/协议转换（而非 endpoint 分支）
+ * - 阶段：response_post（在基础规范化之后执行）
+ */
+export declare class ResponseOpenAIToResponsesBridgeFilter implements Filter<JsonObject> {
+    readonly name = "response_openai_to_responses_bridge";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject, ctx: FilterContext): Promise<FilterResult<JsonObject>>;
+}
+export default ResponseOpenAIToResponsesBridgeFilter;

package/dist/filters/special/response-openai-to-responses-bridge.js

@@ -0,0 +1,24 @@
+import { buildResponsesPayloadFromChat } from '../../conversion/responses/responses-openai-bridge.js';
+/**
+ * ResponseOpenAIToResponsesBridgeFilter
+ * - 将 OpenAI Chat 形状的响应桥接为 OpenAI Responses 形状
+ * - 与 Anthropic 并行：使用 filter 进行形状/协议转换（而非 endpoint 分支）
+ * - 阶段：response_post（在基础规范化之后执行）
+ */
+export class ResponseOpenAIToResponsesBridgeFilter {
+    name = 'response_openai_to_responses_bridge';
+    stage = 'response_post';
+    async apply(input, ctx) {
+        try {
+            const requestId = ctx.requestId || `resp_${Date.now()}`;
+            const context = { requestId, endpoint: '/v1/responses', metadata: {} };
+            const bridged = buildResponsesPayloadFromChat(input, context);
+            return { ok: true, data: bridged };
+        }
+        catch {
+            // 桥接失败则保持原样（Fail Fast 由上层处理）
+            return { ok: true, data: input };
+        }
+    }
+}
+export default ResponseOpenAIToResponsesBridgeFilter;

package/dist/filters/special/response-tool-arguments-blacklist.d.ts

@@ -0,0 +1,12 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * ResponseToolArgumentsBlacklistFilter
+ * - Remove keys listed in ROUTECODEX_TOOLARGS_BLACKLIST from tool_calls[].function.arguments (after decode).
+ * - Default: empty blacklist (no-op). Enables incremental hardening without risking valid params.
+ * Stage: response_pre
+ */
+export declare class ResponseToolArgumentsBlacklistFilter implements Filter<JsonObject> {
+    readonly name = "response_tool_arguments_blacklist";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject): FilterResult<JsonObject>;
+}

package/dist/filters/special/response-tool-arguments-blacklist.js

@@ -0,0 +1,63 @@
+function isObject(v) { return !!v && typeof v === 'object' && !Array.isArray(v); }
+function parseJson(str) { try {
+    return JSON.parse(str);
+}
+catch {
+    return null;
+} }
+function getBlacklist() {
+    const env = String(process?.env?.ROUTECODEX_TOOLARGS_BLACKLIST || '').trim();
+    if (!env)
+        return [];
+    return env.split(',').map(s => s.trim()).filter(Boolean);
+}
+/**
+ * ResponseToolArgumentsBlacklistFilter
+ * - Remove keys listed in ROUTECODEX_TOOLARGS_BLACKLIST from tool_calls[].function.arguments (after decode).
+ * - Default: empty blacklist (no-op). Enables incremental hardening without risking valid params.
+ * Stage: response_pre
+ */
+export class ResponseToolArgumentsBlacklistFilter {
+    name = 'response_tool_arguments_blacklist';
+    stage = 'response_pre';
+    apply(input) {
+        const blacklist = getBlacklist();
+        if (blacklist.length === 0)
+            return { ok: true, data: input };
+        try {
+            const out = JSON.parse(JSON.stringify(input || {}));
+            const choices = Array.isArray(out.choices) ? out.choices : [];
+            for (const ch of choices) {
+                const msg = ch && ch.message ? ch.message : undefined;
+                const tcs = msg && Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+                for (const tc of tcs) {
+                    const fn = tc && tc.function ? tc.function : undefined;
+                    const argStr = fn && typeof fn.arguments === 'string' ? fn.arguments : undefined;
+                    if (!argStr)
+                        continue;
+                    const parsed = parseJson(argStr);
+                    if (!isObject(parsed))
+                        continue;
+                    let changed = false;
+                    for (const k of blacklist) {
+                        if (k in parsed) {
+                            delete parsed[k];
+                            changed = true;
+                        }
+                    }
+                    if (changed) {
+                        try {
+                            fn.arguments = JSON.stringify(parsed);
+                        }
+                        catch { /* keep original */ }
+                    }
+                }
+            }
+            out.choices = choices;
+            return { ok: true, data: out };
+        }
+        catch {
+            return { ok: true, data: input };
+        }
+    }
+}

package/dist/filters/special/response-tool-arguments-schema-converge.d.ts

@@ -0,0 +1,13 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * ResponseToolArgumentsSchemaConvergeFilter
+ * - If tool schemas are available on context (context.toolSchemas[name] = JSONSchema),
+ *   keep only keys defined in schema.properties for each tool call arguments.
+ * - Does not validate or coerce types; only converges keys to schema surface.
+ * - Stage: response_pre
+ */
+export declare class ResponseToolArgumentsSchemaConvergeFilter implements Filter<JsonObject> {
+    readonly name = "response_tool_arguments_schema_converge";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject, context?: FilterContext): FilterResult<JsonObject>;
+}

package/dist/filters/special/response-tool-arguments-schema-converge.js

@@ -0,0 +1,63 @@
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+function parseJson(str) {
+    try {
+        return JSON.parse(str);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * ResponseToolArgumentsSchemaConvergeFilter
+ * - If tool schemas are available on context (context.toolSchemas[name] = JSONSchema),
+ *   keep only keys defined in schema.properties for each tool call arguments.
+ * - Does not validate or coerce types; only converges keys to schema surface.
+ * - Stage: response_pre
+ */
+export class ResponseToolArgumentsSchemaConvergeFilter {
+    name = 'response_tool_arguments_schema_converge';
+    stage = 'response_pre';
+    apply(input, context) {
+        try {
+            const schemaMap = context?.toolSchemas;
+            if (!schemaMap || typeof schemaMap !== 'object')
+                return { ok: true, data: input };
+            const out = JSON.parse(JSON.stringify(input || {}));
+            const choices = Array.isArray(out.choices) ? out.choices : [];
+            for (const ch of choices) {
+                const msg = ch && ch.message ? ch.message : undefined;
+                const tcs = msg && Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+                for (const tc of tcs) {
+                    const fn = tc && tc.function ? tc.function : undefined;
+                    const name = fn && typeof fn.name === 'string' ? String(fn.name) : '';
+                    if (!name)
+                        continue;
+                    const schema = schemaMap[name];
+                    const props = schema && schema.properties && isObject(schema.properties) ? schema.properties : undefined;
+                    if (!props || !isObject(fn))
+                        continue;
+                    const argStr = typeof fn.arguments === 'string' ? fn.arguments : undefined;
+                    const parsed = argStr ? parseJson(argStr) : (isObject(fn.arguments) ? fn.arguments : null);
+                    if (!isObject(parsed))
+                        continue;
+                    const whitelisted = {};
+                    for (const k of Object.keys(props)) {
+                        if (k in parsed)
+                            whitelisted[k] = parsed[k];
+                    }
+                    try {
+                        fn.arguments = JSON.stringify(whitelisted);
+                    }
+                    catch { /* keep original */ }
+                }
+            }
+            out.choices = choices;
+            return { ok: true, data: out };
+        }
+        catch {
+            return { ok: true, data: input };
+        }
+    }
+}

package/dist/filters/special/response-tool-arguments-stringify.d.ts

@@ -0,0 +1,9 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * Ensure choices[*].message.tool_calls[].function.arguments is a JSON string.
+ */
+export declare class ResponseToolArgumentsStringifyFilter implements Filter<JsonObject> {
+    readonly name = "response_tool_arguments_stringify";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject): FilterResult<JsonObject>;
+}

package/dist/filters/special/response-tool-arguments-stringify.js

@@ -0,0 +1,134 @@
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+function repairFindMeta(s) {
+    // Minimal, idempotent repairs for common find expressions within a shell:
+    // - ensure -exec terminator is escaped exactly once: ;  =>  \\;
+    // - collapse multiple backslashes before ; to a single backslash
+    // - escape unescaped parentheses used in predicates: ( ) -> \\( \\)
+    try {
+        const hasFind = /(^|\s)find\s/.test(s);
+        if (!hasFind)
+            return s;
+        let out = s;
+        // Only escape semicolon not already escaped (negative lookbehind)
+        out = out.replace(/-exec([^;]*?)(?<!\\);/g, (_m, g1) => `-exec${g1} \\;`);
+        // Collapse multiple backslashes immediately before ; into a single backslash
+        out = out.replace(/-exec([^;]*?)\\+;/g, (_m, g1) => `-exec${g1} \\;`);
+        // Escape parentheses only when not already escaped
+        out = out.replace(/(?<!\\)\(/g, '\\(').replace(/(?<!\\)\)/g, '\\)');
+        return out;
+    }
+    catch {
+        return s;
+    }
+}
+function packShellCommand(cmd) {
+    // Normalize into ["bash","-lc","<single string>"] to support pipes, parens, -exec, etc.
+    const normalizeArray = (argv) => {
+        if (argv.length >= 2 && argv[0].toLowerCase() === 'bash' && argv[1] === '-lc') {
+            if (argv.length === 3)
+                return ['bash', '-lc', repairFindMeta(String(argv[2]))];
+            const tail = argv.slice(2).join(' ');
+            return ['bash', '-lc', repairFindMeta(tail)];
+        }
+        const joined = argv.join(' ');
+        return ['bash', '-lc', repairFindMeta(joined)];
+    };
+    try {
+        if (Array.isArray(cmd)) {
+            return normalizeArray(cmd.map((x) => String(x)));
+        }
+        if (typeof cmd === 'string') {
+            // If the string looks like a JSON array, attempt to parse before normalizing.
+            const trimmed = cmd.trim();
+            if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    if (Array.isArray(parsed)) {
+                        return normalizeArray(parsed.map((x) => String(x)));
+                    }
+                }
+                catch {
+                    // fall back to treating as plain string
+                }
+            }
+            return ['bash', '-lc', repairFindMeta(cmd)];
+        }
+    }
+    catch {
+        // fall through
+    }
+    return cmd;
+}
+/**
+ * Ensure choices[*].message.tool_calls[].function.arguments is a JSON string.
+ */
+export class ResponseToolArgumentsStringifyFilter {
+    name = 'response_tool_arguments_stringify';
+    stage = 'response_post';
+    apply(input) {
+        try {
+            const out = JSON.parse(JSON.stringify(input || {}));
+            const choices = Array.isArray(out.choices) ? out.choices : [];
+            for (const ch of choices) {
+                const msg = ch && ch.message ? ch.message : undefined;
+                const tcs = msg && Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+                for (const tc of tcs) {
+                    try {
+                        const fn = tc && tc.function ? tc.function : undefined;
+                        if (fn && typeof fn === 'object') {
+                            const name = typeof fn.name === 'string' ? String(fn.name).trim().toLowerCase() : '';
+                            const argIn = fn.arguments;
+                            let parsed = undefined;
+                            if (typeof argIn === 'string') {
+                                try {
+                                    parsed = JSON.parse(argIn);
+                                }
+                                catch {
+                                    parsed = undefined;
+                                }
+                            }
+                            else if (isObject(argIn)) {
+                                parsed = argIn;
+                            }
+                            if (name === 'shell' && isObject(parsed)) {
+                                const cmd = parsed.command;
+                                parsed.command = packShellCommand(cmd);
+                                try {
+                                    fn.arguments = JSON.stringify(parsed ?? {});
+                                }
+                                catch {
+                                    fn.arguments = '{}';
+                                }
+                            }
+                            else {
+                                if (typeof argIn !== 'string') {
+                                    try {
+                                        fn.arguments = JSON.stringify(argIn ?? {});
+                                    }
+                                    catch {
+                                        fn.arguments = '{}';
+                                    }
+                                }
+                            }
+                            // Ensure invariants per tool_call
+                            if (!tc.id || typeof tc.id !== 'string') {
+                                const basis = `${name || 'tool'}_${Math.random().toString(36).slice(2, 10)}`;
+                                tc.id = `call_${basis}`;
+                            }
+                            if (!tc.type)
+                                tc.type = 'function';
+                        }
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+            out.choices = choices;
+            return { ok: true, data: out };
+        }
+        catch {
+            return { ok: true, data: input };
+        }
+    }
+}

package/dist/filters/special/response-tool-arguments-toon-decode.d.ts

@@ -0,0 +1,10 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * Decode arguments.toon to standard JSON ({command, workdir?}) and map tool name 'shell_toon' → 'shell'.
+ * Stage: response_pre (before arguments stringify and invariants).
+ */
+export declare class ResponseToolArgumentsToonDecodeFilter implements Filter<JsonObject> {
+    readonly name = "response_tool_arguments_toon_decode";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject): FilterResult<JsonObject>;
+}

package/dist/filters/special/response-tool-arguments-toon-decode.js

@@ -0,0 +1,94 @@
+function envEnabled() {
+    // Default ON. Allow disabling via env RCC_TOON_ENABLE/ROUTECODEX_TOON_ENABLE = 0|false|off
+    const v = String(process?.env?.RCC_TOON_ENABLE || process?.env?.ROUTECODEX_TOON_ENABLE || '').toLowerCase();
+    if (!v)
+        return true;
+    return !(v === '0' || v === 'false' || v === 'off');
+}
+function isObject(v) { return !!v && typeof v === 'object' && !Array.isArray(v); }
+function decodeToonPairs(toon) {
+    try {
+        const out = {};
+        const lines = String(toon).split(/\r?\n/);
+        for (const raw of lines) {
+            const line = raw.trim();
+            if (!line)
+                continue;
+            const m = line.match(/^([A-Za-z0-9_\-]+)\s*:\s*(.*)$/);
+            if (!m)
+                return null; // fail fast for non key: value
+            const key = m[1];
+            const val = m[2];
+            out[key] = val;
+        }
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Decode arguments.toon to standard JSON ({command, workdir?}) and map tool name 'shell_toon' → 'shell'.
+ * Stage: response_pre (before arguments stringify and invariants).
+ */
+export class ResponseToolArgumentsToonDecodeFilter {
+    name = 'response_tool_arguments_toon_decode';
+    stage = 'response_pre';
+    apply(input) {
+        if (!envEnabled())
+            return { ok: true, data: input };
+        try {
+            const out = JSON.parse(JSON.stringify(input || {}));
+            const choices = Array.isArray(out.choices) ? out.choices : [];
+            for (const ch of choices) {
+                const msg = ch && ch.message ? ch.message : undefined;
+                const tcs = msg && Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+                for (const tc of tcs) {
+                    try {
+                        const fn = tc && tc.function ? tc.function : undefined;
+                        if (!fn || typeof fn !== 'object')
+                            continue;
+                        const argStr = fn.arguments;
+                        if (typeof argStr !== 'string')
+                            continue;
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(argStr);
+                        }
+                        catch {
+                            continue;
+                        }
+                        if (!isObject(parsed))
+                            continue;
+                        const toon = parsed.toon;
+                        if (typeof toon !== 'string' || !toon.trim())
+                            continue;
+                        const kv = decodeToonPairs(toon);
+                        if (!kv)
+                            continue; // keep original if decode fails
+                        const command = kv['command'];
+                        const workdir = kv['workdir'];
+                        if (typeof command === 'string' && command.trim()) {
+                            const merged = { command };
+                            if (typeof workdir === 'string' && workdir.trim())
+                                merged.workdir = workdir;
+                            try {
+                                fn.arguments = JSON.stringify(merged);
+                            }
+                            catch { /* keep original */ }
+                            if (typeof fn.name === 'string' && fn.name === 'shell_toon') {
+                                fn.name = 'shell';
+                            }
+                        }
+                    }
+                    catch { /* one tool_call decode failure → ignore */ }
+                }
+            }
+            out.choices = choices;
+            return { ok: true, data: out };
+        }
+        catch {
+            return { ok: true, data: input };
+        }
+    }
+}

package/dist/filters/special/response-tool-arguments-whitelist.d.ts

@@ -0,0 +1,11 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * Whitelist tool function arguments keys after decode to match schema (e.g., keep only 'command'/'workdir').
+ * Stage: response_pre. Runs after TOON decode and before stringify.
+ */
+export declare class ResponseToolArgumentsWhitelistFilter implements Filter<JsonObject> {
+    readonly name = "response_tool_arguments_whitelist";
+    readonly stage: FilterContext['stage'];
+    private getWhitelist;
+    apply(input: JsonObject, context?: FilterContext): FilterResult<JsonObject>;
+}