@jsonstudio/rcc 0.85.9 → 0.89.164

package/node_modules/@jsonstudio/llms/dist/conversion/shared/chat-request-filters.js

@@ -0,0 +1,178 @@
+import { FilterEngine, RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter } from '../../filters/index.js';
+import { normalizeChatRequest } from '../index.js';
+import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
+import { createSnapshotWriter } from './snapshot-utils.js';
+/**
+ * 统一的 Chat 请求侧过滤链路。
+ *
+ * 目标：
+ * - 所有进入 Provider 的 Chat 形状请求（无论入口为 /v1/chat、/v1/responses 还是 /v1/messages），
+ *   都在这里走同一套工具治理与参数标准化逻辑。
+ */
+export async function runStandardChatRequestFilters(chatRequest, profile, context) {
+    const existingMetadata = context.metadata ?? {};
+    if (!context.metadata) {
+        context.metadata = existingMetadata;
+    }
+    const inboundStreamFromContext = typeof existingMetadata.inboundStream === 'boolean' ? existingMetadata.inboundStream : undefined;
+    const inboundStreamDetected = chatRequest && typeof chatRequest === 'object' && chatRequest.stream === true;
+    const normalizedInboundStream = inboundStreamFromContext ?? inboundStreamDetected ?? undefined;
+    if (typeof normalizedInboundStream === 'boolean') {
+        existingMetadata.inboundStream = normalizedInboundStream;
+    }
+    const requestId = context.requestId ?? `req_${Date.now()}`;
+    const modelId = (chatRequest && typeof chatRequest === 'object' && typeof chatRequest.model === 'string')
+        ? String(chatRequest.model)
+        : 'unknown';
+    const endpoint = context.entryEndpoint ||
+        context.endpoint ||
+        '/v1/chat/completions';
+    const snapshot = createSnapshotWriter({
+        requestId,
+        endpoint,
+        folderHint: 'openai-chat'
+    });
+    const snapshotStage = (stage, payload) => {
+        if (!snapshot)
+            return;
+        snapshot(stage, payload);
+    };
+    snapshotStage('req_process_filters_input', chatRequest);
+    const reqCtxBase = {
+        requestId,
+        model: modelId,
+        endpoint,
+        profile: profile.outgoingProtocol,
+        debug: { emit: () => { } }
+    };
+    const engine = new FilterEngine();
+    const incomingProtocol = (profile.incomingProtocol || '').toLowerCase();
+    const entryEndpointLower = (endpoint || '').toLowerCase();
+    const originalToolCount = (chatRequest && typeof chatRequest === 'object' && Array.isArray(chatRequest.tools))
+        ? chatRequest.tools.length
+        : 0;
+    const isAnthropicProfile = incomingProtocol === 'anthropic-messages' ||
+        entryEndpointLower.includes('/v1/messages');
+    const skipAutoToolInjection = isAnthropicProfile && originalToolCount === 0;
+    // Request-side initial filters（与 openai-openai-codec 保持一致）
+    if (!skipAutoToolInjection) {
+        try {
+            const { RequestToolListFilter } = await import('../../filters/index.js');
+            engine.registerFilter(new RequestToolListFilter());
+        }
+        catch {
+            // 可选过滤器，失败时保持向后兼容
+        }
+    }
+    engine.registerFilter(new RequestToolCallsStringifyFilter());
+    engine.registerFilter(new RequestToolChoicePolicyFilter());
+    // FieldMap：保持与 Chat 入口一致，使用 openai-openai.fieldmap.json
+    try {
+        const cfg = await loadFieldMapConfig('openai-openai.fieldmap.json');
+        if (cfg)
+            engine.setFieldMap(cfg);
+        engine.registerTransform('stringifyJson', (v) => (typeof v === 'string'
+            ? v
+            : (() => {
+                try {
+                    return JSON.stringify(v ?? {});
+                }
+                catch {
+                    return '{}';
+                }
+            })()));
+    }
+    catch {
+        // best-effort：缺少 fieldmap 时保持原样
+    }
+    let staged = await engine.run('request_pre', chatRequest, reqCtxBase);
+    snapshotStage('req_process_filters_request_pre', staged);
+    staged = await engine.run('request_map', staged, reqCtxBase);
+    snapshotStage('req_process_filters_request_map', staged);
+    staged = await engine.run('request_post', staged, reqCtxBase);
+    snapshotStage('req_process_filters_request_post', staged);
+    if (skipAutoToolInjection && staged && typeof staged === 'object') {
+        if (!Array.isArray(staged.tools)) {
+            staged.tools = [];
+        }
+        staged.__rcc_disable_mcp_tools = true;
+    }
+    // 归一化 Chat 请求后再做最终工具治理
+    let normalized = normalizeChatRequest(staged);
+    snapshotStage('req_process_filters_normalized', normalized);
+    try {
+        const { RequestOpenAIToolsNormalizeFilter, ToolPostConstraintsFilter } = await import('../../filters/index.js');
+        engine.registerFilter(new RequestOpenAIToolsNormalizeFilter());
+        // 工具治理后的最后约束层：默认配置为空，由宿主/配置系统按 profile/provider/modelId 决定是否启用具体规则。
+        engine.registerFilter(new ToolPostConstraintsFilter('request_finalize'));
+        normalized = await engine.run('request_finalize', normalized, reqCtxBase);
+        snapshotStage('req_process_filters_request_finalize', normalized);
+    }
+    catch {
+        // 可选工具归一过滤器，失败时保持已归一化结果
+    }
+    const preserveStreamField = profile.incomingProtocol === 'openai-chat' && profile.outgoingProtocol === 'openai-chat';
+    const pruned = pruneChatRequestPayload(normalized, { preserveStreamField });
+    snapshotStage('req_process_filters_output', pruned);
+    return pruned;
+}
+function pruneChatRequestPayload(chatRequest, options) {
+    if (!chatRequest || typeof chatRequest !== 'object')
+        return chatRequest;
+    const stripped = { ...chatRequest };
+    stripSentinelKeys(stripped);
+    if ('originalStream' in stripped) {
+        delete stripped.originalStream;
+    }
+    if ('_originalStreamOptions' in stripped) {
+        delete stripped._originalStreamOptions;
+    }
+    if ('metadata' in stripped) {
+        delete stripped.metadata;
+    }
+    if (!options?.preserveStreamField && 'stream' in stripped && stripped.stream !== true) {
+        delete stripped.stream;
+    }
+    if (Array.isArray(stripped.messages)) {
+        stripped.messages = stripped.messages.map((message) => sanitizeMessageEntry(message));
+    }
+    return stripped;
+}
+function sanitizeMessageEntry(message) {
+    if (!message || typeof message !== 'object')
+        return message;
+    const clone = { ...message };
+    if (Array.isArray(clone.tool_calls) && clone.tool_calls.length) {
+        clone.tool_calls = clone.tool_calls.map((call) => sanitizeToolCallEntry(call));
+    }
+    if (clone.role === 'tool') {
+        if (typeof clone.tool_call_id !== 'string' && typeof clone.call_id === 'string') {
+            clone.tool_call_id = clone.call_id;
+        }
+        if ('id' in clone) {
+            delete clone.id;
+        }
+    }
+    if ('call_id' in clone) {
+        delete clone.call_id;
+    }
+    return clone;
+}
+function sanitizeToolCallEntry(call) {
+    if (!call || typeof call !== 'object')
+        return call;
+    const clone = { ...call };
+    delete clone.call_id;
+    delete clone.tool_call_id;
+    if (clone.function && typeof clone.function === 'object') {
+        clone.function = { ...clone.function };
+    }
+    return clone;
+}
+function stripSentinelKeys(record) {
+    Object.keys(record).forEach((key) => {
+        if (key.startsWith('__rcc_')) {
+            delete record[key];
+        }
+    });
+}

