@nvae/llmswitch 0.2.0

package/dist/bridge/translate-response.js

@@ -0,0 +1,509 @@
+/**
+ * Translate Chat Completions (stream/non-stream) → Responses API events/objects.
+ */
+function newId(prefix) {
+    return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+export function sseEvent(type, data) {
+    const payload = { type, ...data };
+    return `event: ${type}\ndata: ${JSON.stringify(payload)}\n\n`;
+}
+function mapUsage(usage) {
+    if (!usage)
+        return undefined;
+    const input = numberOr(usage.prompt_tokens) ??
+        numberOr(usage.input_tokens) ??
+        0;
+    const output = numberOr(usage.completion_tokens) ??
+        numberOr(usage.output_tokens) ??
+        0;
+    return {
+        input_tokens: input,
+        output_tokens: output,
+        total_tokens: numberOr(usage.total_tokens) ?? input + output,
+        output_tokens_details: {
+            reasoning_tokens: numberOr(usage.completion_tokens_details
+                ?.reasoning_tokens) ?? 0,
+        },
+    };
+}
+function numberOr(value) {
+    return typeof value === "number" ? value : undefined;
+}
+export function createStreamState(model, responseId, customTools) {
+    return {
+        responseId: responseId || newId("resp"),
+        model,
+        textItemId: null,
+        textStarted: false,
+        textContentIndex: 0,
+        outputIndex: 0,
+        fullText: "",
+        customTools: new Set(customTools ?? []),
+        toolCalls: new Map(),
+        created: false,
+        completed: false,
+    };
+}
+/**
+ * Chat function-calling often wraps freeform payloads as `{"input":"..."}`.
+ * Codex custom tools need the raw string in `input`.
+ */
+export function unwrapCustomToolInput(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return "";
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === "string")
+            return parsed;
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            const obj = parsed;
+            if (typeof obj.input === "string")
+                return obj.input;
+            if (typeof obj.text === "string")
+                return obj.text;
+            if (typeof obj.query === "string" && Object.keys(obj).length === 1) {
+                return obj.query;
+            }
+        }
+    }
+    catch {
+        // Freeform text / partial JSON — keep as-is
+    }
+    return raw;
+}
+function isCustomToolName(state, name) {
+    return Boolean(name) && state.customTools.has(name);
+}
+function baseResponse(state, status) {
+    return {
+        id: state.responseId,
+        object: "response",
+        created_at: Math.floor(Date.now() / 1000),
+        status,
+        model: state.model,
+        output: [],
+        error: null,
+        incomplete_details: null,
+        usage: state.usage,
+    };
+}
+function ensureCreated(state, out) {
+    if (state.created)
+        return;
+    state.created = true;
+    const response = baseResponse(state, "in_progress");
+    out.push(sseEvent("response.created", { response }));
+    out.push(sseEvent("response.in_progress", { response }));
+}
+function ensureTextItem(state, out) {
+    if (state.textStarted)
+        return;
+    state.textStarted = true;
+    state.textItemId = newId("msg");
+    const outputIndex = state.outputIndex;
+    out.push(sseEvent("response.output_item.added", {
+        output_index: outputIndex,
+        item: {
+            id: state.textItemId,
+            type: "message",
+            status: "in_progress",
+            role: "assistant",
+            content: [],
+        },
+    }));
+    out.push(sseEvent("response.content_part.added", {
+        item_id: state.textItemId,
+        output_index: outputIndex,
+        content_index: state.textContentIndex,
+        part: { type: "output_text", text: "", annotations: [] },
+    }));
+}
+/**
+ * Convert one Chat Completions SSE JSON chunk into zero or more Responses SSE frames.
+ */
+export function chatChunkToResponsesEvents(chunk, state) {
+    const out = [];
+    ensureCreated(state, out);
+    if (chunk.usage && typeof chunk.usage === "object") {
+        state.usage = mapUsage(chunk.usage);
+    }
+    const choices = Array.isArray(chunk.choices) ? chunk.choices : [];
+    for (const choiceRaw of choices) {
+        const choice = choiceRaw;
+        const delta = (choice.delta || choice.message || {});
+        const finish = choice.finish_reason;
+        if (typeof delta.content === "string" && delta.content.length > 0) {
+            ensureTextItem(state, out);
+            state.fullText += delta.content;
+            out.push(sseEvent("response.output_text.delta", {
+                item_id: state.textItemId,
+                output_index: state.outputIndex,
+                content_index: state.textContentIndex,
+                delta: delta.content,
+            }));
+        }
+        // Completions-style: choices[].text
+        if (typeof choice.text === "string" && choice.text.length > 0) {
+            ensureTextItem(state, out);
+            state.fullText += choice.text;
+            out.push(sseEvent("response.output_text.delta", {
+                item_id: state.textItemId,
+                output_index: state.outputIndex,
+                content_index: state.textContentIndex,
+                delta: choice.text,
+            }));
+        }
+        const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+        for (const tcRaw of toolCalls) {
+            const tc = tcRaw;
+            const idx = typeof tc.index === "number" ? tc.index : 0;
+            let entry = state.toolCalls.get(idx);
+            const fn = (tc.function || {});
+            if (!entry) {
+                const callId = String(tc.id || newId("call"));
+                const name = String(fn.name || "");
+                entry = {
+                    itemId: newId(isCustomToolName(state, name) ? "ctc" : "fc"),
+                    callId,
+                    name,
+                    arguments: "",
+                    started: false,
+                    custom: isCustomToolName(state, name),
+                    outputIndex: -1,
+                };
+                state.toolCalls.set(idx, entry);
+            }
+            else {
+                if (tc.id)
+                    entry.callId = String(tc.id);
+                if (typeof fn.name === "string" && fn.name) {
+                    entry.name = fn.name;
+                    entry.custom = isCustomToolName(state, entry.name);
+                }
+            }
+            if (!entry.started && entry.name) {
+                entry.started = true;
+                entry.custom = isCustomToolName(state, entry.name);
+                // Close text item before tool calls if needed
+                if (state.textStarted && state.textItemId) {
+                    closeTextItem(state, out);
+                }
+                entry.outputIndex = state.outputIndex;
+                state.outputIndex += 1;
+                if (entry.custom) {
+                    out.push(sseEvent("response.output_item.added", {
+                        output_index: entry.outputIndex,
+                        item: {
+                            id: entry.itemId,
+                            type: "custom_tool_call",
+                            status: "in_progress",
+                            call_id: entry.callId,
+                            name: entry.name,
+                            input: "",
+                        },
+                    }));
+                }
+                else {
+                    out.push(sseEvent("response.output_item.added", {
+                        output_index: entry.outputIndex,
+                        item: {
+                            id: entry.itemId,
+                            type: "function_call",
+                            status: "in_progress",
+                            call_id: entry.callId,
+                            name: entry.name,
+                            arguments: "",
+                        },
+                    }));
+                }
+            }
+            if (typeof fn.arguments === "string" && fn.arguments.length > 0) {
+                if (!entry.started) {
+                    // name may arrive later; start with placeholder
+                    entry.started = true;
+                    entry.custom = isCustomToolName(state, entry.name);
+                    if (state.textStarted && state.textItemId)
+                        closeTextItem(state, out);
+                    entry.outputIndex = state.outputIndex;
+                    state.outputIndex += 1;
+                    if (entry.custom) {
+                        out.push(sseEvent("response.output_item.added", {
+                            output_index: entry.outputIndex,
+                            item: {
+                                id: entry.itemId,
+                                type: "custom_tool_call",
+                                status: "in_progress",
+                                call_id: entry.callId,
+                                name: entry.name || "tool",
+                                input: "",
+                            },
+                        }));
+                    }
+                    else {
+                        out.push(sseEvent("response.output_item.added", {
+                            output_index: entry.outputIndex,
+                            item: {
+                                id: entry.itemId,
+                                type: "function_call",
+                                status: "in_progress",
+                                call_id: entry.callId,
+                                name: entry.name || "tool",
+                                arguments: "",
+                            },
+                        }));
+                    }
+                }
+                entry.arguments += fn.arguments;
+                // For custom tools, buffer JSON-wrapped args and emit raw input at done.
+                // Function tools stream argument deltas as usual.
+                if (!entry.custom) {
+                    out.push(sseEvent("response.function_call_arguments.delta", {
+                        item_id: entry.itemId,
+                        output_index: entry.outputIndex,
+                        delta: fn.arguments,
+                    }));
+                }
+            }
+        }
+        if (finish) {
+            finalizeStream(state, out, finish);
+        }
+    }
+    return out;
+}
+function closeTextItem(state, out) {
+    if (!state.textStarted || !state.textItemId)
+        return;
+    const outputIndex = state.outputIndex;
+    out.push(sseEvent("response.output_text.done", {
+        item_id: state.textItemId,
+        output_index: outputIndex,
+        content_index: state.textContentIndex,
+        text: state.fullText,
+    }));
+    out.push(sseEvent("response.content_part.done", {
+        item_id: state.textItemId,
+        output_index: outputIndex,
+        content_index: state.textContentIndex,
+        part: { type: "output_text", text: state.fullText, annotations: [] },
+    }));
+    out.push(sseEvent("response.output_item.done", {
+        output_index: outputIndex,
+        item: {
+            id: state.textItemId,
+            type: "message",
+            status: "completed",
+            role: "assistant",
+            content: [
+                { type: "output_text", text: state.fullText, annotations: [] },
+            ],
+        },
+    }));
+    state.outputIndex += 1;
+    state.textStarted = false;
+    state.textItemId = null;
+}
+function finalizeStream(state, out, finishReason) {
+    if (state.completed)
+        return;
+    if (state.textStarted && state.textItemId) {
+        closeTextItem(state, out);
+    }
+    for (const entry of state.toolCalls.values()) {
+        if (!entry.started)
+            continue;
+        // Re-evaluate in case the name arrived after the item was opened
+        entry.custom = isCustomToolName(state, entry.name) || entry.custom;
+        const outputIndex = entry.outputIndex >= 0 ? entry.outputIndex : state.outputIndex;
+        if (entry.custom) {
+            const input = unwrapCustomToolInput(entry.arguments);
+            out.push(sseEvent("response.custom_tool_call_input.delta", {
+                item_id: entry.itemId,
+                output_index: outputIndex,
+                call_id: entry.callId,
+                delta: input,
+            }));
+            out.push(sseEvent("response.custom_tool_call_input.done", {
+                item_id: entry.itemId,
+                output_index: outputIndex,
+                call_id: entry.callId,
+                input,
+            }));
+            out.push(sseEvent("response.output_item.done", {
+                output_index: outputIndex,
+                item: {
+                    id: entry.itemId,
+                    type: "custom_tool_call",
+                    status: "completed",
+                    call_id: entry.callId,
+                    name: entry.name || "tool",
+                    input,
+                },
+            }));
+        }
+        else {
+            out.push(sseEvent("response.function_call_arguments.done", {
+                item_id: entry.itemId,
+                output_index: outputIndex,
+                arguments: entry.arguments,
+            }));
+            out.push(sseEvent("response.output_item.done", {
+                output_index: outputIndex,
+                item: {
+                    id: entry.itemId,
+                    type: "function_call",
+                    status: "completed",
+                    call_id: entry.callId,
+                    name: entry.name || "tool",
+                    arguments: entry.arguments,
+                },
+            }));
+        }
+        if (entry.outputIndex < 0) {
+            entry.outputIndex = outputIndex;
+            state.outputIndex = Math.max(state.outputIndex, outputIndex + 1);
+        }
+    }
+    const status = finishReason === "length" || finishReason === "content_filter"
+        ? "incomplete"
+        : "completed";
+    const output = [];
+    if (state.fullText) {
+        output.push({
+            id: newId("msg"),
+            type: "message",
+            status: "completed",
+            role: "assistant",
+            content: [{ type: "output_text", text: state.fullText, annotations: [] }],
+        });
+    }
+    for (const entry of state.toolCalls.values()) {
+        if (entry.custom) {
+            output.push({
+                id: entry.itemId,
+                type: "custom_tool_call",
+                status: "completed",
+                call_id: entry.callId,
+                name: entry.name || "tool",
+                input: unwrapCustomToolInput(entry.arguments),
+            });
+        }
+        else {
+            output.push({
+                id: entry.itemId,
+                type: "function_call",
+                status: "completed",
+                call_id: entry.callId,
+                name: entry.name || "tool",
+                arguments: entry.arguments,
+            });
+        }
+    }
+    const response = {
+        ...baseResponse(state, status),
+        output,
+        usage: state.usage,
+    };
+    out.push(sseEvent("response.completed", { response }));
+    state.completed = true;
+}
+export function forceCompleteStream(state) {
+    if (state.completed)
+        return [];
+    const out = [];
+    ensureCreated(state, out);
+    finalizeStream(state, out, "stop");
+    return out;
+}
+/**
+ * Non-streaming Chat Completions JSON → Responses JSON.
+ */
+export function chatCompletionToResponse(chat, modelFallback, customTools) {
+    const id = newId("resp");
+    const model = String(chat.model || modelFallback || "");
+    const customSet = new Set(customTools ?? []);
+    const usage = mapUsage(chat.usage && typeof chat.usage === "object"
+        ? chat.usage
+        : undefined);
+    const output = [];
+    const choices = Array.isArray(chat.choices) ? chat.choices : [];
+    const choice = (choices[0] || {});
+    const message = (choice.message || {});
+    // Completions API shape
+    const textFromCompletions = typeof choice.text === "string" ? choice.text : "";
+    const content = typeof message.content === "string"
+        ? message.content
+        : textFromCompletions;
+    if (content) {
+        output.push({
+            id: newId("msg"),
+            type: "message",
+            status: "completed",
+            role: "assistant",
+            content: [{ type: "output_text", text: content, annotations: [] }],
+        });
+    }
+    const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+    for (const tcRaw of toolCalls) {
+        const tc = tcRaw;
+        const fn = (tc.function || {});
+        const name = String(fn.name || "tool");
+        const args = typeof fn.arguments === "string"
+            ? fn.arguments
+            : JSON.stringify(fn.arguments ?? {});
+        if (customSet.has(name)) {
+            output.push({
+                id: newId("ctc"),
+                type: "custom_tool_call",
+                status: "completed",
+                call_id: String(tc.id || newId("call")),
+                name,
+                input: unwrapCustomToolInput(args),
+            });
+        }
+        else {
+            output.push({
+                id: newId("fc"),
+                type: "function_call",
+                status: "completed",
+                call_id: String(tc.id || newId("call")),
+                name,
+                arguments: args,
+            });
+        }
+    }
+    const finish = String(choice.finish_reason || "stop");
+    const status = finish === "length" || finish === "content_filter"
+        ? "incomplete"
+        : "completed";
+    return {
+        id,
+        object: "response",
+        created_at: Math.floor(Date.now() / 1000),
+        status,
+        model,
+        output,
+        error: null,
+        incomplete_details: null,
+        usage,
+    };
+}
+/**
+ * Parse SSE lines from Chat Completions upstream into JSON chunk objects.
+ */
+export function parseChatSseLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("data:"))
+        return null;
+    const data = trimmed.slice(5).trim();
+    if (data === "[DONE]")
+        return "done";
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/bridge/types.js

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

