@jsonstudio/llms 0.4.4 → 0.4.5

package/dist/conversion/shared/bridge-request-adapter.js

@@ -0,0 +1,430 @@
+import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from './bridge-id-utils.js';
+import { ensureBridgeInstructions } from './bridge-instructions.js';
+import { serializeToolArguments, coerceBridgeRole, serializeToolOutput } from './bridge-message-utils.js';
+export function captureResponsesContext(payload, dto) {
+    ensureBridgeInstructions(payload);
+    const context = {
+        requestId: dto?.route?.requestId,
+        instructions: typeof payload.instructions === 'string' ? payload.instructions : undefined,
+        input: Array.isArray(payload.input) ? payload.input : undefined,
+        include: payload.include,
+        store: payload.store,
+        toolChoice: payload.tool_choice,
+        parallelToolCalls: typeof payload.parallel_tool_calls === 'boolean' ? payload.parallel_tool_calls : undefined,
+        metadata: (payload.metadata && typeof payload.metadata === 'object') ? { ...payload.metadata } : undefined,
+        responseFormat: payload.response_format,
+        stream: typeof payload.stream === 'boolean' ? payload.stream : undefined,
+        instructionsIsRaw: payload.instructions_is_raw === true,
+        isChatPayload: Array.isArray(payload.messages)
+    };
+    if (Array.isArray(payload.tools)) {
+        context.toolsRaw = payload.tools;
+    }
+    context.isResponsesPayload = !context.isChatPayload && Array.isArray(context.input);
+    return context;
+}
+export function buildChatRequestFromResponses(payload, context) {
+    const toolOutputs = Array.isArray(payload.tool_outputs)
+        ? payload.tool_outputs
+        : undefined;
+    const responseId = typeof payload.response_id === 'string' ? payload.response_id : undefined;
+    const hasInput = Array.isArray(payload.input) && payload.input.length > 0;
+    const submitOnlyMode = !!toolOutputs && !!responseId && !hasInput;
+    if (submitOnlyMode) {
+        return {
+            request: {
+                type: 'submit_tool_outputs',
+                model: payload.model,
+                response_id: responseId,
+                tool_outputs: toolOutputs,
+                stream: payload.stream === true
+            }
+        };
+    }
+    let toolsNormalized = Array.isArray(payload.tools)
+        ? normalizeTools(payload.tools)
+        : undefined;
+    // Inject MCP tools (CCR style) if enabled
+    try {
+        const enableMcp = String(process.env?.ROUTECODEX_MCP_ENABLE ?? '1') !== '0';
+        if (enableMcp) {
+            // Discover servers from prior inputs if present (best-effort; depends on client payload)
+            const discovered = new Set();
+            try {
+                const input = Array.isArray(payload.input) ? payload.input : [];
+                for (const it of input) {
+                    const t = (it && typeof it === 'object') ? it : {};
+                    const isToolCall = (t.type === 'function_call' || t.type === 'tool_call');
+                    const isToolMsg = (t.type === 'tool_message' || t.type === 'tool_result');
+                    if (isToolCall) {
+                        const args = typeof t.arguments === 'string' ? (() => { try {
+                            return JSON.parse(t.arguments);
+                        }
+                        catch {
+                            return {};
+                        } })() : (t.arguments || {});
+                        const sv = (args && typeof args === 'object') ? args.server : undefined;
+                        if (typeof sv === 'string' && sv.trim())
+                            discovered.add(sv.trim());
+                    }
+                    else if (isToolMsg) {
+                        const output = t?.output;
+                        const val = (typeof output === 'string') ? (() => { try {
+                            return JSON.parse(output);
+                        }
+                        catch {
+                            return null;
+                        } })() : (output || null);
+                        const args = (val && typeof val === 'object') ? val.arguments : undefined;
+                        const sv = (args && typeof args === 'object') ? args.server : undefined;
+                        if (typeof sv === 'string' && sv.trim())
+                            discovered.add(sv.trim());
+                    }
+                }
+            }
+            catch { /* ignore */ }
+            const list = toolsNormalized && Array.isArray(toolsNormalized) ? toolsNormalized : [];
+            const have = new Set(list.map((t) => (t?.function?.name || '').toString()));
+            const addTool = (def) => { if (!have.has(def.function.name)) {
+                list.push(def);
+                have.add(def.function.name);
+            } };
+            const obj = (props, req) => ({ type: 'object', properties: props, required: req, additionalProperties: false });
+            const serversRaw = String(process.env?.ROUTECODEX_MCP_SERVERS || '').trim();
+            const envServers = serversRaw ? serversRaw.split(',').map((s) => s.trim()).filter(Boolean) : [];
+            const merged = Array.from(new Set([...envServers, ...Array.from(discovered)]));
+            const serverProp = merged.length ? { type: 'string', enum: merged } : { type: 'string' };
+            // 初始仅注入 list_mcp_resources；有已知 server 后再注入其余 MCP 工具
+            // 与 Chat 路径保持一致：server 可选（不强制要求）
+            addTool({ type: 'function', function: { name: 'list_mcp_resources', strict: true, description: 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: serverProp, filter: { type: 'string' }, root: { type: 'string' } }, [] /* server optional */) } });
+            if (merged.length > 0) {
+                addTool({ type: 'function', function: { name: 'read_mcp_resource', strict: true, description: 'Read a resource via MCP server.', parameters: obj({ server: serverProp, uri: { type: 'string' } }, ['server', 'uri']) } });
+                addTool({ type: 'function', function: { name: 'list_mcp_resource_templates', strict: true, description: 'List resource templates via MCP server.', parameters: obj({ server: serverProp }, ['server']) } });
+            }
+            toolsNormalized = list;
+        }
+    }
+    catch { /* ignore MCP injection */ }
+    const mergedInput = mergeToolOutputsIntoInput(context.input, payload.tool_outputs);
+    let messages = mapResponsesInputToChat({
+        instructions: context.instructions,
+        input: mergedInput,
+        toolsNormalized
+    });
+    const preservedSystemMessages = Array.isArray(context.originalSystemMessages)
+        ? context.originalSystemMessages
+            .map((text) => (typeof text === 'string' ? text.trim() : ''))
+            .filter((text) => text.length > 0)
+            .map((text) => ({ role: 'system', content: text }))
+        : undefined;
+    if (preservedSystemMessages && preservedSystemMessages.length) {
+        const nonSystemMessages = messages.filter((msg) => String(msg?.role || '').toLowerCase() !== 'system');
+        messages = [...preservedSystemMessages, ...nonSystemMessages];
+    }
+    const request = {
+        model: payload.model || 'gpt-4.1-mini',
+        messages
+    };
+    for (const key of ['temperature', 'top_p', 'max_tokens', 'tool_choice', 'parallel_tool_calls', 'user', 'logit_bias', 'seed', 'response_format']) {
+        if (payload[key] !== undefined) {
+            request[key] = payload[key];
+        }
+    }
+    if (Array.isArray(toolsNormalized) && toolsNormalized.length) {
+        request.tools = toolsNormalized;
+    }
+    if (typeof payload.stream === 'boolean') {
+        request.stream = payload.stream;
+    }
+    return {
+        request,
+        toolsNormalized
+    };
+}
+function mergeToolOutputsIntoInput(input, toolOutputsRaw) {
+    const result = Array.isArray(input) ? [...input] : [];
+    if (!Array.isArray(toolOutputsRaw)) {
+        return result;
+    }
+    for (const entry of toolOutputsRaw) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const data = entry;
+        const callIdRaw = data.tool_call_id ?? data.call_id ?? data.id;
+        if (typeof callIdRaw !== 'string' || !callIdRaw.trim())
+            continue;
+        const outputRaw = data.output;
+        const outputText = normalizeToolOutputPayload(outputRaw);
+        const normalizedCallId = normalizeFunctionCallId({ callId: callIdRaw, fallback: callIdRaw });
+        const outputId = normalizeFunctionCallOutputId({ callId: normalizedCallId, fallback: normalizedCallId });
+        result.push({
+            type: 'function_call_output',
+            id: outputId,
+            call_id: normalizedCallId,
+            output: outputText
+        });
+    }
+    return result;
+}
+function normalizeToolOutputPayload(payload) {
+    if (typeof payload === 'string') {
+        return payload;
+    }
+    if (payload == null) {
+        return '';
+    }
+    try {
+        return JSON.stringify(payload);
+    }
+    catch {
+        return String(payload);
+    }
+}
+function mapResponsesInputToChat(options) {
+    const { instructions, input, toolsNormalized } = options;
+    const messages = [];
+    if (typeof instructions === 'string' && instructions.length) {
+        messages.push({ role: 'system', content: instructions });
+    }
+    if (!Array.isArray(input))
+        return messages;
+    const toolNameById = new Map();
+    const toolCallIdAliases = new Map();
+    let lastToolCallId = null;
+    for (const entry of input) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const entryType = typeof entry.type === 'string' ? entry.type.toLowerCase() : 'message';
+        if (typeof entry.content === 'string') {
+            const directText = (entry.content || '').toString().trim();
+            if (directText.length) {
+                const normalizedRole = coerceBridgeRole(entry.role || 'user');
+                messages.push({ role: normalizedRole, content: directText });
+                continue;
+            }
+        }
+        if (entryType === 'function_call' || entryType === 'tool_call') {
+            const rawName = typeof entry.name === 'string' ? entry.name : (typeof entry?.function?.name === 'string' ? entry.function.name : undefined);
+            const name = (typeof rawName === 'string' && rawName.includes('.')) ? rawName.slice(rawName.indexOf('.') + 1).trim() : rawName;
+            if (typeof name !== 'string' || !name.trim() || name.toLowerCase() === 'tool') {
+                continue;
+            }
+            const args = entry.arguments ?? entry?.function?.arguments ?? {};
+            const parsedArgs = args;
+            const callIdRaw = typeof entry.id === 'string' ? entry.id : (typeof entry.call_id === 'string' ? entry.call_id : `call_${Math.random().toString(36).slice(2, 8)}`);
+            const callId = normalizeFunctionCallId({ callId: callIdRaw, fallback: `fc_call_${messages.length + 1}` });
+            if (callIdRaw && callIdRaw !== callId) {
+                toolCallIdAliases.set(callIdRaw, callId);
+            }
+            const serialized = serializeToolArguments(parsedArgs, name, toolsNormalized).trim();
+            toolNameById.set(callId, name);
+            messages.push({ role: 'assistant', tool_calls: [{ id: callId, type: 'function', function: { name, arguments: serialized } }] });
+            lastToolCallId = callId;
+            continue;
+        }
+        if (entryType === 'function_call_output' || entryType === 'tool_result' || entryType === 'tool_message') {
+            let toolCallId = entry.tool_call_id || entry.call_id || entry.tool_use_id || entry.id || lastToolCallId;
+            if (toolCallId && toolCallIdAliases.has(String(toolCallId))) {
+                toolCallId = toolCallIdAliases.get(String(toolCallId)) || toolCallId;
+            }
+            else if (typeof toolCallId === 'string' && toolCallId.trim().length) {
+                const normalized = normalizeFunctionCallId({ callId: toolCallId, fallback: toolCallId });
+                if (normalized !== toolCallId) {
+                    toolCallIdAliases.set(toolCallId, normalized);
+                }
+                toolCallId = normalized;
+            }
+            const output = serializeToolOutput(entry);
+            if (toolCallId) {
+                try {
+                    let contentStr = output != null ? String(output) : '';
+                    if (!contentStr || contentStr.trim().length === 0) {
+                        contentStr = 'Command succeeded (no output).';
+                    }
+                    const nm = toolNameById.get(String(toolCallId));
+                    const toolMsg = { role: 'tool', tool_call_id: String(toolCallId), content: contentStr };
+                    if (typeof nm === 'string' && nm.trim().length)
+                        toolMsg.name = nm;
+                    messages.push(toolMsg);
+                }
+                catch {
+                    const fallback = (output ?? '');
+                    const nm = toolNameById.get(String(toolCallId));
+                    const toolMsg = { role: 'tool', tool_call_id: String(toolCallId), content: String(fallback) };
+                    if (typeof nm === 'string' && nm.trim().length)
+                        toolMsg.name = nm;
+                    messages.push(toolMsg);
+                }
+                lastToolCallId = null;
+            }
+            continue;
+        }
+        let handledViaExplicitMessage = false;
+        if (entry && typeof entry.message === 'object' && Array.isArray(entry.message?.content)) {
+            const explicit = entry.message;
+            const { text, toolCalls, toolMessages, lastCallId } = processMessageBlocks(Array.isArray(explicit.content) ? explicit.content : [], toolsNormalized, toolNameById, toolCallIdAliases, lastToolCallId);
+            if (toolCalls.length)
+                messages.push({ role: 'assistant', tool_calls: toolCalls });
+            for (const msg of toolMessages)
+                messages.push(msg);
+            const normalizedRole = coerceBridgeRole((explicit.role ?? entry.role) || 'user');
+            if (typeof text === 'string' && text.trim().length) {
+                messages.push({ role: normalizedRole, content: text.trim() });
+            }
+            lastToolCallId = lastCallId;
+            handledViaExplicitMessage = true;
+        }
+        if (!handledViaExplicitMessage) {
+            const { text, toolCalls, toolMessages, lastCallId } = processMessageBlocks(Array.isArray(entry.content) ? entry.content : [], toolsNormalized, toolNameById, toolCallIdAliases, lastToolCallId);
+            if (toolCalls.length)
+                messages.push({ role: 'assistant', tool_calls: toolCalls });
+            for (const msg of toolMessages)
+                messages.push(msg);
+            const normalizedRole = coerceBridgeRole(entry.role || 'user');
+            if (typeof text === 'string' && text.trim().length) {
+                messages.push({ role: normalizedRole, content: text.trim() });
+            }
+            lastToolCallId = lastCallId;
+        }
+        try {
+            const t = String(entry.type || '').toLowerCase();
+            if ((t === 'input_text' || t === 'text' || t === 'output_text' || t === 'commentary') && typeof entry.text === 'string') {
+                const normalizedRole = coerceBridgeRole(entry.role || 'user');
+                const s = entry.text;
+                if (s && s.length)
+                    messages.push({ role: normalizedRole, content: s });
+            }
+        }
+        catch { /* ignore */ }
+    }
+    return messages;
+}
+function processMessageBlocks(blocks, toolsNormalized, toolNameById, toolCallIdAliases, lastToolCallId) {
+    const textParts = [];
+    const toolCalls = [];
+    const toolMessages = [];
+    let currentLastCall = lastToolCallId;
+    for (const block of blocks) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const type = typeof block.type === 'string' ? block.type.toLowerCase() : '';
+        if (type === 'input_text' || type === 'output_text' || type === 'text' || type === 'commentary') {
+            if (typeof block.text === 'string')
+                textParts.push(block.text);
+            else if (typeof block.content === 'string')
+                textParts.push(block.content);
+            continue;
+        }
+        if (type === 'message' && Array.isArray(block.content)) {
+            const nested = processMessageBlocks(block.content, toolsNormalized, toolNameById, toolCallIdAliases, currentLastCall);
+            if (nested.text)
+                textParts.push(nested.text);
+            for (const tc of nested.toolCalls)
+                toolCalls.push(tc);
+            for (const tm of nested.toolMessages)
+                toolMessages.push(tm);
+            currentLastCall = nested.lastCallId;
+            continue;
+        }
+        if (type === 'function_call') {
+            const rawName = typeof block.name === 'string' ? block.name : (typeof block?.function?.name === 'string' ? block.function.name : undefined);
+            const name = (typeof rawName === 'string' && rawName.includes('.')) ? rawName.slice(rawName.indexOf('.') + 1).trim() : rawName;
+            const args = block.arguments ?? block?.function?.arguments ?? {};
+            const parsedArgs = args;
+            const callIdRaw = typeof block.id === 'string' ? block.id : (typeof block.call_id === 'string' ? block.call_id : `call_${Math.random().toString(36).slice(2, 8)}`);
+            const callId = normalizeFunctionCallId({ callId: callIdRaw, fallback: `fc_call_${toolCalls.length + 1}` });
+            if (callIdRaw && callIdRaw !== callId) {
+                toolCallIdAliases.set(callIdRaw, callId);
+            }
+            if (typeof name !== 'string' || !name.trim()) {
+                currentLastCall = null;
+                continue;
+            }
+            const serialized = serializeToolArguments(parsedArgs, name, toolsNormalized).trim();
+            toolNameById.set(callId, name);
+            toolCalls.push({ id: callId, type: 'function', function: { name, arguments: serialized } });
+            currentLastCall = callId;
+            continue;
+        }
+        if (type === 'function_call_output' || type === 'tool_result' || type === 'tool_message') {
+            let toolCallId = block.tool_call_id || block.call_id || block.tool_use_id || block.id || currentLastCall;
+            if (toolCallId && toolCallIdAliases.has(String(toolCallId))) {
+                toolCallId = toolCallIdAliases.get(String(toolCallId)) || toolCallId;
+            }
+            else if (typeof toolCallId === 'string' && toolCallId.trim().length) {
+                const normalized = normalizeFunctionCallId({ callId: toolCallId, fallback: toolCallId });
+                if (normalized !== toolCallId) {
+                    toolCallIdAliases.set(toolCallId, normalized);
+                }
+                toolCallId = normalized;
+            }
+            const output = serializeToolOutput(block);
+            if (toolCallId) {
+                try {
+                    let contentStr = output != null ? String(output) : '';
+                    if (!contentStr || contentStr.trim().length === 0) {
+                        contentStr = 'Command succeeded (no output).';
+                    }
+                    const nm = toolNameById.get(String(toolCallId));
+                    const toolMsg = { role: 'tool', tool_call_id: String(toolCallId), content: contentStr };
+                    if (typeof nm === 'string' && nm.trim().length)
+                        toolMsg.name = nm;
+                    toolMessages.push(toolMsg);
+                }
+                catch {
+                    const fallback = (output ?? '');
+                    const nm = toolNameById.get(String(toolCallId));
+                    const toolMsg = { role: 'tool', tool_call_id: String(toolCallId), content: String(fallback) };
+                    if (typeof nm === 'string' && nm.trim().length)
+                        toolMsg.name = nm;
+                    toolMessages.push(toolMsg);
+                }
+                currentLastCall = null;
+            }
+            continue;
+        }
+    }
+    return {
+        text: textParts.length ? textParts.join('\n') : null,
+        toolCalls,
+        toolMessages,
+        lastCallId: currentLastCall
+    };
+}
+function normalizeTools(tools) {
+    const normalized = [];
+    for (const tool of tools) {
+        if (!tool || typeof tool !== 'object')
+            continue;
+        const originalType = typeof tool.type === 'string' ? tool.type : 'function';
+        const mappedType = ['function', 'custom'].includes(originalType.toLowerCase())
+            ? 'function'
+            : originalType;
+        const fn = (tool.function && typeof tool.function === 'object')
+            ? tool.function
+            : {};
+        const topName = typeof tool.name === 'string' ? tool.name : undefined;
+        const fnName = typeof fn.name === 'string' ? fn.name : undefined;
+        const name = (fnName || topName || '').trim();
+        if (!name)
+            continue;
+        const topDesc = typeof tool.description === 'string' ? tool.description : undefined;
+        const fnDesc = typeof fn.description === 'string' ? fn.description : undefined;
+        const description = fnDesc || topDesc;
+        const fnParams = Object.prototype.hasOwnProperty.call(fn, 'parameters') ? fn.parameters : undefined;
+        const topParams = Object.prototype.hasOwnProperty.call(tool, 'parameters') ? tool.parameters : undefined;
+        const parameters = fnParams !== undefined ? fnParams : topParams;
+        const strict = typeof fn.strict === 'boolean' ? fn.strict :
+            typeof tool.strict === 'boolean' ? tool.strict :
+                undefined;
+        const fnOut = { name };
+        if (description)
+            fnOut.description = description;
+        if (parameters !== undefined)
+            fnOut.parameters = parameters;
+        if (strict !== undefined)
+            fnOut.strict = strict;
+        normalized.push({ type: mappedType, function: fnOut });
+    }
+    return normalized;
+}