package/node_modules/@jsonstudio/llms/dist/conversion/shared/gemini-tool-utils.d.ts

@@ -0,0 +1,5 @@
+import type { BridgeToolDefinition } from './bridge-message-types.js';
+import type { MissingField } from '../hub/types/chat-envelope.js';
+import type { JsonValue, JsonObject } from '../hub/types/json.js';
+export declare function prepareGeminiToolsForBridge(rawTools: JsonValue | undefined, missing?: MissingField[]): BridgeToolDefinition[] | undefined;
+export declare function buildGeminiToolsFromBridge(defs: BridgeToolDefinition[] | undefined): JsonObject[] | undefined;

package/node_modules/@jsonstudio/llms/dist/conversion/shared/gemini-tool-utils.js

@@ -0,0 +1,130 @@
+import { jsonClone } from '../hub/types/json.js';
+function isPlainRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function cloneParameters(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => cloneParameters(entry));
+    }
+    if (isPlainRecord(value)) {
+        const cloned = {};
+        for (const [key, entry] of Object.entries(value)) {
+            cloned[key] = cloneParameters(entry);
+        }
+        return cloned;
+    }
+    return { type: 'object', properties: {} };
+}
+function declarationToBridge(declaration) {
+    if (!declaration || typeof declaration !== 'object') {
+        return null;
+    }
+    const def = declaration;
+    const name = typeof def.name === 'string' ? def.name : undefined;
+    if (!name) {
+        return null;
+    }
+    const description = typeof def.description === 'string' ? def.description : undefined;
+    const parameters = cloneParameters(def.parameters ?? { type: 'object', properties: {} });
+    return {
+        type: 'function',
+        function: {
+            name,
+            description,
+            parameters
+        }
+    };
+}
+function legacyToolToBridge(entry) {
+    const name = typeof entry.name === 'string' ? entry.name : undefined;
+    if (!name) {
+        return null;
+    }
+    const description = typeof entry.description === 'string' ? entry.description : undefined;
+    const parameters = cloneParameters(entry.parameters ?? { type: 'object', properties: {} });
+    return {
+        type: 'function',
+        function: {
+            name,
+            description,
+            parameters
+        }
+    };
+}
+export function prepareGeminiToolsForBridge(rawTools, missing) {
+    if (!rawTools) {
+        return undefined;
+    }
+    const arr = Array.isArray(rawTools) ? rawTools : [rawTools];
+    const defs = [];
+    arr.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object') {
+            missing?.push({
+                path: `tools[${index}]`,
+                reason: 'invalid_entry',
+                originalValue: jsonClone(entry)
+            });
+            return;
+        }
+        const obj = entry;
+        const declarations = Array.isArray(obj.functionDeclarations) ? obj.functionDeclarations : undefined;
+        if (declarations && declarations.length) {
+            declarations.forEach((decl, declIndex) => {
+                const converted = declarationToBridge(decl);
+                if (converted) {
+                    defs.push(converted);
+                }
+                else {
+                    missing?.push({ path: `tools[${index}].functionDeclarations[${declIndex}]`, reason: 'invalid_entry' });
+                }
+            });
+            return;
+        }
+        const converted = legacyToolToBridge(obj);
+        if (converted) {
+            defs.push(converted);
+            return;
+        }
+        missing?.push({ path: `tools[${index}]`, reason: 'invalid_entry' });
+    });
+    return defs.length ? defs : undefined;
+}
+export function buildGeminiToolsFromBridge(defs) {
+    if (!defs || !defs.length) {
+        return undefined;
+    }
+    const tools = [];
+    defs.forEach((def) => {
+        if (!def || typeof def !== 'object') {
+            return;
+        }
+        const fnNode = def.function && typeof def.function === 'object' ? def.function : undefined;
+        const name = typeof fnNode?.name === 'string'
+            ? fnNode.name
+            : typeof def.name === 'string'
+                ? def.name
+                : undefined;
+        if (!name) {
+            return;
+        }
+        const description = typeof fnNode?.description === 'string'
+            ? fnNode.description
+            : typeof def.description === 'string'
+                ? def.description
+                : undefined;
+        const parameters = cloneParameters(fnNode?.parameters ?? def.parameters ?? { type: 'object', properties: {} });
+        tools.push({
+            functionDeclarations: [
+                {
+                    name,
+                    description,
+                    parameters
+                }
+            ]
+        });
+    });
+    return tools.length ? tools : undefined;
+}

