@jsonstudio/llms 0.4.2

package/dist/conversion/shared/responses-instructions.js

@@ -0,0 +1,113 @@
+function collectTextFromBlocks(blocks) {
+    const parts = [];
+    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') && typeof block.text === 'string') {
+            const text = block.text.trim();
+            if (text)
+                parts.push(text);
+            continue;
+        }
+        if (type === 'message' && Array.isArray(block.content)) {
+            const nested = collectTextFromBlocks(block.content);
+            if (nested)
+                parts.push(nested);
+            continue;
+        }
+        if (typeof block.content === 'string') {
+            const text = block.content.trim();
+            if (text)
+                parts.push(text);
+            continue;
+        }
+        if (Array.isArray(block.content)) {
+            const nested = collectTextFromBlocks(block.content);
+            if (nested)
+                parts.push(nested);
+            continue;
+        }
+        if (typeof block.text === 'string') {
+            const text = block.text.trim();
+            if (text)
+                parts.push(text);
+        }
+    }
+    return parts.join('\n');
+}
+function extractSystemInstruction(entry) {
+    if (!entry || typeof entry !== 'object')
+        return null;
+    const roleSource = entry.role ?? entry.message?.role;
+    const role = typeof roleSource === 'string' ? roleSource.toLowerCase() : '';
+    if (role !== 'system')
+        return null;
+    const collected = [];
+    if (Array.isArray(entry.content)) {
+        const text = collectTextFromBlocks(entry.content);
+        if (text.trim())
+            collected.push(text.trim());
+    }
+    else if (typeof entry.content === 'string') {
+        const text = entry.content.trim();
+        if (text)
+            collected.push(text);
+    }
+    if (typeof entry.text === 'string') {
+        const text = entry.text.trim();
+        if (text)
+            collected.push(text);
+    }
+    const message = entry.message;
+    if (message && typeof message === 'object') {
+        if (Array.isArray(message.content)) {
+            const text = collectTextFromBlocks(message.content);
+            if (text.trim())
+                collected.push(text.trim());
+        }
+        else if (typeof message.content === 'string') {
+            const text = message.content.trim();
+            if (text)
+                collected.push(text);
+        }
+        if (typeof message.text === 'string') {
+            const text = String(message.text).trim();
+            if (text)
+                collected.push(text);
+        }
+    }
+    const merged = collected.join('\n').trim();
+    return merged ? merged : null;
+}
+export function ensureResponsesInstructions(payload) {
+    let instructions = typeof payload.instructions === 'string' ? payload.instructions : '';
+    const hasClientInstruction = typeof payload.instructions === 'string' && payload.instructions.length > 0;
+    const input = Array.isArray(payload.input) ? payload.input : undefined;
+    if (input && input.length) {
+        for (let i = 0; i < input.length; i += 1) {
+            const entry = input[i];
+            const roleSource = entry?.role ?? entry?.message?.role;
+            const role = typeof roleSource === 'string' ? roleSource.toLowerCase() : '';
+            if (role === 'system') {
+                const text = extractSystemInstruction(entry);
+                input.splice(i, 1);
+                i -= 1;
+                if (text && text.trim()) {
+                    if (!hasClientInstruction && !instructions) {
+                        instructions = text.trim();
+                    }
+                }
+                continue;
+            }
+        }
+    }
+    if (instructions) {
+        payload.instructions = instructions;
+        return instructions;
+    }
+    if (typeof payload.instructions !== 'undefined') {
+        delete payload.instructions;
+    }
+    return undefined;
+}

package/dist/conversion/shared/responses-metadata.d.ts

@@ -0,0 +1 @@
+export declare const RESPONSES_RAW_SYSTEM_METADATA_KEY = "__rcc_raw_system";

package/dist/conversion/shared/responses-metadata.js

@@ -0,0 +1 @@
+export const RESPONSES_RAW_SYSTEM_METADATA_KEY = '__rcc_raw_system';

package/dist/conversion/shared/responses-request-adapter.d.ts

