@nvae/llmswitch 0.7.0 → 0.9.0

package/dist/bridge/chat-to-anthropic-request.js

@@ -0,0 +1,270 @@
+/**
+ * Translate OpenAI Chat Completions requests → Anthropic Messages API.
+ *
+ * Reverse direction of `anthropic-translate-request.ts`. Used by the gateway
+ * when an OpenAI-format client is routed to an Anthropic upstream.
+ */
+/** Anthropic requires max_tokens; use this when the client omits it. */
+export const DEFAULT_ANTHROPIC_MAX_TOKENS = 4096;
+function asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function parseDataUrl(url) {
+    const match = url.match(/^data:([^;,]+);base64,([\s\S]*)$/);
+    if (!match)
+        return null;
+    return { mediaType: match[1] ?? "image/png", data: match[2] ?? "" };
+}
+function imageBlock(url) {
+    const inline = parseDataUrl(url);
+    if (inline) {
+        return {
+            type: "image",
+            source: {
+                type: "base64",
+                media_type: inline.mediaType,
+                data: inline.data,
+            },
+        };
+    }
+    if (/^https?:\/\//i.test(url)) {
+        return { type: "image", source: { type: "url", url } };
+    }
+    return null;
+}
+/** Chat content (string or multimodal parts) → Anthropic content blocks. */
+export function chatContentToAnthropicBlocks(content) {
+    if (typeof content === "string") {
+        return content ? [{ type: "text", text: content }] : [];
+    }
+    if (!Array.isArray(content))
+        return [];
+    const blocks = [];
+    for (const raw of content) {
+        const part = asRecord(raw);
+        if (!part)
+            continue;
+        const type = String(part.type || "");
+        if ((type === "text" || type === "input_text" || type === "output_text") &&
+            typeof part.text === "string") {
+            blocks.push({ type: "text", text: part.text });
+            continue;
+        }
+        if (type === "image_url") {
+            const nested = asRecord(part.image_url);
+            const url = typeof nested?.url === "string"
+                ? nested.url
+                : typeof part.image_url === "string"
+                    ? part.image_url
+                    : "";
+            const block = url ? imageBlock(url) : null;
+            if (block)
+                blocks.push(block);
+            continue;
+        }
+        // Already an Anthropic-shaped block (image/document/thinking): keep as-is.
+        if (part.source || type === "thinking" || type === "redacted_thinking") {
+            blocks.push(part);
+            continue;
+        }
+        if (typeof part.text === "string") {
+            blocks.push({ type: "text", text: part.text });
+        }
+    }
+    return blocks;
+}
+function stringifyToolArguments(raw) {
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+        return raw;
+    }
+    if (typeof raw !== "string" || !raw.trim())
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Partial or non-JSON arguments: forward as a single field.
+    }
+    return { input: raw };
+}
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((raw) => {
+        const part = asRecord(raw);
+        return part && typeof part.text === "string" ? part.text : "";
+    })
+        .join("");
+}
+function pushMessage(messages, role, blocks) {
+    if (!blocks.length)
+        return;
+    const last = messages[messages.length - 1];
+    // Anthropic expects alternating roles; merge consecutive same-role turns.
+    if (last && last.role === role) {
+        last.content.push(...blocks);
+        return;
+    }
+    messages.push({ role, content: blocks });
+}
+export function chatMessagesToAnthropicMessages(chatMessages) {
+    const systemParts = [];
+    const messages = [];
+    for (const message of chatMessages) {
+        const role = String(message.role || "user");
+        if (role === "system" || role === "developer") {
+            const text = contentToText(message.content);
+            if (text)
+                systemParts.push(text);
+            continue;
+        }
+        if (role === "tool" || role === "function") {
+            const toolUseId = message.tool_call_id || message.name || "";
+            if (!toolUseId)
+                continue;
+            pushMessage(messages, "user", [
+                {
+                    type: "tool_result",
+                    tool_use_id: toolUseId,
+                    content: contentToText(message.content),
+                },
+            ]);
+            continue;
+        }
+        if (role === "assistant") {
+            const blocks = chatContentToAnthropicBlocks(message.content);
+            for (const call of message.tool_calls ?? []) {
+                blocks.push({
+                    type: "tool_use",
+                    id: call.id,
+                    name: call.function?.name || "tool",
+                    input: stringifyToolArguments(call.function?.arguments),
+                });
+            }
+            pushMessage(messages, "assistant", blocks);
+            continue;
+        }
+        pushMessage(messages, "user", chatContentToAnthropicBlocks(message.content));
+    }
+    return { system: systemParts.join("\n\n"), messages };
+}
+export function chatToolsToAnthropicTools(tools) {
+    if (!Array.isArray(tools) || !tools.length)
+        return undefined;
+    const out = [];
+    for (const tool of tools) {
+        const fn = tool?.function;
+        const name = String(fn?.name || "").trim();
+        if (!name)
+            continue;
+        const entry = {
+            name,
+            input_schema: fn?.parameters ?? { type: "object", properties: {} },
+        };
+        if (typeof fn?.description === "string")
+            entry.description = fn.description;
+        out.push(entry);
+    }
+    return out.length ? out : undefined;
+}
+export function chatToolChoiceToAnthropic(toolChoice) {
+    if (toolChoice == null)
+        return undefined;
+    if (toolChoice === "auto")
+        return { type: "auto" };
+    if (toolChoice === "required")
+        return { type: "any" };
+    if (toolChoice === "none")
+        return { type: "none" };
+    const obj = asRecord(toolChoice);
+    if (!obj)
+        return undefined;
+    if (obj.type === "function") {
+        const nested = asRecord(obj.function);
+        const name = String(nested?.name || obj.name || "");
+        return name ? { type: "tool", name } : { type: "auto" };
+    }
+    // Already Anthropic-shaped.
+    if (obj.type === "auto" || obj.type === "any" || obj.type === "tool") {
+        return obj;
+    }
+    return undefined;
+}
+function normalizeStop(stop) {
+    if (typeof stop === "string")
+        return stop ? [stop] : undefined;
+    if (Array.isArray(stop)) {
+        const list = stop.filter((v) => typeof v === "string");
+        return list.length ? list : undefined;
+    }
+    return undefined;
+}
+/**
+ * Chat Completions request → Anthropic Messages request body.
+ * `max_tokens` is mandatory upstream, so a default is applied when missing.
+ */
+export function chatToAnthropicRequest(body) {
+    const chatMessages = Array.isArray(body.messages)
+        ? body.messages
+        : [];
+    const { system, messages } = chatMessagesToAnthropicMessages(chatMessages);
+    const stream = Boolean(body.stream);
+    const maxTokens = typeof body.max_tokens === "number"
+        ? body.max_tokens
+        : typeof body.max_completion_tokens === "number"
+            ? body.max_completion_tokens
+            : DEFAULT_ANTHROPIC_MAX_TOKENS;
+    const out = {
+        model: String(body.model || ""),
+        max_tokens: maxTokens,
+        messages,
+        stream,
+    };
+    if (system)
+        out.system = system;
+    const tools = chatToolsToAnthropicTools(body.tools);
+    if (tools)
+        out.tools = tools;
+    if (body.tool_choice !== undefined) {
+        const choice = chatToolChoiceToAnthropic(body.tool_choice);
+        if (choice !== undefined)
+            out.tool_choice = choice;
+    }
+    if (typeof body.temperature === "number")
+        out.temperature = body.temperature;
+    if (typeof body.top_p === "number")
+        out.top_p = body.top_p;
+    const stopSequences = normalizeStop(body.stop);
+    if (stopSequences)
+        out.stop_sequences = stopSequences;
+    if (typeof body.metadata === "object" && body.metadata) {
+        out.metadata = body.metadata;
+    }
+    // Map OpenAI reasoning_effort onto Anthropic extended thinking budget.
+    const effort = body.reasoning_effort;
+    if (typeof effort === "string") {
+        const budget = effort === "low"
+            ? 1024
+            : effort === "medium"
+                ? 4096
+                : effort === "high"
+                    ? 8192
+                    : 0;
+        if (budget > 0) {
+            out.thinking = { type: "enabled", budget_tokens: budget };
+            // Thinking requires headroom above the budget.
+            if (maxTokens <= budget)
+                out.max_tokens = budget + 1024;
+        }
+    }
+    return out;
+}

