@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/filters/special/request-toolcalls-stringify.js

@@ -0,0 +1,94 @@
+/**
+ * Ensure assistant.tool_calls[].function.arguments is a JSON string containing valid JSON.
+ * - If arguments is not a string, JSON.stringify it.
+ * - If arguments is a string but not parseable as JSON, wrap it into a JSON object so the
+ *   provider always receives syntactically valid JSON (e.g. {"input": "<raw>"}).
+ * Also set assistant.content=null when tool_calls exist (request-side invariant).
+ */
+export class RequestToolCallsStringifyFilter {
+    name = 'request_toolcalls_stringify';
+    stage = 'request_post';
+    apply(input) {
+        try {
+            const out = JSON.parse(JSON.stringify(input || {}));
+            const msgs = Array.isArray(out.messages) ? out.messages : [];
+            for (const m of msgs) {
+                if (!m || typeof m !== 'object')
+                    continue;
+                if (m.role === 'assistant' && Array.isArray(m.tool_calls) && m.tool_calls.length) {
+                    try {
+                        for (const tc of m.tool_calls) {
+                            if (!tc || typeof tc !== 'object')
+                                continue;
+                            const fn = tc.function || {};
+                            if (!fn || typeof fn !== 'object')
+                                continue;
+                            const currentArgs = fn.arguments;
+                            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 {
+                                    argsJson = JSON.stringify(currentArgs ?? {});
+                                }
+                                catch {
+                                    argsJson = '{}';
+                                }
+                                fn.arguments = argsJson;
+                                tc.function = fn;
+                                continue;
+                            }
+                            // Case 2: string arguments → ensure it is valid JSON
+                            if (typeof currentArgs === 'string') {
+                                const trimmed = currentArgs.trim();
+                                if (trimmed.length === 0) {
+                                    fn.arguments = '{}';
+                                    tc.function = fn;
+                                    continue;
+                                }
+                                let parsedOk = false;
+                                let parsedValue = undefined;
+                                try {
+                                    parsedValue = JSON.parse(trimmed);
+                                    parsedOk = true;
+                                }
+                                catch {
+                                    parsedOk = false;
+                                }
+                                if (!parsedOk) {
+                                    // Wrap raw string into a JSON object to keep payload syntactically valid.
+                                    // For shell, align with GLM/统一工具治理约定，优先映射到 { command }，
+                                    // 其余模型仍使用 { input } 形式。
+                                    try {
+                                        if (fnName === 'shell') {
+                                            fn.arguments = JSON.stringify({ command: currentArgs });
+                                        }
+                                        else {
+                                            fn.arguments = JSON.stringify({ input: currentArgs });
+                                        }
+                                    }
+                                    catch {
+                                        fn.arguments = '{}';
+                                    }
+                                    tc.function = fn;
+                                    continue;
+                                }
+                                // 合法 JSON 场景保持原样
+                                fn.arguments = trimmed;
+                                tc.function = fn;
+                            }
+                        }
+                    }
+                    catch { /* ignore per-item errors */ }
+                    // Invariant: assistant with tool_calls should use content=null
+                    m.content = null;
+                }
+            }
+            out.messages = msgs;
+            return { ok: true, data: out };
+        }
+        catch {
+            return { ok: true, data: input };
+        }
+    }
+}

package/vendor/llmswitch-core/dist/filters/special/request-tools-normalize.d.ts

@@ -0,0 +1,11 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * Normalize OpenAI tools definitions at the final request stage.
+ * - Enforces { command: string | string[], workdir?: string } shape for shell-like tools.
+ * - Best-effort; never throws.
+ */
+export declare class RequestOpenAIToolsNormalizeFilter implements Filter<JsonObject> {
+    readonly name = "request_openai_tools_normalize";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject): Promise<FilterResult<JsonObject>>;
+}

package/vendor/llmswitch-core/dist/filters/special/request-tools-normalize.js

@@ -0,0 +1,114 @@
+import { buildShellDescription, hasApplyPatchToolDeclared, isShellToolName } from '../../tools/tool-description-utils.js';
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+/**
+ * Normalize OpenAI tools definitions at the final request stage.
+ * - Enforces { command: string | string[], workdir?: string } shape for shell-like tools.
+ * - 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 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 {
+                    if ('tool_choice' in out)
+                        delete out.tool_choice;
+                }
+                catch { /* ignore */ }
+                return { ok: true, data: out };
+            }
+            let normalizedList = [];
+            try {
+                const mod = await import('../../conversion/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 specific built-in tools at unified shaping point
+                    try {
+                        const rawToolName = String(dst.function.name || '');
+                        const isShell = isShellToolName(rawToolName);
+                        if (isShell) {
+                            dst.function.name = 'exec_command';
+                            dst.function.parameters = {
+                                type: 'object',
+                                properties: {
+                                    cmd: { type: 'string' },
+                                    workdir: { type: 'string' }
+                                },
+                                required: ['cmd'],
+                                additionalProperties: false
+                            };
+                            const label = rawToolName && rawToolName.trim().length > 0 ? rawToolName.trim() : 'exec_command';
+                            dst.function.description = buildShellDescription(label, hasApplyPatchTool);
+                        }
+                    }
+                    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 { /* ignore */ }
+                    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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/dist/filters/special/response-tool-arguments-stringify.js

@@ -0,0 +1,132 @@
+import { repairFindMeta } from '../../conversion/shared/tooling.js';
+import { normalizeExecCommandArgs } from '../../tools/exec-command/normalize.js';
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+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 (name === 'exec_command' && isObject(parsed)) {
+                                const normalized = normalizeExecCommandArgs(parsed);
+                                const next = normalized.ok ? normalized.normalized : parsed;
+                                try {
+                                    fn.arguments = JSON.stringify(next ?? {});
+                                }
+                                catch {
+                                    fn.arguments = '{}';
+                                }
+                            }
+                            else if ((name === 'shell_command' || name === 'bash') && isObject(parsed)) {
+                                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/vendor/llmswitch-core/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>;
+}