package/dist/cli.js

@@ -0,0 +1,48 @@
+import { Command } from "commander";
+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 { getAppConfigRoot } from "./utils/paths.js";
+export function createProgram() {
+    const program = new Command();
+    program
+        .name("llms")
+        .description("为 Claude Code / Codex / OpenCode 切换供应商、模型与上游代理")
+        .version("0.2.0")
+        .option("--json", "部分命令支持 JSON 输出（见子命令）");
+    program
+        .command("path")
+        .description("显示 llm-switch 本地配置目录")
+        .action(() => {
+        console.log(getAppConfigRoot());
+    });
+    registerLaunchCommand(program);
+    registerBridgeCommand(program);
+    for (const tool of TOOLS) {
+        registerToolCommand(program, tool);
+    }
+    program.configureOutput({
+        writeErr: (str) => process.stderr.write(str),
+    });
+    return program;
+}
+export async function run(argv = process.argv) {
+    const program = createProgram();
+    program.exitOverride();
+    try {
+        await program.parseAsync(argv);
+    }
+    catch (err) {
+        if (err &&
+            typeof err === "object" &&
+            "code" in err &&
+            (err.code === "commander.helpDisplayed" ||
+                err.code === "commander.version")) {
+            return;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`错误：${message}`);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/bridge-cmd.js

@@ -0,0 +1,113 @@
+import { ensureBridgeForProfile, isBridgeAlive, isPidRunning, readPid, runBridgeForeground, startBridgeDaemon, stopBridge, upstreamFromProfile, } from "../bridge/manager.js";
+import { bridgeBaseUrl, bridgeRootUrl, readBridgeState, writeBridgeUpstream, } from "../bridge/state.js";
+import { DEFAULT_BRIDGE_HOST, DEFAULT_BRIDGE_PORT } from "../bridge/types.js";
+import { getActiveProfile, requireProfile } from "../store/profiles.js";
+import { isTool } from "../types.js";
+export function registerBridgeCommand(program) {
+    const bridge = program
+        .command("bridge")
+        .description("本地协议适配桥：Codex Responses↔Chat、Claude Messages↔Chat（共用进程，按工具隔离上游）");
+    bridge
+        .command("serve")
+        .description("前台运行 bridge（守护进程由 use/launch 自动拉起）")
+        .option("--host <host>", "监听地址", DEFAULT_BRIDGE_HOST)
+        .option("--port <port>", "监听端口", String(DEFAULT_BRIDGE_PORT))
+        .action(async (opts) => {
+        const port = Number(opts.port) || DEFAULT_BRIDGE_PORT;
+        await runBridgeForeground(opts.host || DEFAULT_BRIDGE_HOST, port);
+    });
+    bridge
+        .command("start")
+        .description("后台启动 bridge")
+        .option("--host <host>", "监听地址", DEFAULT_BRIDGE_HOST)
+        .option("--port <port>", "监听端口", String(DEFAULT_BRIDGE_PORT))
+        .action(async (opts) => {
+        const host = opts.host || DEFAULT_BRIDGE_HOST;
+        const port = Number(opts.port) || DEFAULT_BRIDGE_PORT;
+        const pid = await startBridgeDaemon(host, port);
+        for (let i = 0; i < 30; i++) {
+            if (await isBridgeAlive(host, port))
+                break;
+            await new Promise((r) => setTimeout(r, 100));
+        }
+        if (!(await isBridgeAlive(host, port))) {
+            throw new Error("bridge 启动失败，请尝试：llms bridge serve");
+        }
+        console.log(`bridge 已启动 pid=${pid} ${bridgeRootUrl()}`);
+    });
+    bridge
+        .command("stop")
+        .description("停止 bridge")
+        .action(async () => {
+        const ok = await stopBridge();
+        console.log(ok ? "已发送停止信号" : "没有正在运行的 bridge 进程");
+    });
+    bridge
+        .command("status")
+        .description("查看 bridge 状态")
+        .option("--json", "JSON 输出")
+        .action(async (opts) => {
+        const state = readBridgeState();
+        const alive = await isBridgeAlive(state.host, state.port);
+        const pid = state.pid || readPid();
+        const summarize = (upstream) => upstream
+            ? {
+                baseUrl: upstream.baseUrl,
+                mode: upstream.mode,
+                profile: upstream.profileName || null,
+                hasKey: Boolean(upstream.apiKey),
+            }
+            : null;
+        const data = {
+            alive,
+            host: state.host,
+            port: state.port,
+            rootUrl: bridgeRootUrl(state),
+            codexBaseUrl: bridgeBaseUrl(state),
+            pid,
+            pidRunning: pid ? isPidRunning(pid) : false,
+            upstreams: {
+                codex: summarize(state.upstreams.codex),
+                claude: summarize(state.upstreams.claude),
+            },
+        };
+        if (opts.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        console.log(`状态：${alive ? "运行中" : "未运行"}`);
+        console.log(`根地址：${data.rootUrl}`);
+        console.log(`Codex base：${data.codexBaseUrl}`);
+        console.log(`PID：${pid ?? "-"}`);
+        for (const tool of ["codex", "claude"]) {
+            const u = data.upstreams[tool];
+            if (u) {
+                console.log(`${tool} 上游：${u.baseUrl}（${u.mode}） profile=${u.profile ?? "-"}`);
+            }
+            else {
+                console.log(`${tool} 上游：未配置`);
+            }
+        }
+    });
+    bridge
+        .command("reload")
+        .description("用当前启用的 profile 刷新某一侧上游（不重启进程）")
+        .argument("[tool]", "claude 或 codex（默认 codex）", "codex")
+        .option("--profile <name>", "指定 profile")
+        .action(async (toolArg, opts) => {
+        const toolName = toolArg || "codex";
+        if (!isTool(toolName) || (toolName !== "codex" && toolName !== "claude")) {
+            throw new Error("tool 只能是 claude 或 codex");
+        }
+        const tool = toolName;
+        const profile = opts.profile
+            ? requireProfile(tool, opts.profile)
+            : getActiveProfile(tool);
+        if (!profile) {
+            throw new Error(`没有可用的 ${tool} profile`);
+        }
+        writeBridgeUpstream(tool, upstreamFromProfile(profile, tool));
+        const base = await ensureBridgeForProfile(profile, tool);
+        console.log(`已刷新 ${tool} 上游 ${profile.name} → bridge ${base}`);
+    });
+}