package/dist/bridge/chat-to-responses-request.js

@@ -0,0 +1,216 @@
+/**
+ * Translate OpenAI Chat Completions requests → OpenAI Responses API.
+ *
+ * Reverse direction of `translate-request.ts`. Used by the gateway when a
+ * Chat-format client is routed to a Responses upstream.
+ */
+function asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((raw) => {
+        const part = asRecord(raw);
+        return part && typeof part.text === "string" ? part.text : "";
+    })
+        .join("");
+}
+/** Chat content parts → Responses input content parts. */
+function chatContentToInputParts(content, textType) {
+    if (typeof content === "string") {
+        return content ? [{ type: textType, text: content }] : [];
+    }
+    if (!Array.isArray(content))
+        return [];
+    const parts = [];
+    for (const raw of content) {
+        const part = asRecord(raw);
+        if (!part)
+            continue;
+        const type = String(part.type || "");
+        if ((type === "text" || type === "input_text" || type === "output_text") &&
+            typeof part.text === "string") {
+            parts.push({ type: textType, text: part.text });
+            continue;
+        }
+        if (type === "image_url") {
+            const nested = asRecord(part.image_url);
+            const url = typeof nested?.url === "string"
+                ? nested.url
+                : typeof part.image_url === "string"
+                    ? part.image_url
+                    : "";
+            if (url) {
+                const item = { type: "input_image", image_url: url };
+                if (typeof nested?.detail === "string")
+                    item.detail = nested.detail;
+                parts.push(item);
+            }
+            continue;
+        }
+        if (type === "input_audio") {
+            const nested = asRecord(part.input_audio);
+            if (nested)
+                parts.push({ type: "input_audio", input_audio: nested });
+            continue;
+        }
+        if (type === "file") {
+            const nested = asRecord(part.file);
+            if (nested)
+                parts.push({ type: "input_file", ...nested });
+            continue;
+        }
+        if (typeof part.text === "string") {
+            parts.push({ type: textType, text: part.text });
+        }
+    }
+    return parts;
+}
+export function chatMessagesToResponsesInput(chatMessages) {
+    const instructionParts = [];
+    const input = [];
+    for (const message of chatMessages) {
+        const role = String(message.role || "user");
+        if (role === "system" || role === "developer") {
+            const text = contentToText(message.content);
+            if (text)
+                instructionParts.push(text);
+            continue;
+        }
+        if (role === "tool" || role === "function") {
+            const callId = message.tool_call_id || message.name || "";
+            if (!callId)
+                continue;
+            input.push({
+                type: "function_call_output",
+                call_id: callId,
+                output: contentToText(message.content),
+            });
+            continue;
+        }
+        if (role === "assistant") {
+            const parts = chatContentToInputParts(message.content, "output_text");
+            if (parts.length) {
+                input.push({ type: "message", role: "assistant", content: parts });
+            }
+            for (const call of message.tool_calls ?? []) {
+                input.push({
+                    type: "function_call",
+                    call_id: call.id,
+                    name: call.function?.name || "tool",
+                    arguments: typeof call.function?.arguments === "string"
+                        ? call.function.arguments
+                        : JSON.stringify(call.function?.arguments ?? {}),
+                });
+            }
+            continue;
+        }
+        const parts = chatContentToInputParts(message.content, "input_text");
+        if (parts.length) {
+            input.push({ type: "message", role: "user", content: parts });
+        }
+    }
+    return { instructions: instructionParts.join("\n\n"), input };
+}
+export function chatToolsToResponsesTools(tools) {
+    if (!Array.isArray(tools) || !tools.length)
+        return undefined;
+    const out = [];
+    for (const tool of tools) {
+        const fn = tool?.function;
+        const name = String(fn?.name || "").trim();
+        if (!name)
+            continue;
+        const entry = {
+            type: "function",
+            name,
+            parameters: fn?.parameters ?? { type: "object", properties: {} },
+            strict: false,
+        };
+        if (typeof fn?.description === "string")
+            entry.description = fn.description;
+        out.push(entry);
+    }
+    return out.length ? out : undefined;
+}
+export function chatToolChoiceToResponses(toolChoice) {
+    if (toolChoice == null)
+        return undefined;
+    if (toolChoice === "auto" ||
+        toolChoice === "none" ||
+        toolChoice === "required") {
+        return toolChoice;
+    }
+    const obj = asRecord(toolChoice);
+    if (!obj)
+        return undefined;
+    if (obj.type === "function") {
+        const nested = asRecord(obj.function);
+        const name = String(nested?.name || obj.name || "");
+        return name ? { type: "function", name } : "auto";
+    }
+    return toolChoice;
+}
+/**
+ * Chat Completions request → Responses request body.
+ * `store` defaults to false: the gateway is stateless and must not create
+ * server-side conversation state on the upstream.
+ */
+export function chatToResponsesRequest(body) {
+    const chatMessages = Array.isArray(body.messages)
+        ? body.messages
+        : [];
+    const { instructions, input } = chatMessagesToResponsesInput(chatMessages);
+    const stream = Boolean(body.stream);
+    const out = {
+        model: String(body.model || ""),
+        input,
+        stream,
+        store: false,
+    };
+    if (instructions)
+        out.instructions = instructions;
+    const tools = chatToolsToResponsesTools(body.tools);
+    if (tools)
+        out.tools = tools;
+    if (body.tool_choice !== undefined) {
+        const choice = chatToolChoiceToResponses(body.tool_choice);
+        if (choice !== undefined)
+            out.tool_choice = choice;
+    }
+    if (typeof body.parallel_tool_calls === "boolean") {
+        out.parallel_tool_calls = body.parallel_tool_calls;
+    }
+    if (typeof body.temperature === "number")
+        out.temperature = body.temperature;
+    if (typeof body.top_p === "number")
+        out.top_p = body.top_p;
+    const maxOut = typeof body.max_completion_tokens === "number"
+        ? body.max_completion_tokens
+        : typeof body.max_tokens === "number"
+            ? body.max_tokens
+            : undefined;
+    if (typeof maxOut === "number")
+        out.max_output_tokens = maxOut;
+    if (typeof body.reasoning_effort === "string") {
+        out.reasoning = { effort: body.reasoning_effort };
+    }
+    const responseFormat = asRecord(body.response_format);
+    if (responseFormat) {
+        out.text = { format: responseFormat };
+    }
+    if (typeof body.metadata === "object" && body.metadata) {
+        out.metadata = body.metadata;
+    }
+    if (typeof body.user === "string" && body.user) {
+        out.user = body.user;
+    }
+    return out;
+}