package/dist/conversion/shared/chat-output-normalizer.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizeChatMessageContent(content: unknown): {
+    contentText?: string;
+    reasoningText?: string;
+};

package/dist/conversion/shared/chat-output-normalizer.js

@@ -0,0 +1,56 @@
+import { extractReasoningSegments, sanitizeReasoningTaggedText } from './reasoning-utils.js';
+function collectText(value, collector) {
+    if (value == null) {
+        return;
+    }
+    if (typeof value === 'string') {
+        const cleaned = extractReasoningSegments(value, collector.reasoningParts);
+        if (cleaned.length) {
+            collector.textParts.push(cleaned);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            collectText(entry, collector);
+        }
+        return;
+    }
+    if (typeof value === 'object') {
+        const record = value;
+        if (typeof record.text === 'string') {
+            collectText(record.text, collector);
+            return;
+        }
+        if (typeof record.content === 'string') {
+            collectText(record.content, collector);
+            return;
+        }
+        if (Array.isArray(record.content)) {
+            collectText(record.content, collector);
+            return;
+        }
+        if (record.type === 'image_url' && typeof record.image_url === 'string') {
+            collector.textParts.push(`[image:${record.image_url}]`);
+            return;
+        }
+        try {
+            collector.textParts.push(sanitizeReasoningTaggedText(JSON.stringify(record)));
+        }
+        catch {
+            collector.textParts.push(String(record));
+        }
+        return;
+    }
+    collector.textParts.push(sanitizeReasoningTaggedText(String(value)));
+}
+export function normalizeChatMessageContent(content) {
+    const collector = { textParts: [], reasoningParts: [] };
+    collectText(content, collector);
+    const text = collector.textParts.join('');
+    const reasoning = collector.reasoningParts.join('\n');
+    return {
+        contentText: text.length ? text : undefined,
+        reasoningText: reasoning.length ? reasoning : undefined
+    };
+}

package/dist/conversion/shared/chat-request-filters.js

@@ -70,5 +70,28 @@ export async function runStandardChatRequestFilters(chatRequest, profile, contex
     catch {
         // 可选工具归一过滤器，失败时保持已归一化结果
     }
-    return normalized;
+    return ensureToolParameterDefaults(normalized);
+}
+function ensureToolParameterDefaults(chatRequest) {
+    if (!chatRequest || typeof chatRequest !== 'object')
+        return chatRequest;
+    const next = { ...chatRequest };
+    if (!Array.isArray(next.tools))
+        return next;
+    next.tools = next.tools.map((tool) => {
+        if (!tool || typeof tool !== 'object')
+            return tool;
+        if (tool.type !== 'function')
+            return tool;
+        const fn = tool.function && typeof tool.function === 'object' ? { ...tool.function } : tool.function;
+        if (fn && typeof fn === 'object' && fn.parameters && typeof fn.parameters === 'object') {
+            const params = { ...fn.parameters };
+            if (!Object.prototype.hasOwnProperty.call(params, 'additionalProperties')) {
+                params.additionalProperties = true;
+            }
+            fn.parameters = params;
+        }
+        return { ...tool, function: fn };
+    });
+    return next;
 }

package/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/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/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 {};