@nvae/llmswitch 0.6.0 → 0.8.0

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

@@ -0,0 +1,393 @@
+/**
+ * Translate OpenAI Responses API results (stream/non-stream) → Chat Completions.
+ *
+ * Reverse direction of `translate-response.ts`. Used by the gateway when a
+ * Responses upstream must be presented in Chat Completions shape (the
+ * gateway's hub format).
+ */
+function newId(prefix) {
+    return `${prefix}-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
+}
+function asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function numberOr(value, fallback = 0) {
+    return typeof value === "number" ? value : fallback;
+}
+function mapUsage(usage) {
+    if (!usage)
+        return undefined;
+    const prompt = numberOr(usage.input_tokens, numberOr(usage.prompt_tokens));
+    const completion = numberOr(usage.output_tokens, numberOr(usage.completion_tokens));
+    const out = {
+        prompt_tokens: prompt,
+        completion_tokens: completion,
+        total_tokens: numberOr(usage.total_tokens, prompt + completion),
+    };
+    const details = asRecord(usage.output_tokens_details);
+    if (details && typeof details.reasoning_tokens === "number") {
+        out.completion_tokens_details = {
+            reasoning_tokens: details.reasoning_tokens,
+        };
+    }
+    const inputDetails = asRecord(usage.input_tokens_details);
+    if (inputDetails && typeof inputDetails.cached_tokens === "number") {
+        out.prompt_tokens_details = { cached_tokens: inputDetails.cached_tokens };
+    }
+    return out;
+}
+/** Responses status → Chat Completions finish_reason. */
+export function responsesStatusToFinishReason(status, incompleteDetails) {
+    if (status === "incomplete") {
+        return incompleteDetails?.reason === "content_filter"
+            ? "content_filter"
+            : "length";
+    }
+    return "stop";
+}
+function extractOutputText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const raw of content) {
+        const part = asRecord(raw);
+        if (!part)
+            continue;
+        if (typeof part.text === "string")
+            parts.push(part.text);
+    }
+    return parts.join("");
+}
+function extractReasoning(item) {
+    const summary = Array.isArray(item.summary) ? item.summary : [];
+    const parts = [];
+    for (const raw of summary) {
+        const entry = asRecord(raw);
+        if (entry && typeof entry.text === "string")
+            parts.push(entry.text);
+        else if (typeof raw === "string")
+            parts.push(raw);
+    }
+    if (!parts.length && typeof item.text === "string")
+        parts.push(item.text);
+    return parts.join("\n");
+}
+/** Custom (freeform) tool input → Chat function arguments JSON string. */
+function customInputToArguments(input) {
+    const raw = typeof input === "string" ? input : "";
+    try {
+        return JSON.stringify({ input: raw });
+    }
+    catch {
+        return "{}";
+    }
+}
+/** Non-streaming Responses object → Chat Completions object. */
+export function responseToChatCompletion(response, fallbackModel = "") {
+    const output = Array.isArray(response.output) ? response.output : [];
+    const textParts = [];
+    const reasoningParts = [];
+    const toolCalls = [];
+    for (const raw of output) {
+        const item = asRecord(raw);
+        if (!item)
+            continue;
+        const type = String(item.type || "");
+        if (type === "message") {
+            const text = extractOutputText(item.content);
+            if (text)
+                textParts.push(text);
+            continue;
+        }
+        if (type === "reasoning") {
+            const text = extractReasoning(item);
+            if (text)
+                reasoningParts.push(text);
+            continue;
+        }
+        if (type === "function_call") {
+            toolCalls.push({
+                index: toolCalls.length,
+                id: String(item.call_id || item.id || newId("call")),
+                type: "function",
+                function: {
+                    name: String(item.name || "tool"),
+                    arguments: typeof item.arguments === "string"
+                        ? item.arguments
+                        : JSON.stringify(item.arguments ?? {}),
+                },
+            });
+            continue;
+        }
+        if (type === "custom_tool_call") {
+            toolCalls.push({
+                index: toolCalls.length,
+                id: String(item.call_id || item.id || newId("call")),
+                type: "function",
+                function: {
+                    name: String(item.name || "tool"),
+                    arguments: customInputToArguments(item.input),
+                },
+            });
+        }
+    }
+    const message = {
+        role: "assistant",
+        content: textParts.length ? textParts.join("") : null,
+    };
+    if (reasoningParts.length) {
+        message.reasoning_content = reasoningParts.join("\n");
+    }
+    if (toolCalls.length)
+        message.tool_calls = toolCalls;
+    const finishReason = toolCalls.length
+        ? "tool_calls"
+        : responsesStatusToFinishReason(response.status, asRecord(response.incomplete_details));
+    const out = {
+        id: typeof response.id === "string" && response.id
+            ? response.id.replace(/^resp_/, "chatcmpl-")
+            : newId("chatcmpl"),
+        object: "chat.completion",
+        created: numberOr(response.created_at, Math.floor(Date.now() / 1000)),
+        model: String(response.model || fallbackModel || ""),
+        choices: [
+            { index: 0, message, finish_reason: finishReason, logprobs: null },
+        ],
+    };
+    const usage = mapUsage(asRecord(response.usage));
+    if (usage)
+        out.usage = usage;
+    return out;
+}
+export function createResponsesToChatStreamState(model, options = {}) {
+    return {
+        id: newId("chatcmpl"),
+        model,
+        created: Math.floor(Date.now() / 1000),
+        items: new Map(),
+        nextToolIndex: 0,
+        roleEmitted: false,
+        finishReason: null,
+        usage: undefined,
+        completed: false,
+        includeUsage: options.includeUsage !== false,
+    };
+}
+function chunk(state, delta, finishReason = null) {
+    return {
+        id: state.id,
+        object: "chat.completion.chunk",
+        created: state.created,
+        model: state.model,
+        choices: [{ index: 0, delta, finish_reason: finishReason, logprobs: null }],
+    };
+}
+function ensureRole(state, out) {
+    if (state.roleEmitted)
+        return;
+    state.roleEmitted = true;
+    out.push(chunk(state, { role: "assistant", content: "" }));
+}
+/** Parse one Responses SSE line; the JSON payload carries the event `type`. */
+export function parseResponsesSseLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("data:"))
+        return null;
+    const data = trimmed.slice(5).trim();
+    if (!data)
+        return null;
+    if (data === "[DONE]")
+        return "done";
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+export class ResponsesStreamError extends Error {
+    errorType;
+    constructor(message, errorType = "api_error") {
+        super(message);
+        this.errorType = errorType;
+        this.name = "ResponsesStreamError";
+    }
+}
+function toolEntryFor(state, itemId) {
+    if (!itemId)
+        return undefined;
+    return state.items.get(itemId);
+}
+/**
+ * Convert one Responses SSE event into zero or more Chat Completions chunks.
+ * Throws `ResponsesStreamError` on upstream error/failed events.
+ */
+export function responsesEventToChatChunks(event, state) {
+    const out = [];
+    const type = String(event.type || "");
+    if (type === "response.created" || type === "response.in_progress") {
+        const response = asRecord(event.response);
+        if (response) {
+            if (typeof response.model === "string" && response.model) {
+                state.model = response.model;
+            }
+            if (typeof response.id === "string" && response.id) {
+                state.id = response.id.replace(/^resp_/, "chatcmpl-");
+            }
+        }
+        ensureRole(state, out);
+        return out;
+    }
+    if (type === "response.output_item.added") {
+        ensureRole(state, out);
+        const item = asRecord(event.item);
+        if (!item)
+            return out;
+        const itemType = String(item.type || "");
+        if (itemType !== "function_call" && itemType !== "custom_tool_call") {
+            return out;
+        }
+        const itemId = String(item.id || "");
+        const entry = {
+            toolIndex: state.nextToolIndex++,
+            callId: String(item.call_id || item.id || newId("call")),
+            name: String(item.name || "tool"),
+            custom: itemType === "custom_tool_call",
+            customInput: "",
+            emittedStart: true,
+        };
+        if (itemId)
+            state.items.set(itemId, entry);
+        out.push(chunk(state, {
+            tool_calls: [
+                {
+                    index: entry.toolIndex,
+                    id: entry.callId,
+                    type: "function",
+                    function: { name: entry.name, arguments: "" },
+                },
+            ],
+        }));
+        return out;
+    }
+    if (type === "response.output_text.delta" ||
+        type === "response.refusal.delta") {
+        ensureRole(state, out);
+        const delta = event.delta;
+        if (typeof delta === "string" && delta) {
+            out.push(chunk(state, { content: delta }));
+        }
+        return out;
+    }
+    if (type === "response.reasoning_summary_text.delta" ||
+        type === "response.reasoning_text.delta") {
+        ensureRole(state, out);
+        const delta = event.delta;
+        if (typeof delta === "string" && delta) {
+            out.push(chunk(state, { reasoning_content: delta }));
+        }
+        return out;
+    }
+    if (type === "response.function_call_arguments.delta") {
+        const entry = toolEntryFor(state, String(event.item_id || ""));
+        const delta = event.delta;
+        if (entry && typeof delta === "string" && delta) {
+            out.push(chunk(state, {
+                tool_calls: [
+                    { index: entry.toolIndex, function: { arguments: delta } },
+                ],
+            }));
+        }
+        return out;
+    }
+    if (type === "response.custom_tool_call_input.delta") {
+        const entry = toolEntryFor(state, String(event.item_id || ""));
+        const delta = event.delta;
+        // Freeform input is not valid JSON; buffer and emit once complete.
+        if (entry && typeof delta === "string")
+            entry.customInput += delta;
+        return out;
+    }
+    if (type === "response.custom_tool_call_input.done") {
+        const entry = toolEntryFor(state, String(event.item_id || ""));
+        if (entry) {
+            const input = typeof event.input === "string" ? event.input : entry.customInput;
+            out.push(chunk(state, {
+                tool_calls: [
+                    {
+                        index: entry.toolIndex,
+                        function: { arguments: customInputToArguments(input) },
+                    },
+                ],
+            }));
+            entry.customInput = "";
+        }
+        return out;
+    }
+    if (type === "response.output_item.done") {
+        const item = asRecord(event.item);
+        if (!item)
+            return out;
+        const itemId = String(item.id || "");
+        const entry = toolEntryFor(state, itemId);
+        // Non-streamed argument payloads only appear on the done event.
+        if (entry && entry.custom && entry.customInput) {
+            out.push(chunk(state, {
+                tool_calls: [
+                    {
+                        index: entry.toolIndex,
+                        function: {
+                            arguments: customInputToArguments(entry.customInput),
+                        },
+                    },
+                ],
+            }));
+            entry.customInput = "";
+        }
+        return out;
+    }
+    if (type === "response.completed" || type === "response.incomplete") {
+        const response = asRecord(event.response);
+        if (response) {
+            state.usage = mapUsage(asRecord(response.usage));
+            state.finishReason = state.items.size
+                ? "tool_calls"
+                : responsesStatusToFinishReason(response.status ?? (type === "response.incomplete" ? "incomplete" : "completed"), asRecord(response.incomplete_details));
+        }
+        return finishResponsesToChatStream(state);
+    }
+    if (type === "response.failed" || type === "error") {
+        const response = asRecord(event.response);
+        const error = asRecord(event.error) || asRecord(response?.error);
+        throw new ResponsesStreamError(String(error?.message || "上游 Responses 流返回错误"), String(error?.type || error?.code || "api_error"));
+    }
+    return out;
+}
+function finishResponsesToChatStream(state) {
+    if (state.completed)
+        return [];
+    state.completed = true;
+    const out = [];
+    const finishReason = state.finishReason || (state.items.size ? "tool_calls" : "stop");
+    out.push(chunk(state, {}, finishReason));
+    if (state.includeUsage && state.usage) {
+        out.push({
+            id: state.id,
+            object: "chat.completion.chunk",
+            created: state.created,
+            model: state.model,
+            choices: [],
+            usage: state.usage,
+        });
+    }
+    return out;
+}
+/** Emit terminal chunks when the upstream stream ends without a completion event. */
+export function forceCompleteResponsesToChatStream(state) {
+    return finishResponsesToChatStream(state);
+}

package/dist/bridge/server.js

@@ -29,7 +29,7 @@ function authenticateDataRequest(req, upstream, tool) {
     if (!upstream?.clientToken || upstream.migrationRequired)
         return false;
     const bearer = bearerToken(req);
-    if (tool === "codex") {
+    if (tool === "codex" || tool === "opencode") {
         return constantTimeTokenEqual(upstream.clientToken, bearer);
     }
     const apiKey = headerValue(req.headers["x-api-key"]);
@@ -40,7 +40,8 @@ function authenticateDataRequest(req, upstream, tool) {
 }
 function authenticateModelsRequest(req, upstreams) {
     return (authenticateDataRequest(req, upstreams.codex, "codex") ||
-        authenticateDataRequest(req, upstreams.claude, "claude"));
+        authenticateDataRequest(req, upstreams.claude, "claude") ||
+        authenticateDataRequest(req, upstreams.opencode, "opencode"));
 }
 function readBody(req, maxBytes = parseBridgeRuntimeLimits().maxBodyBytes) {
     return new Promise((resolve, reject) => {
@@ -156,7 +157,7 @@ async function fetchModelsJson(upstream) {
     }
 }
 async function proxyModelsMerged(_req, res, upstreams) {
-    const sides = [upstreams.codex, upstreams.claude].filter((u) => Boolean(u?.baseUrl));
+    const sides = [upstreams.codex, upstreams.claude, upstreams.opencode].filter((u) => Boolean(u?.baseUrl));
     if (!sides.length) {
         sendJson(res, 503, {
             error: { message: "Bridge 未配置上游" },
@@ -293,6 +294,52 @@ async function forwardChatResponses(req, res, upstream, body, wantStream) {
     }
     await pipeChatStreamToResponses(response, res, String(body.model || ""), customTools, true);
 }
+/**
+ * OpenCode-facing passthrough: forward an OpenAI chat request verbatim to the
+ * upstream `/chat/completions` (with llm-switch transport applying the proxy)
+ * and relay the raw response, preserving streaming for SSE.
+ */
+async function forwardOpenCodeChat(_req, res, upstream, bodyBuf) {
+    let body;
+    try {
+        body = JSON.parse(bodyBuf.toString("utf8"));
+    }
+    catch {
+        sendJson(res, 400, { error: { message: "Invalid JSON body" } });
+        return;
+    }
+    const wantStream = Boolean(body.stream);
+    const url = joinUrl(upstream.baseUrl, "/chat/completions");
+    let response;
+    try {
+        response = await requestUpstream(upstream, url, "POST", bodyBuf.toString("utf8"));
+    }
+    catch (err) {
+        sendJson(res, 502, {
+            error: {
+                message: `Upstream chat 请求失败: ${err instanceof Error ? err.message : String(err)}`,
+            },
+        });
+        return;
+    }
+    if (!response.ok) {
+        const text = await response.text();
+        res.writeHead(response.status, {
+            "Content-Type": response.headers.get("content-type") || "application/json",
+        });
+        res.end(text);
+        return;
+    }
+    if (!wantStream) {
+        const text = await response.text();
+        res.writeHead(response.status, {
+            "Content-Type": response.headers.get("content-type") || "application/json",
+        });
+        res.end(text);
+        return;
+    }
+    await pipeRawStream(response, res);
+}
 async function forwardCompletions(_req, res, upstream, body, wantStream) {
     const completionReq = responsesToCompletionsRequest(body);
     const customTools = collectCustomToolNames(body.tools);
@@ -444,6 +491,34 @@ async function pipeChatStreamToAnthropic(upstream, res, model) {
         res.end();
     }
 }
+/** Relay an upstream SSE stream verbatim (OpenCode chat passthrough). */
+async function pipeRawStream(upstream, res) {
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream; charset=utf-8",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no",
+    });
+    const reader = upstream.body?.getReader();
+    if (!reader) {
+        res.end();
+        return;
+    }
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            res.write(value);
+        }
+    }
+    catch {
+        // Connection dropped; best-effort close.
+    }
+    finally {
+        res.end();
+    }
+}
 export function createBridgeServer(options = {}) {
     return createServer(async (req, res) => {
         try {
@@ -487,6 +562,13 @@ export function createBridgeServer(options = {}) {
                                 migrationRequired: merged.claude.migrationRequired === true,
                             }
                             : null,
+                        opencode: merged.opencode
+                            ? {
+                                mode: merged.opencode.mode,
+                                profile: merged.opencode.profileName || null,
+                                migrationRequired: merged.opencode.migrationRequired === true,
+                            }
+                            : null,
                     },
                 });
                 return;
@@ -584,9 +666,32 @@ export function createBridgeServer(options = {}) {
                 await handleMessages(req, res, merged.claude, body);
                 return;
             }
+            if (req.method === "POST" &&
+                (path === "/v1/chat/completions" || path === "/chat/completions")) {
+                if (!merged.opencode?.baseUrl) {
+                    sendJson(res, 503, {
+                        error: {
+                            message: "Bridge 未配置 OpenCode 上游。请先 llms opencode use <openai-chat profile>",
+                        },
+                    });
+                    return;
+                }
+                if (!authenticateDataRequest(req, merged.opencode, "opencode")) {
+                    sendJson(res, 401, {
+                        error: {
+                            code: "invalid_bridge_token",
+                            message: "Bridge token 无效；请重新执行 llms opencode use <profile>",
+                        },
+                    });
+                    return;
+                }
+                const body = await readBody(req);
+                await forwardOpenCodeChat(req, res, merged.opencode, body);
+                return;
+            }
             sendJson(res, 404, {
                 error: {
-                    message: `Bridge 支持 GET /v1/models、POST /v1/responses、POST /v1/messages（当前: ${req.method} ${path}）`,
+                    message: `Bridge 支持 GET /v1/models、POST /v1/responses、POST /v1/messages、POST /v1/chat/completions（当前: ${req.method} ${path}）`,
                 },
             });
         }

package/dist/bridge/state.js

@@ -63,7 +63,10 @@ function isLegacyUpstream(raw) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw))
         return false;
     const row = raw;
-    return typeof row.baseUrl === "string" && !("codex" in row) && !("claude" in row);
+    return (typeof row.baseUrl === "string" &&
+        !("codex" in row) &&
+        !("claude" in row) &&
+        !("opencode" in row));
 }
 export function normalizeBridgeUpstreams(raw) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
@@ -71,11 +74,12 @@ export function normalizeBridgeUpstreams(raw) {
     }
     const row = raw;
     if (isLegacyUpstream(raw)) {
-        return { codex: raw, claude: null };
+        return { codex: raw, claude: null, opencode: null };
     }
     return {
         codex: row.codex ?? null,
         claude: row.claude ?? null,
+        opencode: row.opencode ?? null,
     };
 }
 /** Legacy upstreams cannot authenticate until reapplied. */
@@ -155,6 +159,7 @@ function readLegacyMigrationState() {
             upstreams: {
                 codex: markUpstreamMigrationRequired(upstreams.codex),
                 claude: markUpstreamMigrationRequired(upstreams.claude),
+                opencode: markUpstreamMigrationRequired(upstreams.opencode),
             },
             pending: null,
         });
@@ -224,6 +229,7 @@ function persistState(next) {
         upstreams: {
             codex: next.upstreams.codex,
             claude: next.upstreams.claude,
+            opencode: next.upstreams.opencode,
         },
         pending: next.pending,
     };

package/dist/bridge/types.js

@@ -1,8 +1,10 @@
 export const DEFAULT_BRIDGE_PORT = 17890;
 export const DEFAULT_BRIDGE_HOST = "127.0.0.1";
 export function emptyUpstreams() {
-    return { codex: null, claude: null };
+    return { codex: null, claude: null, opencode: null };
 }
 export function hasAnyUpstream(upstreams) {
-    return Boolean(upstreams.codex?.baseUrl || upstreams.claude?.baseUrl);
+    return Boolean(upstreams.codex?.baseUrl ||
+        upstreams.claude?.baseUrl ||
+        upstreams.opencode?.baseUrl);
 }

package/dist/cli.js

@@ -3,6 +3,7 @@ import { TOOLS } from "./types.js";
 import { registerToolCommand } from "./commands/tool.js";
 import { registerLaunchCommand } from "./commands/launch-cmd.js";
 import { registerBridgeCommand } from "./commands/bridge-cmd.js";
+import { registerGatewayCommand } from "./commands/gateway-cmd.js";
 import { registerSetupCommand } from "./commands/setup-cmd.js";
 import { registerHomeCommand } from "./commands/home-cmd.js";
 import { getAppConfigRoot } from "./utils/paths.js";
@@ -22,6 +23,7 @@ export function createProgram() {
     });
     registerLaunchCommand(program);
     registerBridgeCommand(program);
+    registerGatewayCommand(program);
     registerSetupCommand(program);
     for (const tool of TOOLS) {
         registerToolCommand(program, tool);

package/dist/commands/bridge-cmd.js

@@ -72,6 +72,7 @@ export function registerBridgeCommand(program) {
             upstreams: {
                 codex: summarize(state.upstreams.codex),
                 claude: summarize(state.upstreams.claude),
+                opencode: summarize(state.upstreams.opencode),
             },
         };
         if (opts.json) {
@@ -80,9 +81,9 @@ export function registerBridgeCommand(program) {
         }
         console.log(`状态：${alive ? "运行中" : "未运行"}`);
         console.log(`根地址：${data.rootUrl}`);
-        console.log(`Codex base：${data.codexBaseUrl}`);
+        console.log(`Codex/OpenCode base：${data.codexBaseUrl}`);
         console.log(`PID：${pid ?? "-"}`);
-        for (const tool of ["codex", "claude"]) {
+        for (const tool of ["codex", "claude", "opencode"]) {
             const u = data.upstreams[tool];
             if (u) {
                 console.log(`${tool} 上游：${u.baseUrl}（${u.mode}） profile=${u.profile ?? "-"}`);