@@ -0,0 +1,66 @@
+export type ResponsesContentPart = {
+    type: string;
+    text?: string;
+    content?: unknown;
+};
+export type ResponsesInputItem = {
+    type: string;
+    role?: string;
+    content?: Array<ResponsesContentPart> | null;
+    name?: string;
+    arguments?: unknown;
+    call_id?: string;
+    output?: unknown;
+    function?: {
+        name?: string;
+        arguments?: unknown;
+    };
+    message?: {
+        role?: string;
+        content?: Array<ResponsesContentPart>;
+    };
+    id?: string;
+    tool_call_id?: string;
+    tool_use_id?: string;
+    text?: string;
+};
+export type ResponsesToolDefinition = {
+    type: string;
+    name?: string;
+    description?: string;
+    strict?: boolean;
+    parameters?: unknown;
+    function?: {
+        name?: string;
+        description?: string;
+        strict?: boolean;
+        parameters?: unknown;
+    };
+};
+export interface ResponsesRequestContext {
+    requestId?: string;
+    instructions?: string;
+    originalSystemMessages?: string[];
+    input?: ResponsesInputItem[];
+    include?: unknown;
+    store?: unknown;
+    toolChoice?: unknown;
+    parallelToolCalls?: boolean;
+    metadata?: Record<string, unknown>;
+    responseFormat?: unknown;
+    toolsRaw?: ResponsesToolDefinition[];
+    stream?: boolean;
+    instructionsIsRaw?: boolean;
+    isChatPayload?: boolean;
+    isResponsesPayload?: boolean;
+}
+export interface BuildChatRequestResult {
+    request: Record<string, unknown>;
+    toolsNormalized?: Array<Record<string, unknown>>;
+}
+export declare function captureResponsesContext(payload: Record<string, unknown>, dto?: {
+    route?: {
+        requestId?: string;
+    };
+}): ResponsesRequestContext;
+export declare function buildChatRequestFromResponses(payload: Record<string, unknown>, context: ResponsesRequestContext): BuildChatRequestResult;

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

@@ -0,0 +1,461 @@
+import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from './responses-id-utils.js';
+import { ensureResponsesInstructions } from './responses-instructions.js';
+export function captureResponsesContext(payload, dto) {
+    ensureResponsesInstructions(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 = normalizeResponseRole(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 = normalizeArgumentsBySchema(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 = normalizeToolOutput(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 = normalizeResponseRole((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 = normalizeResponseRole(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 = normalizeResponseRole(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 = normalizeArgumentsBySchema(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 = normalizeToolOutput(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 normalizeResponseRole(role) {
+    if (typeof role === 'string') {
+        const normalized = role.toLowerCase();
+        if (normalized === 'system' || normalized === 'assistant' || normalized === 'user' || normalized === 'tool')
+            return normalized;
+    }
+    return 'user';
+}
+function normalizeArgumentsBySchema(argsStringOrObj, _functionName, _tools) {
+    if (typeof argsStringOrObj === 'string')
+        return argsStringOrObj;
+    try {
+        return JSON.stringify(argsStringOrObj ?? {});
+    }
+    catch {
+        return String(argsStringOrObj);
+    }
+}
+function normalizeToolOutput(entry) {
+    const out = entry?.output;
+    if (typeof out === 'string')
+        return out;
+    if (out && typeof out === 'object') {
+        try {
+            return JSON.stringify(out);
+        }
+        catch {
+            return String(out);
+        }
+    }
+    return null;
+}
+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/snapshot-hooks.d.ts

@@ -0,0 +1,12 @@
+export interface SnapshotHookOptions {
+    endpoint: string;
+    stage: string;
+    requestId: string;
+    data: unknown;
+    verbosity?: 'minimal' | 'verbose';
+}
+/**
+ * Hub pipeline no longer exposes the legacy hooks runtime.
+ * Keep a tiny shim so existing callers can continue awaiting the same API surface.
+ */
+export declare function writeSnapshotViaHooks(_options: SnapshotHookOptions): Promise<void>;

package/dist/conversion/shared/snapshot-hooks.js

@@ -0,0 +1,7 @@
+/**
+ * Hub pipeline no longer exposes the legacy hooks runtime.
+ * Keep a tiny shim so existing callers can continue awaiting the same API surface.
+ */
+export async function writeSnapshotViaHooks(_options) {
+    return;
+}