llm-simple-router 0.8.2 → 0.9.4

package/dist/proxy/transform/request-bridge-responses.js

@@ -0,0 +1,311 @@
+/**
+ * Bridge (lossy) request transformation between OpenAI Responses API
+ * and OpenAI Chat Completions API.
+ *
+ * This is the SECONDARY conversion path used when the upstream provider
+ * only supports the opposite API format. It is lossy because Chat Completions
+ * cannot represent `previous_response_id`, built-in tools, or structured
+ * reasoning items.
+ */
+// ---------- Responses → Chat Completions ----------
+/**
+ * Convert an OpenAI Responses API request body to an OpenAI Chat Completions
+ * request body.
+ */
+export function responsesToChatRequest(body) {
+    const result = {};
+    result.model = body.model;
+    // instructions → system message
+    const messages = [];
+    if (body.instructions != null && body.instructions !== "") {
+        messages.push({ role: "system", content: String(body.instructions) });
+    }
+    // input → messages
+    convertResponsesInputToChatMessages(body.input, messages);
+    result.messages = messages;
+    // max_output_tokens → max_completion_tokens
+    if (body.max_output_tokens != null) {
+        result.max_completion_tokens = body.max_output_tokens;
+    }
+    // Pass-through fields
+    if (body.temperature != null)
+        result.temperature = body.temperature;
+    if (body.top_p != null)
+        result.top_p = body.top_p;
+    if (body.stream != null)
+        result.stream = body.stream;
+    // tools: Responses format → Chat Completions format
+    const tools = body.tools;
+    if (tools) {
+        const chatTools = [];
+        for (const t of tools) {
+            if (t.type === "function") {
+                // Responses tools are flat: {type:"function", name, parameters, description}
+                // Chat tools need function wrapper: {type:"function", function:{name, parameters}}
+                const fn = { name: String(t.name) };
+                if (t.description != null)
+                    fn.description = String(t.description);
+                if (t.parameters != null)
+                    fn.parameters = t.parameters;
+                chatTools.push({ type: "function", function: fn });
+            }
+            // Non-function tools (web_search_preview, file_search, etc.) → skip
+        }
+        if (chatTools.length > 0) {
+            result.tools = chatTools;
+        }
+    }
+    // tool_choice — compatible between Chat and Responses
+    if (body.tool_choice != null) {
+        result.tool_choice = body.tool_choice;
+    }
+    // reasoning — pass through (both use {effort?, max_tokens?})
+    if (body.reasoning != null) {
+        result.reasoning = body.reasoning;
+    }
+    // text.format → response_format
+    const text = body.text;
+    if (text?.format != null) {
+        result.response_format = text.format;
+    }
+    // stream_options
+    if (body.stream_options != null) {
+        result.stream_options = body.stream_options;
+    }
+    return result;
+}
+/**
+ * Convert Responses `input` (string | ResponseInputItem[]) into Chat
+ * Completions `messages[]`, appending to the provided array.
+ */
+function convertResponsesInputToChatMessages(input, messages) {
+    if (input == null)
+        return;
+    // String shorthand → single user message
+    if (typeof input === "string") {
+        messages.push({ role: "user", content: input });
+        return;
+    }
+    if (!Array.isArray(input))
+        return;
+    // Track pending function_calls to merge into a single assistant message
+    const pendingFnCalls = [];
+    for (const item of input) {
+        const type = item.type;
+        // Flush any pending function_calls before processing non-function_call items
+        if (type !== "function_call" && pendingFnCalls.length > 0) {
+            flushFunctionCalls(messages, pendingFnCalls);
+        }
+        if (type === "message") {
+            // ResponseInputMessage → Chat message
+            const role = item.role;
+            const content = extractMessageTextContent(item);
+            messages.push({ role, content });
+        }
+        else if (type === "input_text") {
+            messages.push({ role: "user", content: String(item.text ?? "") });
+        }
+        else if (type === "function_call") {
+            // Collect; will be flushed when next non-function_call item appears
+            // or at end of loop
+            const fn = {
+                name: String(item.name ?? ""),
+                arguments: String(item.arguments ?? "{}"),
+            };
+            pendingFnCalls.push({
+                id: String(item.id ?? ""),
+                type: "function",
+                function: fn,
+            });
+        }
+        else if (type === "function_call_output") {
+            messages.push({
+                role: "tool",
+                tool_call_id: String(item.call_id ?? ""),
+                content: String(item.output ?? ""),
+            });
+        }
+        else if (type === "reasoning") {
+            // No Chat Completions equivalent — skip
+        }
+        // Unknown item types → skip
+    }
+    // Flush any remaining pending function_calls
+    if (pendingFnCalls.length > 0) {
+        flushFunctionCalls(messages, pendingFnCalls);
+    }
+}
+/**
+ * Flush accumulated function_call tool_calls into a single assistant message.
+ */
+function flushFunctionCalls(messages, pending) {
+    messages.push({
+        role: "assistant",
+        content: null,
+        tool_calls: [...pending],
+    });
+    pending.length = 0;
+}
+/**
+ * Extract text content from a ResponseInputMessage.
+ */
+function extractMessageTextContent(msg) {
+    const content = msg.content;
+    if (content == null)
+        return "";
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((p) => p.type === "input_text" && p.text != null)
+            .map((p) => String(p.text))
+            .join("");
+    }
+    return "";
+}
+// ---------- Chat Completions → Responses ----------
+/**
+ * Convert an OpenAI Chat Completions request body to an OpenAI Responses API
+ * request body.
+ */
+export function chatToResponsesRequest(body) {
+    const result = {};
+    result.model = body.model;
+    // Extract instructions from system/developer messages
+    const messages = body.messages;
+    const { instructions, nonSystemMsgs } = extractChatInstructions(messages ?? []);
+    if (instructions) {
+        result.instructions = instructions;
+    }
+    // Convert non-system messages → input items
+    result.input = convertChatMessagesToResponsesInput(nonSystemMsgs);
+    // max_completion_tokens / max_tokens → max_output_tokens
+    if (body.max_completion_tokens != null) {
+        result.max_output_tokens = body.max_completion_tokens;
+    }
+    else if (body.max_tokens != null) {
+        result.max_output_tokens = body.max_tokens;
+    }
+    // Pass-through fields
+    if (body.temperature != null)
+        result.temperature = body.temperature;
+    if (body.top_p != null)
+        result.top_p = body.top_p;
+    if (body.stream != null)
+        result.stream = body.stream;
+    // tools: Chat format → Responses format
+    const tools = body.tools;
+    if (tools) {
+        const respTools = [];
+        for (const t of tools) {
+            if (t.type === "function" && t.function) {
+                // Chat: {type:"function", function:{name, parameters, description}}
+                // Responses: {type:"function", name, parameters, description}
+                const fn = t.function;
+                const mapped = {
+                    type: "function",
+                    name: String(fn.name),
+                };
+                if (fn.description != null)
+                    mapped.description = String(fn.description);
+                if (fn.parameters != null)
+                    mapped.parameters = fn.parameters;
+                respTools.push(mapped);
+            }
+            // Non-function tools → skip
+        }
+        if (respTools.length > 0) {
+            result.tools = respTools;
+        }
+    }
+    // tool_choice — compatible
+    if (body.tool_choice != null) {
+        result.tool_choice = body.tool_choice;
+    }
+    // reasoning — pass through
+    if (body.reasoning != null) {
+        result.reasoning = body.reasoning;
+    }
+    // response_format → text.format
+    if (body.response_format != null) {
+        result.text = { format: body.response_format };
+    }
+    // stream_options
+    if (body.stream_options != null) {
+        result.stream_options = body.stream_options;
+    }
+    return result;
+}
+/**
+ * Extract system/developer messages from Chat messages as instructions.
+ */
+function extractChatInstructions(messages) {
+    const parts = [];
+    const nonSystemMsgs = [];
+    for (const msg of messages) {
+        const role = msg.role;
+        if (role === "system" || role === "developer") {
+            parts.push(String(msg.content ?? ""));
+        }
+        else {
+            nonSystemMsgs.push(msg);
+        }
+    }
+    return {
+        instructions: parts.length > 0 ? parts.join("\n") : "",
+        nonSystemMsgs,
+    };
+}
+/**
+ * Convert Chat Completions non-system messages → Responses input items.
+ */
+function convertChatMessagesToResponsesInput(messages) {
+    const items = [];
+    for (const msg of messages) {
+        const role = msg.role;
+        if (role === "user") {
+            const content = msg.content;
+            const text = typeof content === "string" ? content : String(content ?? "");
+            items.push({
+                type: "message",
+                role: "user",
+                content: [{ type: "input_text", text }],
+            });
+        }
+        else if (role === "assistant") {
+            // Text content → assistant message with output_text
+            const content = msg.content;
+            if (content != null && content !== "" && content !== null) {
+                const text = typeof content === "string" ? content : String(content);
+                items.push({
+                    type: "message",
+                    role: "assistant",
+                    content: [{ type: "output_text", text }],
+                });
+            }
+            // tool_calls → function_call items
+            const toolCalls = msg.tool_calls;
+            if (toolCalls) {
+                for (const tc of toolCalls) {
+                    const fn = tc.function;
+                    items.push({
+                        type: "function_call",
+                        id: String(tc.id ?? ""),
+                        call_id: String(tc.id ?? ""),
+                        name: String(fn?.name ?? ""),
+                        arguments: String(fn?.arguments ?? "{}"),
+                    });
+                }
+            }
+        }
+        else if (role === "tool") {
+            items.push({
+                type: "function_call_output",
+                call_id: String(msg.tool_call_id ?? ""),
+                output: String(msg.content ?? ""),
+            });
+        }
+        // reasoning_content in messages → skip (can't create reasoning items)
+    }
+    return items;
+}

