@jsonstudio/rcc 0.90.367 → 0.90.429

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

@@ -1,94 +0,0 @@
-/**
- * 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

@@ -1,11 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,30 +0,0 @@
-/**
- * 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

@@ -1,13 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

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

@@ -1,63 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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>;
-}