package/node_modules/@jsonstudio/llms/dist/conversion/shared/jsonish.js

@@ -0,0 +1,177 @@
+// Shared JSON-ish parsing helpers
+export function tryParseJson(s) {
+    if (typeof s !== 'string')
+        return s;
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return s;
+    }
+}
+// Lenient parsing for function.arguments often produced by models
+export function parseLenient(value) {
+    if (value === undefined || value === null)
+        return {};
+    if (typeof value === 'object')
+        return value;
+    if (typeof value !== 'string')
+        return { _raw: String(value) };
+    const s0 = value.trim();
+    if (!s0)
+        return {};
+    // 1) strict JSON
+    try {
+        return JSON.parse(s0);
+    }
+    catch { /* continue */ }
+    // 2) fenced ```json ... ``` or ``` ... ```
+    const fence = s0.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+    const candidate = fence ? fence[1] : s0;
+    // 3) object substring
+    const objMatch = candidate.match(/\{[\s\S]*\}/);
+    if (objMatch) {
+        try {
+            return JSON.parse(objMatch[0]);
+        }
+        catch { /* ignore */ }
+    }
+    // 4) array substring
+    const arrMatch = candidate.match(/\[[\s\S]*\]/);
+    if (arrMatch) {
+        try {
+            return JSON.parse(arrMatch[0]);
+        }
+        catch { /* ignore */ }
+    }
+    // 5) single quotes → double; unquoted keys → quoted
+    let t = candidate.replace(/'([^']*)'/g, '"$1"');
+    t = t.replace(/([{,\s])([A-Za-z_][A-Za-z0-9_-]*)\s*:/g, '$1"$2":');
+    try {
+        return JSON.parse(t);
+    }
+    catch { /* ignore */ }
+    // 6) key=value fallback across lines/commas
+    const obj = {};
+    const parts = candidate.split(/[\n,]+/).map(p => p.trim()).filter(Boolean);
+    for (const p of parts) {
+        const m = p.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*[:=]\s*(.+)$/);
+        if (!m)
+            continue;
+        const k = m[1];
+        let v = m[2].trim();
+        if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'")))
+            v = v.slice(1, -1);
+        try {
+            const pv = JSON.parse(v);
+            obj[k] = pv;
+            continue;
+        }
+        catch { /* fallthrough */ }
+        if (/^(true|false)$/i.test(v)) {
+            obj[k] = /^true$/i.test(v);
+            continue;
+        }
+        if (/^-?\d+(?:\.\d+)?$/.test(v)) {
+            obj[k] = Number(v);
+            continue;
+        }
+        obj[k] = v;
+    }
+    return obj;
+}
+// CCR-style repair: JSON -> JSON5-like cleanup -> safe fallback
+export function repairArgumentsToString(value) {
+    try {
+        if (value === undefined || value === null)
+            return '{}';
+        if (typeof value === 'object') {
+            try {
+                return JSON.stringify(value);
+            }
+            catch {
+                return '{}';
+            }
+        }
+        if (typeof value !== 'string') {
+            try {
+                return JSON.stringify({ _raw: String(value) });
+            }
+            catch {
+                return '{}';
+            }
+        }
+        let s = value.trim();
+        if (!s)
+            return '{}';
+        // 1) strict JSON
+        try {
+            JSON.parse(s);
+            return s;
+        }
+        catch { /* continue */ }
+        // 2) fenced ```json ... ``` or ``` ... ```
+        const fence = s.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+        if (fence && fence[1])
+            s = fence[1].trim();
+        // 3) strip comments (// and /* */)
+        try {
+            s = s.replace(/\/\/.*$/gm, '');
+            s = s.replace(/\/\*[\s\S]*?\*\//g, '');
+        }
+        catch { /* ignore */ }
+        // 4) remove trailing commas before } or ]
+        try {
+            s = s.replace(/,\s*(?=[}\]])/g, '');
+        }
+        catch { /* ignore */ }
+        // 5) single quotes to double
+        try {
+            s = s.replace(/'([^'\\]*(?:\\.[^'\\]*)*)'/g, '"$1"');
+        }
+        catch { /* ignore */ }
+        // 6) quote unquoted keys
+        try {
+            s = s.replace(/([\{,\s])([A-Za-z_][A-Za-z0-9_-]*)\s*:/g, '$1"$2":');
+        }
+        catch { /* ignore */ }
+        // 7) try parse after cleanup
+        try {
+            const obj = JSON.parse(s);
+            try {
+                if (obj && typeof obj === 'object' && Object.prototype.hasOwnProperty.call(obj, 'command')) {
+                    const cmd = obj.command;
+                    if (Array.isArray(cmd)) {
+                        obj.command = cmd.map((t) => String(t)).join(' ');
+                    }
+                }
+            }
+            catch { /* ignore */ }
+            return JSON.stringify(obj);
+        }
+        catch { /* continue */ }
+        // 8) extract first {...} or [...] substring and try again
+        try {
+            const m = s.match(/\{[\s\S]*\}|\[[\s\S]*\]/);
+            if (m) {
+                const obj = JSON.parse(m[0]);
+                try {
+                    if (obj && typeof obj === 'object' && Object.prototype.hasOwnProperty.call(obj, 'command')) {
+                        const cmd = obj.command;
+                        if (Array.isArray(cmd)) {
+                            obj.command = cmd.map((t) => String(t)).join(' ');
+                        }
+                    }
+                }
+                catch { /* ignore */ }
+                return JSON.stringify(obj);
+            }
+        }
+        catch { /* ignore */ }
+        // 9) final fallback
+        return '{}';
+    }
+    catch {
+        return '{}';
+    }
+}

package/node_modules/@jsonstudio/llms/dist/conversion/shared/mcp-injection.js

@@ -0,0 +1,110 @@
+// Shared MCP tool exposure logic (two-step), aligned with claude-code-router
+const obj = (props, req = []) => {
+    const schema = {
+        type: 'object',
+        properties: props,
+        additionalProperties: false
+    };
+    if (Array.isArray(req) && req.length > 0) {
+        schema.required = req;
+    }
+    return schema;
+};
+function uniq(arr) { return Array.from(new Set(arr)); }
+export function injectMcpToolsForChat(tools, discoveredServers) {
+    const out = [];
+    const keep = new Set();
+    const listServers = discoveredServers && discoveredServers.length ? { type: 'string', enum: uniq(discoveredServers) } : { type: 'string' };
+    const ensure = (name, def) => { if (!keep.has(name)) {
+        out.push(def);
+        keep.add(name);
+    } };
+    const current = Array.isArray(tools) ? tools : [];
+    for (const t of current) {
+        const name = t && t.function && typeof t.function.name === 'string' ? String(t.function.name) : '';
+        const lower = name.toLowerCase();
+        if (!name) {
+            out.push(t);
+            continue;
+        }
+        if (lower === 'list_mcp_resources') {
+            ensure('list_mcp_resources', { type: 'function', function: { name: 'list_mcp_resources', description: t.function?.description || 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
+            continue;
+        }
+        if (lower === 'read_mcp_resource' || lower === 'list_mcp_resource_templates') {
+            if (discoveredServers.length > 0) {
+                const srv = { type: 'string', enum: uniq(discoveredServers) };
+                if (lower === 'read_mcp_resource') {
+                    ensure('read_mcp_resource', { type: 'function', function: { name: 'read_mcp_resource', description: t.function?.description || 'Read a resource from a given MCP server.', parameters: obj({ server: srv, uri: { type: 'string' }, cursor: { type: 'string' } }, ['server', 'uri']) } });
+                }
+                else {
+                    ensure('list_mcp_resource_templates', { type: 'function', function: { name: 'list_mcp_resource_templates', description: t.function?.description || 'List resource templates from a given MCP server.', parameters: obj({ server: srv, cursor: { type: 'string' } }, ['server']) } });
+                }
+                continue;
+            }
+        }
+        out.push(t);
+        keep.add(lower);
+    }
+    // Ensure list exists when user did not provide it
+    if (!keep.has('list_mcp_resources')) {
+        out.push({ type: 'function', function: { name: 'list_mcp_resources', description: 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
+    }
+    return out;
+}
+export function injectMcpToolsForResponses(tools, discoveredServers) {
+    const out = [];
+    const keep = new Set();
+    const listServers = { type: 'string' };
+    const templateServer = discoveredServers && discoveredServers.length ? { type: 'string', enum: uniq(discoveredServers) } : { type: 'string' };
+    const ensure = (name, def) => { if (!keep.has(name)) {
+        out.push(def);
+        keep.add(name);
+    } };
+    const current = Array.isArray(tools) ? tools : [];
+    for (const t of current) {
+        const name = t && t.function && typeof t.function.name === 'string' ? String(t.function.name) : '';
+        const lower = name.toLowerCase();
+        if (!name) {
+            out.push(t);
+            continue;
+        }
+        if (lower === 'list_mcp_resources') {
+            ensure('list_mcp_resources', { type: 'function', function: { name: 'list_mcp_resources', description: t.function?.description || 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
+            continue;
+        }
+        if (lower === 'list_mcp_resource_templates') {
+            ensure('list_mcp_resource_templates', {
+                type: 'function',
+                function: {
+                    name: 'list_mcp_resource_templates',
+                    description: t.function?.description || 'List resource templates from MCP servers.',
+                    parameters: obj({ server: templateServer, cursor: { type: 'string' } })
+                }
+            });
+            continue;
+        }
+        if (lower === 'read_mcp_resource' && discoveredServers.length > 0) {
+            const srv = { type: 'string', enum: uniq(discoveredServers) };
+            ensure('read_mcp_resource', { type: 'function', function: { name: 'read_mcp_resource', description: t.function?.description || 'Read a resource via MCP server.', parameters: obj({ server: srv, uri: { type: 'string' } }, ['server', 'uri']) } });
+            continue;
+        }
+        out.push(t);
+        keep.add(lower);
+    }
+    if (!keep.has('list_mcp_resources')) {
+        out.push({ type: 'function', function: { name: 'list_mcp_resources', description: 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
+        keep.add('list_mcp_resources');
+    }
+    if (!keep.has('list_mcp_resource_templates')) {
+        out.push({
+            type: 'function',
+            function: {
+                name: 'list_mcp_resource_templates',
+                description: 'List resource templates from MCP servers.',
+                parameters: obj({ server: templateServer, cursor: { type: 'string' } })
+            }
+        });
+    }
+    return out;
+}

package/node_modules/@jsonstudio/llms/dist/conversion/shared/media.js

@@ -0,0 +1,9 @@
+export function isImagePath(p) {
+    try {
+        const s = String(p || '').toLowerCase();
+        return /\.(png|jpg|jpeg|gif|webp|bmp|svg|tiff?|ico|heic|jxl)$/.test(s);
+    }
+    catch {
+        return false;
+    }
+}

package/node_modules/@jsonstudio/llms/dist/conversion/shared/metadata-passthrough.d.ts

@@ -0,0 +1,11 @@
+import { type JsonObject, type JsonValue } from '../hub/types/json.js';
+interface PassthroughOptions {
+    prefix: string;
+    keys: readonly string[];
+}
+export declare function encodeMetadataPassthrough(parameters: JsonObject | undefined, options: PassthroughOptions): Record<string, string> | undefined;
+export declare function extractMetadataPassthrough(metadataField: JsonValue | undefined, options: PassthroughOptions): {
+    metadata?: JsonObject;
+    passthrough?: JsonObject;
+};
+export {};

package/node_modules/@jsonstudio/llms/dist/conversion/shared/metadata-passthrough.js

@@ -0,0 +1,57 @@
+import { isJsonObject, jsonClone } from '../hub/types/json.js';
+function isValidKey(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+export function encodeMetadataPassthrough(parameters, options) {
+    if (!parameters)
+        return undefined;
+    const encoded = {};
+    const { prefix, keys } = options;
+    for (const key of keys) {
+        if (!isValidKey(key))
+            continue;
+        const value = parameters[key];
+        if (value === undefined)
+            continue;
+        try {
+            encoded[`${prefix}${key}`] = JSON.stringify(value);
+        }
+        catch {
+            continue;
+        }
+    }
+    return Object.keys(encoded).length ? encoded : undefined;
+}
+export function extractMetadataPassthrough(metadataField, options) {
+    if (!metadataField || !isJsonObject(metadataField)) {
+        return {};
+    }
+    const cloned = jsonClone(metadataField);
+    const passthrough = {};
+    const { prefix, keys } = options;
+    const allowedKeys = new Set(keys.filter(isValidKey));
+    let mutated = false;
+    for (const rawKey of Object.keys(cloned)) {
+        if (!rawKey.startsWith(prefix))
+            continue;
+        const suffix = rawKey.slice(prefix.length);
+        if (!allowedKeys.has(suffix))
+            continue;
+        const rawValue = cloned[rawKey];
+        if (typeof rawValue !== 'string')
+            continue;
+        try {
+            const parsed = rawValue ? JSON.parse(rawValue) : undefined;
+            passthrough[suffix] = parsed;
+            delete cloned[rawKey];
+            mutated = true;
+        }
+        catch {
+            continue;
+        }
+    }
+    return {
+        metadata: mutated ? (Object.keys(cloned).length ? cloned : undefined) : cloned,
+        passthrough: Object.keys(passthrough).length ? passthrough : undefined
+    };
+}