package/dist/proxy/transform/request-transform-responses.d.ts

@@ -0,0 +1,2 @@
+export declare function responsesToAnthropicRequest(body: Record<string, unknown>): Record<string, unknown>;
+export declare function anthropicToResponsesRequest(body: Record<string, unknown>): Record<string, unknown>;

package/dist/proxy/transform/request-transform-responses.js

@@ -0,0 +1,350 @@
+import { sanitizeToolUseId, parseToolArguments } from "./sanitize.js";
+// ---------- Effort → budget mapping (shared with thinking-mapper) ----------
+const EFFORT_BUDGET = { low: 1024, medium: 8192, high: 32768 };
+const DEFAULT_BUDGET = 8192;
+// ---------- Helpers ----------
+/** Strip "toolu_" prefix from a tool_use_id to recover the original call_id. */
+function stripTooluPrefix(id) {
+    return id.startsWith("toolu_") ? id.slice(6) : id;
+}
+/** Merge consecutive same-role messages to satisfy Anthropic strict alternation. */
+function mergeConsecutiveMessages(msgs) {
+    const merged = [];
+    for (const msg of msgs) {
+        const prev = merged[merged.length - 1];
+        if (prev && prev.role === msg.role) {
+            prev.content = [...prev.content, ...msg.content];
+        }
+        else {
+            merged.push({ ...msg, content: [...msg.content] });
+        }
+    }
+    return merged;
+}
+/** Ensure first message has role "user" (prepend empty user if needed). */
+function ensureFirstIsUser(msgs) {
+    if (msgs.length > 0 && msgs[0].role !== "user") {
+        msgs.unshift({ role: "user", content: [{ type: "text", text: "" }] });
+    }
+    return msgs;
+}
+// ---------- Responses → Anthropic ----------
+export function responsesToAnthropicRequest(body) {
+    const result = {};
+    result.model = body.model;
+    // instructions → system
+    if (body.instructions != null) {
+        result.system = String(body.instructions);
+    }
+    // input → messages
+    result.messages = convertResponsesInputToAntMessages(body.input);
+    // max_output_tokens → max_tokens
+    if (body.max_output_tokens != null) {
+        result.max_tokens = body.max_output_tokens;
+    }
+    // temperature, top_p, stream — pass through
+    if (body.temperature != null)
+        result.temperature = body.temperature;
+    if (body.top_p != null)
+        result.top_p = body.top_p;
+    if (body.stream != null)
+        result.stream = body.stream;
+    // tools: only function-type tools are forwarded
+    const tools = body.tools;
+    if (tools) {
+        const fnTools = tools.filter(t => t.type === "function");
+        if (fnTools.length > 0 && body.tool_choice !== "none") {
+            result.tools = fnTools.map(t => {
+                const mapped = { name: String(t.name) };
+                if (t.description != null)
+                    mapped.description = String(t.description);
+                if (t.parameters != null)
+                    mapped.input_schema = t.parameters;
+                return mapped;
+            });
+            // tool_choice mapping
+            if (body.tool_choice != null && body.tool_choice !== "none") {
+                const tc = mapToolChoiceResponses2Ant(body.tool_choice);
+                if (tc != null) {
+                    result.tool_choice = body.parallel_tool_calls === false
+                        ? { ...tc, disable_parallel_tool_use: true }
+                        : tc;
+                }
+            }
+            else if (body.parallel_tool_calls === false) {
+                result.tool_choice = { type: "auto", disable_parallel_tool_use: true };
+            }
+        }
+    }
+    // reasoning → thinking
+    if (body.reasoning) {
+        const reasoning = body.reasoning;
+        const effort = reasoning.effort;
+        const maxTokens = reasoning.max_tokens;
+        const budget = maxTokens ?? EFFORT_BUDGET[effort ?? ""] ?? DEFAULT_BUDGET;
+        result.thinking = { type: "enabled", budget_tokens: budget };
+        // Ensure max_tokens >= budget_tokens
+        if (result.max_tokens != null && result.max_tokens < budget) {
+            result.max_tokens = budget;
+        }
+    }
+    // metadata.user_id
+    const meta = body.metadata;
+    if (meta?.user_id) {
+        result.metadata = { user_id: meta.user_id };
+    }
+    return result;
+}
+/** Convert Responses input (string | ResponseInputItem[]) → Anthropic messages. */
+function convertResponsesInputToAntMessages(input) {
+    if (input == null)
+        return [];
+    // String shorthand → single user message
+    if (typeof input === "string") {
+        return [{ role: "user", content: [{ type: "text", text: input }] }];
+    }
+    if (!Array.isArray(input))
+        return [];
+    const raw = [];
+    for (const item of input) {
+        const type = item.type;
+        if (type === "message") {
+            // ResponseInputMessage: extract content as AnthropicContentBlock[]
+            const role = item.role;
+            const content = extractMessageContent(item);
+            raw.push({ role, content });
+        }
+        else if (type === "function_call") {
+            // → assistant tool_use (Anthropic requires "toolu_" prefix)
+            const rawId = String(item.call_id ?? item.id ?? "");
+            const antId = rawId.startsWith("toolu_") ? rawId : `toolu_${rawId}`;
+            raw.push({
+                role: "assistant",
+                content: [{
+                        type: "tool_use",
+                        id: sanitizeToolUseId(antId),
+                        name: String(item.name ?? ""),
+                        input: parseToolArguments(item.arguments),
+                    }],
+            });
+        }
+        else if (type === "function_call_output") {
+            // → user tool_result (Anthropic requires "toolu_" prefix)
+            const rawCallId = String(item.call_id ?? "");
+            const antCallId = rawCallId.startsWith("toolu_") ? rawCallId : `toolu_${rawCallId}`;
+            raw.push({
+                role: "user",
+                content: [{
+                        type: "tool_result",
+                        tool_use_id: sanitizeToolUseId(antCallId),
+                        content: String(item.output ?? ""),
+                    }],
+            });
+        }
+        else if (type === "reasoning") {
+            // → assistant thinking
+            const summary = item.summary;
+            const thinkingText = summary
+                ? summary.map(s => String(s.text ?? "")).join("\n")
+                : "";
+            raw.push({
+                role: "assistant",
+                content: [{ type: "thinking", thinking: thinkingText }],
+            });
+        }
+        else if (type === "input_text") {
+            // → user text
+            raw.push({
+                role: "user",
+                content: [{ type: "text", text: String(item.text ?? "") }],
+            });
+        }
+    }
+    const merged = mergeConsecutiveMessages(raw);
+    ensureFirstIsUser(merged);
+    return merged;
+}
+/** Extract content blocks from a ResponseInputMessage. */
+function extractMessageContent(msg) {
+    const content = msg.content;
+    if (content == null)
+        return [];
+    if (typeof content === "string") {
+        return [{ type: "text", text: content }];
+    }
+    if (Array.isArray(content)) {
+        return content.flatMap((part) => {
+            if (part.type === "input_text" && part.text != null) {
+                return [{ type: "text", text: String(part.text) }];
+            }
+            return [];
+        });
+    }
+    return [];
+}
+/** Map Responses tool_choice → Anthropic tool_choice. */
+function mapToolChoiceResponses2Ant(tc) {
+    if (tc === "auto")
+        return { type: "auto" };
+    if (tc === "required")
+        return { type: "any" };
+    if (tc === "none")
+        return undefined;
+    if (typeof tc === "object" && tc !== null) {
+        const obj = tc;
+        if (obj.type === "function" && obj.name) {
+            return { type: "tool", name: String(obj.name) };
+        }
+    }
+    return { type: "auto" };
+}
+// ---------- Anthropic → Responses ----------
+export function anthropicToResponsesRequest(body) {
+    const result = {};
+    result.model = body.model;
+    // system → instructions
+    if (body.system != null) {
+        if (typeof body.system === "string") {
+            result.instructions = body.system;
+        }
+        else if (Array.isArray(body.system)) {
+            result.instructions = body.system
+                .map(b => String(b.text ?? ""))
+                .join("\n");
+        }
+        else {
+            result.instructions = String(body.system);
+        }
+    }
+    // messages → input items
+    const antMessages = body.messages;
+    result.input = antMessages ? convertAntMessagesToResponsesInput(antMessages) : [];
+    // max_tokens → max_output_tokens
+    if (body.max_tokens != null)
+        result.max_output_tokens = body.max_tokens;
+    // temperature, top_p, stream — pass through
+    if (body.temperature != null)
+        result.temperature = body.temperature;
+    if (body.top_p != null)
+        result.top_p = body.top_p;
+    if (body.stream != null)
+        result.stream = body.stream;
+    // tools
+    const tools = body.tools;
+    if (tools && tools.length > 0) {
+        result.tools = tools.map(t => {
+            const mapped = {
+                type: "function",
+                name: String(t.name),
+            };
+            if (t.description != null)
+                mapped.description = String(t.description);
+            if (t.input_schema != null)
+                mapped.parameters = t.input_schema;
+            return mapped;
+        });
+    }
+    // tool_choice
+    if (body.tool_choice != null) {
+        const tc = mapToolChoiceAnt2Responses(body.tool_choice);
+        if (tc != null)
+            result.tool_choice = tc;
+    }
+    // thinking → reasoning
+    if (body.thinking) {
+        const thinking = body.thinking;
+        if (thinking.type === "enabled" && thinking.budget_tokens != null) {
+            result.reasoning = { max_tokens: thinking.budget_tokens };
+        }
+    }
+    // metadata.user_id
+    const meta = body.metadata;
+    if (meta?.user_id) {
+        result.metadata = { user_id: meta.user_id };
+    }
+    return result;
+}
+/** Convert Anthropic messages → Responses input items. */
+function convertAntMessagesToResponsesInput(messages) {
+    const items = [];
+    for (const msg of messages) {
+        const role = msg.role;
+        const content = msg.content;
+        if (!content || !Array.isArray(content))
+            continue;
+        if (role === "user") {
+            // Separate text blocks and tool_result blocks
+            const textBlocks = content.filter(b => b.type === "text");
+            const toolResultBlocks = content.filter(b => b.type === "tool_result");
+            if (textBlocks.length > 0) {
+                const text = textBlocks.map(b => String(b.text ?? "")).join("");
+                items.push({
+                    type: "message",
+                    role: "user",
+                    content: [{ type: "input_text", text }],
+                });
+            }
+            for (const tr of toolResultBlocks) {
+                items.push({
+                    type: "function_call_output",
+                    call_id: stripTooluPrefix(String(tr.tool_use_id ?? "")),
+                    output: String(tr.content ?? ""),
+                });
+            }
+        }
+        else if (role === "assistant") {
+            const textBlocks = content.filter(b => b.type === "text");
+            const toolUseBlocks = content.filter(b => b.type === "tool_use");
+            const thinkingBlocks = content.filter(b => b.type === "thinking");
+            // thinking → reasoning items
+            for (const tb of thinkingBlocks) {
+                items.push({
+                    type: "reasoning",
+                    id: `rs_${Date.now()}_${items.length}`,
+                    summary: [{ type: "summary_text", text: String(tb.thinking ?? "") }],
+                });
+            }
+            // text → assistant message
+            if (textBlocks.length > 0) {
+                const text = textBlocks.map(b => String(b.text ?? "")).join("");
+                items.push({
+                    type: "message",
+                    role: "assistant",
+                    content: [{ type: "output_text", text }],
+                });
+            }
+            // tool_use → function_call
+            for (const tu of toolUseBlocks) {
+                items.push({
+                    type: "function_call",
+                    id: String(tu.id ?? ""),
+                    call_id: stripTooluPrefix(String(tu.id ?? "")),
+                    name: String(tu.name ?? ""),
+                    arguments: JSON.stringify(tu.input ?? {}),
+                });
+            }
+        }
+    }
+    return items;
+}
+/** Map Anthropic tool_choice → Responses tool_choice. */
+function mapToolChoiceAnt2Responses(tc) {
+    if (typeof tc === "string") {
+        if (tc === "auto")
+            return "auto";
+        if (tc === "any")
+            return "required";
+        return "auto";
+    }
+    if (typeof tc === "object" && tc !== null) {
+        const obj = tc;
+        if (obj.type === "auto")
+            return "auto";
+        if (obj.type === "any")
+            return "required";
+        if (obj.type === "tool" && obj.name) {
+            return { type: "function", name: String(obj.name) };
+        }
+    }
+    return "auto";
+}

package/dist/proxy/transform/response-bridge-responses.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Bridge (lossy) response transformation between OpenAI Responses API
+ * and OpenAI Chat Completions API.
+ *
+ * This is the SECONDARY conversion path used when the upstream provider
+ * only supports the opposite API format. It is lossy because Chat Completions
+ * cannot represent structured reasoning summaries, built-in tool outputs,
+ * or response-level metadata.
+ */
+/**
+ * Convert a Responses API response body to a Chat Completions response body.
+ *
+ * Lossy: structured reasoning summaries are flattened to a single string;
+ * built-in tool output items (web_search_call, etc.) are skipped.
+ */
+export declare function responsesToChatResponse(bodyStr: string): string;
+/**
+ * Convert a Chat Completions response body to a Responses API response body.
+ *
+ * Lossy: Chat Completions has no equivalent for built-in tool output items
+ * or structured reasoning summaries.
+ */
+export declare function chatToResponsesResponse(bodyStr: string): string;