@nvae/llmswitch 0.2.0

package/dist/bridge/translate-request.js

@@ -0,0 +1,385 @@
+/**
+ * Translate OpenAI Responses API requests → Chat Completions / Completions.
+ */
+function asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function extractText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const part of content) {
+        const row = asRecord(part);
+        if (!row)
+            continue;
+        if (typeof row.text === "string")
+            parts.push(row.text);
+        else if (typeof row.input_text === "string")
+            parts.push(row.input_text);
+        else if (typeof row.output_text === "string")
+            parts.push(row.output_text);
+        else if (row.type === "input_text" && typeof row.text === "string") {
+            parts.push(row.text);
+        }
+        else if (row.type === "output_text" && typeof row.text === "string") {
+            parts.push(row.text);
+        }
+        else if (row.type === "text" && typeof row.text === "string") {
+            parts.push(row.text);
+        }
+    }
+    return parts.join("");
+}
+function mapRole(role) {
+    if (role === "developer" || role === "system")
+        return "system";
+    if (role === "assistant")
+        return "assistant";
+    if (role === "tool")
+        return "tool";
+    return "user";
+}
+/**
+ * Convert Responses `input` (+ instructions) into Chat `messages`.
+ */
+export function responsesInputToMessages(body) {
+    const messages = [];
+    const instructions = body.instructions;
+    if (typeof instructions === "string" && instructions.trim()) {
+        messages.push({ role: "system", content: instructions });
+    }
+    const input = body.input;
+    if (typeof input === "string") {
+        messages.push({ role: "user", content: input });
+        return messages;
+    }
+    if (!Array.isArray(input))
+        return messages;
+    // Pending assistant tool_calls aggregation
+    let pendingToolCalls = [];
+    const flushToolCalls = () => {
+        if (pendingToolCalls.length === 0)
+            return;
+        messages.push({
+            role: "assistant",
+            content: null,
+            tool_calls: pendingToolCalls,
+        });
+        pendingToolCalls = [];
+    };
+    for (const raw of input) {
+        if (typeof raw === "string") {
+            flushToolCalls();
+            messages.push({ role: "user", content: raw });
+            continue;
+        }
+        const item = asRecord(raw);
+        if (!item)
+            continue;
+        const type = String(item.type || "message");
+        if (type === "message") {
+            flushToolCalls();
+            const role = mapRole(item.role);
+            const text = extractText(item.content);
+            messages.push({ role, content: text });
+            continue;
+        }
+        if (type === "function_call" || type === "custom_tool_call") {
+            const callId = String(item.call_id || item.id || `call_${messages.length}`);
+            const name = String(item.name || "tool");
+            let args;
+            if (type === "custom_tool_call") {
+                const input = typeof item.input === "string"
+                    ? item.input
+                    : typeof item.arguments === "string"
+                        ? item.arguments
+                        : JSON.stringify(item.input ?? item.arguments ?? {});
+                // Chat upstreams expect function.arguments to be a JSON object string.
+                args = JSON.stringify({ input });
+            }
+            else if (typeof item.arguments === "string") {
+                args = item.arguments;
+            }
+            else if (typeof item.input === "string") {
+                args = item.input;
+            }
+            else {
+                args = JSON.stringify(item.arguments ?? item.input ?? {});
+            }
+            pendingToolCalls.push({
+                id: callId,
+                type: "function",
+                function: { name, arguments: args },
+            });
+            continue;
+        }
+        if (type === "function_call_output" || type === "custom_tool_call_output") {
+            flushToolCalls();
+            const callId = String(item.call_id || "");
+            const output = typeof item.output === "string"
+                ? item.output
+                : JSON.stringify(item.output ?? "");
+            if (!callId)
+                continue;
+            messages.push({
+                role: "tool",
+                tool_call_id: callId,
+                content: output,
+            });
+            continue;
+        }
+        if (type === "reasoning") {
+            // Drop encrypted reasoning for chat upstreams
+            continue;
+        }
+        // Fallback: treat unknown items with text as user content
+        const text = extractText(item.content) || extractText(item);
+        if (text) {
+            flushToolCalls();
+            messages.push({ role: "user", content: text });
+        }
+    }
+    flushToolCalls();
+    return messages;
+}
+/**
+ * Names of Responses `type: "custom"` (freeform) tools.
+ * Chat upstreams only speak function tools; the response translator must
+ * convert matching tool_calls back to `custom_tool_call` for Codex.
+ */
+export function collectCustomToolNames(tools) {
+    const names = new Set();
+    if (!Array.isArray(tools))
+        return names;
+    for (const raw of tools) {
+        const tool = asRecord(raw);
+        if (!tool)
+            continue;
+        if (String(tool.type || "") !== "custom")
+            continue;
+        const name = String(tool.name || "").trim();
+        if (name)
+            names.add(name);
+    }
+    return names;
+}
+export function mapResponsesTools(tools) {
+    if (!Array.isArray(tools) || tools.length === 0)
+        return undefined;
+    const out = [];
+    for (const raw of tools) {
+        const tool = asRecord(raw);
+        if (!tool)
+            continue;
+        const type = String(tool.type || "function");
+        if (type === "function") {
+            // Already flat Responses style OR nested chat style
+            const nested = asRecord(tool.function);
+            if (nested) {
+                out.push({
+                    type: "function",
+                    function: {
+                        name: String(nested.name || "tool"),
+                        description: typeof nested.description === "string"
+                            ? nested.description
+                            : undefined,
+                        parameters: nested.parameters,
+                    },
+                });
+            }
+            else {
+                out.push({
+                    type: "function",
+                    function: {
+                        name: String(tool.name || "tool"),
+                        description: typeof tool.description === "string" ? tool.description : undefined,
+                        parameters: tool.parameters,
+                    },
+                });
+            }
+            continue;
+        }
+        // Map Codex local_shell / custom / hosted tools to chat function tools
+        if (type === "local_shell") {
+            out.push({
+                type: "function",
+                function: {
+                    name: "local_shell",
+                    description: "Run a local shell command",
+                    parameters: tool.parameters || {
+                        type: "object",
+                        properties: {
+                            command: { type: "array", items: { type: "string" } },
+                        },
+                    },
+                },
+            });
+            continue;
+        }
+        if (type === "custom") {
+            const description = typeof tool.description === "string"
+                ? tool.description
+                : "Custom freeform tool. Put the entire freeform payload in the input field; do not wrap it in extra JSON beyond the function arguments object.";
+            out.push({
+                type: "function",
+                function: {
+                    name: String(tool.name || "custom"),
+                    description,
+                    parameters: tool.parameters || {
+                        type: "object",
+                        properties: {
+                            input: {
+                                type: "string",
+                                description: "Freeform tool input (raw text, not nested JSON)",
+                            },
+                        },
+                        required: ["input"],
+                    },
+                },
+            });
+            continue;
+        }
+        // OpenAI hosted web_search is not available on chat upstreams; expose as a
+        // client-executed function so Codex can still run its local handler.
+        if (type === "web_search" || type === "web_search_preview") {
+            out.push({
+                type: "function",
+                function: {
+                    name: "web_search",
+                    description: typeof tool.description === "string"
+                        ? tool.description
+                        : "Search the web for current information",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            query: { type: "string", description: "Search query" },
+                        },
+                        required: ["query"],
+                    },
+                },
+            });
+            continue;
+        }
+        if (type === "tool_search") {
+            out.push({
+                type: "function",
+                function: {
+                    name: "tool_search",
+                    description: typeof tool.description === "string"
+                        ? tool.description
+                        : "Search for available tools",
+                    parameters: tool.parameters || {
+                        type: "object",
+                        properties: {
+                            query: { type: "string" },
+                        },
+                    },
+                },
+            });
+        }
+    }
+    return out.length ? out : undefined;
+}
+export function mapToolChoice(toolChoice) {
+    if (toolChoice == null || toolChoice === "auto" || toolChoice === "none" || toolChoice === "required") {
+        return toolChoice;
+    }
+    const obj = asRecord(toolChoice);
+    if (!obj)
+        return toolChoice;
+    if (obj.type === "function") {
+        const nested = asRecord(obj.function);
+        const name = String(nested?.name || obj.name || "");
+        if (!name)
+            return "auto";
+        return { type: "function", function: { name } };
+    }
+    return toolChoice;
+}
+export function responsesToChatRequest(body) {
+    const model = String(body.model || "");
+    const messages = responsesInputToMessages(body);
+    const stream = Boolean(body.stream);
+    const req = {
+        model,
+        messages,
+        stream,
+    };
+    if (stream) {
+        req.stream_options = { include_usage: true };
+    }
+    const tools = mapResponsesTools(body.tools);
+    if (tools)
+        req.tools = tools;
+    if (body.tool_choice !== undefined) {
+        req.tool_choice = mapToolChoice(body.tool_choice);
+    }
+    if (typeof body.parallel_tool_calls === "boolean") {
+        req.parallel_tool_calls = body.parallel_tool_calls;
+    }
+    if (typeof body.temperature === "number")
+        req.temperature = body.temperature;
+    if (typeof body.top_p === "number")
+        req.top_p = body.top_p;
+    const maxOut = body.max_output_tokens ?? body.max_tokens;
+    if (typeof maxOut === "number") {
+        req.max_tokens = maxOut;
+        req.max_completion_tokens = maxOut;
+    }
+    const reasoning = asRecord(body.reasoning);
+    if (reasoning && typeof reasoning.effort === "string") {
+        req.reasoning_effort = reasoning.effort;
+    }
+    const text = asRecord(body.text);
+    const format = text ? asRecord(text.format) : null;
+    if (format) {
+        req.response_format = format;
+    }
+    return req;
+}
+/**
+ * Degraded path: flatten chat messages into a single completions prompt.
+ * Tool calls are stringified; many Codex agent flows will not work well.
+ */
+export function chatToCompletionsRequest(chat) {
+    const lines = [];
+    for (const msg of chat.messages) {
+        const role = msg.role.toUpperCase();
+        let content = "";
+        if (typeof msg.content === "string")
+            content = msg.content;
+        else if (msg.content == null && msg.tool_calls) {
+            content = JSON.stringify(msg.tool_calls);
+        }
+        else if (Array.isArray(msg.content)) {
+            content = extractText(msg.content);
+        }
+        if (msg.tool_call_id) {
+            lines.push(`[TOOL ${msg.tool_call_id}]: ${content}`);
+        }
+        else {
+            lines.push(`${role}: ${content}`);
+        }
+    }
+    lines.push("ASSISTANT:");
+    const req = {
+        model: chat.model,
+        prompt: lines.join("\n\n"),
+        stream: chat.stream,
+    };
+    if (typeof chat.temperature === "number")
+        req.temperature = chat.temperature;
+    if (typeof chat.top_p === "number")
+        req.top_p = chat.top_p;
+    if (typeof chat.max_tokens === "number")
+        req.max_tokens = chat.max_tokens;
+    return req;
+}
+export function responsesToCompletionsRequest(body) {
+    return chatToCompletionsRequest(responsesToChatRequest(body));
+}