@nvae/llmswitch 1.0.0 → 1.3.0

package/dist/bridge/server.js

@@ -1,11 +1,12 @@
 import { createServer, } from "node:http";
-import { parseBridgeRuntimeLimits } from "./runtime.js";
+import { ConcurrencyGate, parseBridgeRuntimeLimits } from "./runtime.js";
 import { requestWithNodeTransport, } from "./transport.js";
 import { constantTimeTokenEqual, readBridgeState, readBridgeUpstreams, } from "./state.js";
 import { anthropicToChatRequest } from "./anthropic-translate-request.js";
 import { chatChunkToAnthropicEvents, chatCompletionToAnthropicMessage, createAnthropicStreamState, forceCompleteAnthropicStream, parseChatSseLine, } from "./anthropic-translate-response.js";
 import { collectCustomToolNames, responsesToChatRequest, responsesToCompletionsRequest, } from "./translate-request.js";
 import { chatChunkToResponsesEvents, chatCompletionToResponse, createStreamState, forceCompleteStream, parseChatSseLine as parseChatSseLineResponses, } from "./translate-response.js";
+import { modelItemId, modelsFromPayload } from "../utils/fetch-models.js";
 function headerValue(value) {
     return Array.isArray(value) ? value[0] : value;
 }
@@ -141,22 +142,21 @@ function requestUpstream(upstream, url, method, body, signal) {
         maxResponseBytes: limits.maxResponseBytes,
     });
 }
-async function fetchModelsJson(upstream) {
+async function fetchModelsJson(upstream, signal) {
     const url = joinUrl(upstream.baseUrl, "/models");
-    const response = await requestUpstream(upstream, url, "GET");
+    const response = await requestUpstream(upstream, url, "GET", undefined, signal);
     if (!response.ok) {
         return { ok: false, status: response.status, data: [] };
     }
     try {
         const json = (await response.json());
-        const data = Array.isArray(json.data) ? json.data : [];
-        return { ok: true, status: 200, data: data };
+        return { ok: true, status: 200, data: modelsFromPayload(json) };
     }
     catch {
         return { ok: false, status: 502, data: [] };
     }
 }
-async function proxyModelsMerged(_req, res, upstreams) {
+async function proxyModelsMerged(_req, res, upstreams, signal) {
     const sides = [upstreams.codex, upstreams.claude, upstreams.opencode].filter((u) => Boolean(u?.baseUrl));
     if (!sides.length) {
         sendJson(res, 503, {
@@ -164,7 +164,7 @@ async function proxyModelsMerged(_req, res, upstreams) {
         });
         return;
     }
-    const results = await Promise.all(sides.map((u) => fetchModelsJson(u).catch(() => ({
+    const results = await Promise.all(sides.map((u) => fetchModelsJson(u, signal).catch(() => ({
         ok: false,
         status: 502,
         data: [],
@@ -175,13 +175,14 @@ async function proxyModelsMerged(_req, res, upstreams) {
         if (!result.ok)
             continue;
         for (const item of result.data) {
-            const id = item && typeof item === "object" && "id" in item
-                ? String(item.id)
-                : "";
+            const id = modelItemId(item);
             if (!id || seen.has(id))
                 continue;
             seen.add(id);
-            merged.push(item);
+            const row = item && typeof item === "object"
+                ? item
+                : {};
+            merged.push(row.id ? item : { ...row, id });
         }
     }
     if (!merged.length && results.every((r) => !r.ok)) {
@@ -192,7 +193,7 @@ async function proxyModelsMerged(_req, res, upstreams) {
     }
     sendJson(res, 200, { object: "list", data: merged });
 }
-async function handleResponses(req, res, upstream, bodyBuf) {
+async function handleResponses(req, res, upstream, bodyBuf, signal) {
     let body;
     try {
         body = JSON.parse(bodyBuf.toString("utf8"));
@@ -204,12 +205,12 @@ async function handleResponses(req, res, upstream, bodyBuf) {
     const mode = upstream.mode || "chat";
     const wantStream = Boolean(body.stream);
     if (mode === "completions") {
-        await forwardCompletions(req, res, upstream, body, wantStream);
+        await forwardCompletions(req, res, upstream, body, wantStream, signal);
         return;
     }
-    await forwardChatResponses(req, res, upstream, body, wantStream);
+    await forwardChatResponses(req, res, upstream, body, wantStream, signal);
 }
-async function handleMessages(_req, res, upstream, bodyBuf) {
+async function handleMessages(_req, res, upstream, bodyBuf, signal) {
     let body;
     try {
         body = JSON.parse(bodyBuf.toString("utf8"));
@@ -226,7 +227,7 @@ async function handleMessages(_req, res, upstream, bodyBuf) {
     const url = joinUrl(upstream.baseUrl, "/chat/completions");
     let response;
     try {
-        response = await requestUpstream(upstream, url, "POST", JSON.stringify(chatReq));
+        response = await requestUpstream(upstream, url, "POST", JSON.stringify(chatReq), signal);
     }
     catch (err) {
         sendJson(res, 502, {
@@ -259,13 +260,13 @@ async function handleMessages(_req, res, upstream, bodyBuf) {
     }
     await pipeChatStreamToAnthropic(response, res, String(body.model || ""));
 }
-async function forwardChatResponses(req, res, upstream, body, wantStream) {
+async function forwardChatResponses(req, res, upstream, body, wantStream, signal) {
     const chatReq = responsesToChatRequest(body);
     const customTools = collectCustomToolNames(body.tools);
     const url = joinUrl(upstream.baseUrl, "/chat/completions");
     let response;
     try {
-        response = await requestUpstream(upstream, url, "POST", JSON.stringify(chatReq));
+        response = await requestUpstream(upstream, url, "POST", JSON.stringify(chatReq), signal);
     }
     catch (err) {
         sendJson(res, 502, {
@@ -299,7 +300,7 @@ async function forwardChatResponses(req, res, upstream, body, wantStream) {
  * 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) {
+async function forwardOpenCodeChat(_req, res, upstream, bodyBuf, signal) {
     let body;
     try {
         body = JSON.parse(bodyBuf.toString("utf8"));
@@ -312,7 +313,7 @@ async function forwardOpenCodeChat(_req, res, upstream, bodyBuf) {
     const url = joinUrl(upstream.baseUrl, "/chat/completions");
     let response;
     try {
-        response = await requestUpstream(upstream, url, "POST", bodyBuf.toString("utf8"));
+        response = await requestUpstream(upstream, url, "POST", bodyBuf.toString("utf8"), signal);
     }
     catch (err) {
         sendJson(res, 502, {
@@ -340,13 +341,13 @@ async function forwardOpenCodeChat(_req, res, upstream, bodyBuf) {
     }
     await pipeRawStream(response, res);
 }
-async function forwardCompletions(_req, res, upstream, body, wantStream) {
+async function forwardCompletions(_req, res, upstream, body, wantStream, signal) {
     const completionReq = responsesToCompletionsRequest(body);
     const customTools = collectCustomToolNames(body.tools);
     const url = joinUrl(upstream.baseUrl, "/completions");
     let response;
     try {
-        response = await requestUpstream(upstream, url, "POST", JSON.stringify(completionReq));
+        response = await requestUpstream(upstream, url, "POST", JSON.stringify(completionReq), signal);
     }
     catch (err) {
         sendJson(res, 502, {
@@ -520,7 +521,41 @@ async function pipeRawStream(upstream, res) {
     }
 }
 export function createBridgeServer(options = {}) {
+    const limits = parseBridgeRuntimeLimits();
+    // LLM_SWITCH_MAX_CONCURRENCY 与 gateway 共用；默认 0 表示不限，
+    // 此时 gate 只统计在途请求、不做拒绝。
+    const gate = new ConcurrencyGate(limits.maxConcurrency);
     return createServer(async (req, res) => {
+        // 客户端断开（Ctrl-C）后必须把上游请求也取消掉，否则 bridge 会一直把流读到
+        // idle/total 超时，白白消耗上游 token 与连接。
+        //
+        // 注意运行时差异：Node 会在客户端掉线时给 ServerResponse 发 "close"，
+        // 但 Bun 的 node:http 不发（只有 req 的 "aborted" 与 socket 的 "close"）。
+        // bridge 守护进程两种运行时都可能跑，所以三个信号都监听，并用
+        // writableFinished 兜底避免正常收尾时误取消。
+        const controller = new AbortController();
+        const abort = () => {
+            if (res.writableFinished)
+                return;
+            controller.abort();
+        };
+        const socket = res.socket;
+        res.on("close", abort);
+        req.on("aborted", abort);
+        socket?.on("close", abort);
+        const signal = controller.signal;
+        const isDataPlane = req.method === "POST" &&
+            /^\/(v1\/)?(responses|messages|chat\/completions|completions)$/.test((req.url || "/").split("?")[0].replace(/\/+$/, "") || "/");
+        if (isDataPlane && !gate.tryAcquire()) {
+            res.setHeader("Retry-After", "1");
+            sendJson(res, 503, {
+                error: {
+                    code: "too_many_concurrent_requests",
+                    message: `并发请求数已达上限 ${limits.maxConcurrency}（LLM_SWITCH_MAX_CONCURRENCY 可调整）`,
+                },
+            });
+            return;
+        }
         try {
             const state = readBridgeState();
             const expectedControlToken = options.controlToken ?? state.instance?.controlToken;
@@ -614,7 +649,7 @@ export function createBridgeServer(options = {}) {
                     });
                     return;
                 }
-                await proxyModelsMerged(req, res, merged);
+                await proxyModelsMerged(req, res, merged, signal);
                 return;
             }
             if (req.method === "POST" &&
@@ -637,7 +672,7 @@ export function createBridgeServer(options = {}) {
                     return;
                 }
                 const body = await readBody(req);
-                await handleResponses(req, res, merged.codex, body);
+                await handleResponses(req, res, merged.codex, body, signal);
                 return;
             }
             if (req.method === "POST" &&
@@ -663,7 +698,7 @@ export function createBridgeServer(options = {}) {
                     return;
                 }
                 const body = await readBody(req);
-                await handleMessages(req, res, merged.claude, body);
+                await handleMessages(req, res, merged.claude, body, signal);
                 return;
             }
             if (req.method === "POST" &&
@@ -686,7 +721,7 @@ export function createBridgeServer(options = {}) {
                     return;
                 }
                 const body = await readBody(req);
-                await forwardOpenCodeChat(req, res, merged.opencode, body);
+                await forwardOpenCodeChat(req, res, merged.opencode, body, signal);
                 return;
             }
             sendJson(res, 404, {
@@ -696,6 +731,9 @@ export function createBridgeServer(options = {}) {
             });
         }
         catch (err) {
+            // 客户端已经走了就没人读响应了，不必再写。
+            if (signal.aborted || res.writableEnded)
+                return;
             if (err instanceof RequestBodyTooLargeError) {
                 sendJson(res, 413, {
                     error: { code: "request_too_large", message: err.message },
@@ -708,6 +746,13 @@ export function createBridgeServer(options = {}) {
                 },
             });
         }
+        finally {
+            res.off("close", abort);
+            req.off("aborted", abort);
+            socket?.off("close", abort);
+            if (isDataPlane)
+                gate.release();
+        }
     });
 }
 export function listenBridge(port, host, options = {}) {

package/dist/bridge/state.js

@@ -240,41 +240,73 @@ function persistState(next) {
  * revision must equal the on-disk revision (compare-and-set).
  */
 export function writeBridgeState(state) {
-    const current = readBridgeState();
-    if (existsSync(getBridgeStatePath()) && state.revision !== current.revision) {
-        throw new BridgeStateConflictError(current.revision, state.revision);
-    }
-    const next = withFlatAliases({
-        version: STATE_VERSION,
-        revision: current.revision + 1,
-        listener: state.listener,
-        instance: state.instance,
-        upstreams: normalizeBridgeUpstreams(state.upstreams),
-        pending: state.pending,
+    return withBridgeLock(() => {
+        const current = readBridgeState();
+        if (existsSync(getBridgeStatePath()) &&
+            state.revision !== current.revision) {
+            throw new BridgeStateConflictError(current.revision, state.revision);
+        }
+        const next = withFlatAliases({
+            version: STATE_VERSION,
+            revision: current.revision + 1,
+            listener: state.listener,
+            instance: state.instance,
+            upstreams: normalizeBridgeUpstreams(state.upstreams),
+            pending: state.pending,
+        });
+        persistState(next);
+        return next;
     });
-    persistState(next);
-    return next;
 }
 /**
  * Atomically mutate state under compare-and-set. `expectedRevision` defaults to
  * the current on-disk revision.
+ *
+ * The read-modify-write runs inside the on-disk bridge lock. Without it two
+ * concurrent `llms <tool> use` runs can interleave: both read the same revision,
+ * both write, and one side's upstream (or the daemon's instance identity) is
+ * lost — which then makes `bridge stop` unable to recognise the live daemon.
  */
 export function updateBridgeState(mutate, expectedRevision) {
-    const current = readBridgeState();
-    if (expectedRevision !== undefined && expectedRevision !== current.revision) {
-        throw new BridgeStateConflictError(current.revision, expectedRevision);
-    }
-    const mutated = mutate(current);
-    const next = withFlatAliases({
-        version: STATE_VERSION,
-        revision: current.revision + 1,
-        listener: mutated.listener,
-        instance: mutated.instance,
-        upstreams: normalizeBridgeUpstreams(mutated.upstreams),
-        pending: mutated.pending,
+    return withBridgeLock(() => {
+        const current = readBridgeState();
+        if (expectedRevision !== undefined &&
+            expectedRevision !== current.revision) {
+            throw new BridgeStateConflictError(current.revision, expectedRevision);
+        }
+        const mutated = mutate(current);
+        const next = withFlatAliases({
+            version: STATE_VERSION,
+            revision: current.revision + 1,
+            listener: mutated.listener,
+            instance: mutated.instance,
+            upstreams: normalizeBridgeUpstreams(mutated.upstreams),
+            pending: mutated.pending,
+        });
+        persistState(next);
+        return next;
     });
-    persistState(next);
-    return next;
+}
+/**
+ * Run `fn` while holding the exclusive bridge lock.
+ *
+ * Reentrant within a process: the file lock uses `flag: "wx"`, so a nested
+ * acquire from the same process would block until it timed out. A depth counter
+ * keeps nested writes (e.g. clearBridgeUpstream → stopBridge) working.
+ */
+let bridgeLockDepth = 0;
+export function withBridgeLock(fn) {
+    if (bridgeLockDepth > 0)
+        return fn();
+    const lock = acquireBridgeLock();
+    bridgeLockDepth += 1;
+    try {
+        return fn();
+    }
+    finally {
+        bridgeLockDepth -= 1;
+        lock.release();
+    }
 }
 // --- upstream facade (compat) ----------------------------------------------
 export function readBridgeUpstreams() {

package/dist/bridge/translate-response.js

@@ -37,6 +37,9 @@ export function createStreamState(model, responseId, customTools, webSearchEnabl
         textItemId: null,
         textStarted: false,
         textContentIndex: 0,
+        reasoningItemId: null,
+        reasoningStarted: false,
+        reasoningText: "",
         outputIndex: 0,
         currentText: "",
         completedItems: [],
@@ -147,6 +150,8 @@ function ensureCreated(state, out) {
 function ensureTextItem(state, out) {
     if (state.textStarted)
         return;
+    // reasoning 必须排在正文之前，先把它收尾再开正文项。
+    closeReasoningItem(state, out);
     state.textStarted = true;
     state.textItemId = newId("msg");
     state.currentText = "";
@@ -168,6 +173,74 @@ function ensureTextItem(state, out) {
         part: { type: "output_text", text: "", annotations: [] },
     }));
 }
+/**
+ * Reasoning models on Chat Completions upstreams stream their chain of thought
+ * as `delta.reasoning_content`. Responses clients (Codex) expect it as a
+ * `reasoning` output item with summary text, so surface it instead of dropping it.
+ */
+function ensureReasoningItem(state, out) {
+    if (state.reasoningStarted)
+        return;
+    state.reasoningStarted = true;
+    state.reasoningItemId = newId("rs");
+    state.reasoningText = "";
+    out.push(sseEvent("response.output_item.added", {
+        output_index: state.outputIndex,
+        item: {
+            id: state.reasoningItemId,
+            type: "reasoning",
+            status: "in_progress",
+            summary: [],
+        },
+    }));
+    out.push(sseEvent("response.reasoning_summary_part.added", {
+        item_id: state.reasoningItemId,
+        output_index: state.outputIndex,
+        summary_index: 0,
+        part: { type: "summary_text", text: "" },
+    }));
+}
+function emitReasoningDelta(state, out, content) {
+    if (!content)
+        return;
+    ensureReasoningItem(state, out);
+    state.reasoningText += content;
+    out.push(sseEvent("response.reasoning_summary_text.delta", {
+        item_id: state.reasoningItemId,
+        output_index: state.outputIndex,
+        summary_index: 0,
+        delta: content,
+    }));
+}
+function closeReasoningItem(state, out) {
+    if (!state.reasoningStarted || !state.reasoningItemId)
+        return;
+    const outputIndex = state.outputIndex;
+    const item = {
+        id: state.reasoningItemId,
+        type: "reasoning",
+        status: "completed",
+        summary: [{ type: "summary_text", text: state.reasoningText }],
+    };
+    out.push(sseEvent("response.reasoning_summary_text.done", {
+        item_id: state.reasoningItemId,
+        output_index: outputIndex,
+        summary_index: 0,
+        text: state.reasoningText,
+    }));
+    out.push(sseEvent("response.reasoning_summary_part.done", {
+        item_id: state.reasoningItemId,
+        output_index: outputIndex,
+        summary_index: 0,
+        part: { type: "summary_text", text: state.reasoningText },
+    }));
+    out.push(sseEvent("response.output_item.done", { output_index: outputIndex, item }));
+    state.completedItems.push({ outputIndex, item });
+    state.outputIndex += 1;
+    state.reasoningStarted = false;
+    state.reasoningItemId = null;
+    state.reasoningText = "";
+}
 function emitTextDelta(state, out, content) {
     if (!content)
         return;
@@ -279,6 +352,14 @@ export function chatChunkToResponsesEvents(chunk, state) {
         const choice = choiceRaw;
         const delta = (choice.delta || choice.message || {});
         const finish = choice.finish_reason;
+        const reasoningDelta = typeof delta.reasoning_content === "string"
+            ? delta.reasoning_content
+            : typeof delta.reasoning === "string"
+                ? delta.reasoning
+                : "";
+        if (reasoningDelta) {
+            emitReasoningDelta(state, out, reasoningDelta);
+        }
         if (typeof delta.content === "string" && delta.content.length > 0) {
             consumeTextContent(state, out, delta.content);
         }
@@ -448,6 +529,8 @@ function finalizeStream(state, out, finishReason) {
     if (state.textStarted && state.textItemId) {
         closeTextItem(state, out);
     }
+    // 只有 reasoning 没有正文的回复（或工具调用前只推理）也要把 reasoning 收尾。
+    closeReasoningItem(state, out);
     for (const entry of state.toolCalls.values()) {
         if (!entry.started)
             continue;
@@ -549,6 +632,21 @@ export function chatCompletionToResponse(chat, modelFallback, customTools, webSe
     const content = typeof message.content === "string"
         ? message.content
         : textFromCompletions;
+    // 推理模型在 Chat 上游用 reasoning_content 返回思维链；Responses 客户端
+    // （Codex）读的是 reasoning 输出项，之前这段内容被整体丢弃。
+    const reasoningText = typeof message.reasoning_content === "string"
+        ? message.reasoning_content
+        : typeof message.reasoning === "string"
+            ? message.reasoning
+            : "";
+    if (reasoningText) {
+        output.push({
+            id: newId("rs"),
+            type: "reasoning",
+            status: "completed",
+            summary: [{ type: "summary_text", text: reasoningText }],
+        });
+    }
     for (const segment of splitWebSearchContent(content, webSearchEnabled)) {
         if (segment.type === "web_search") {
             output.push({

package/dist/bridge/transport.js

@@ -66,6 +66,39 @@ export function selectProxyUrl(_target, proxy) {
  * Build a fresh per-request Agent for the given proxy URL. Callers own its
  * lifecycle and must call `.destroy()` once the response is drained.
  */
+/**
+ * Proxy agents are cached and keep-alive.
+ *
+ * A fresh Agent per request meant a new TCP+TLS (and CONNECT) handshake for
+ * every upstream call, which is significant on chatty streaming workloads.
+ * Cached agents are shared, so they must never be destroyed on a single
+ * request's failure — Node's Agent already evicts broken sockets itself.
+ * Keyed by proxy URL because socks5 vs socks5h changes DNS resolution.
+ */
+const proxyAgentCache = new Map();
+const PROXY_AGENT_CACHE_MAX = 16;
+export function getProxyAgent(target, proxyUrl) {
+    const key = `${proxyUrl}|${target.protocol}`;
+    const cached = proxyAgentCache.get(key);
+    if (cached)
+        return cached;
+    const agent = createTransportAgent(target, proxyUrl);
+    if (proxyAgentCache.size >= PROXY_AGENT_CACHE_MAX) {
+        // 简单淘汰：清掉最早插入的一个，避免无界增长。
+        const oldest = proxyAgentCache.keys().next().value;
+        if (oldest !== undefined)
+            proxyAgentCache.delete(oldest);
+    }
+    proxyAgentCache.set(key, agent);
+    return agent;
+}
+/** Test seam: drop cached agents. */
+export function clearProxyAgentCache() {
+    for (const agent of proxyAgentCache.values()) {
+        agent.destroy?.();
+    }
+    proxyAgentCache.clear();
+}
 export function createTransportAgent(_target, proxyUrl) {
     let proxy;
     try {
@@ -78,10 +111,10 @@ export function createTransportAgent(_target, proxyUrl) {
         throw new TransportProtocolError(`不支持的 proxy protocol: ${proxy.protocol}`);
     }
     if (proxy.protocol === "http:" || proxy.protocol === "https:") {
-        return new HttpsProxyAgent(proxy);
+        return new HttpsProxyAgent(proxy, { keepAlive: true });
     }
     // socks5 resolves DNS locally; socks5h/socks4a defer to the proxy.
-    return new SocksProxyAgent(proxy);
+    return new SocksProxyAgent(proxy, { keepAlive: true });
 }
 function sanitizeHeaders(headers) {
     const out = {};
@@ -274,7 +307,8 @@ function parseTarget(url) {
 }
 function performRequest(target, options) {
     const proxyUrl = selectProxyUrl(target, options.proxy);
-    const agent = proxyUrl ? createTransportAgent(target, proxyUrl) : undefined;
+    // 复用同一个代理 Agent（keep-alive）；无代理时走 Node 全局 agent，本身已 keep-alive。
+    const agent = proxyUrl ? getProxyAgent(target, proxyUrl) : undefined;
     const isHttps = target.protocol === "https:";
     const requestImpl = isHttps ? httpsRequest : httpRequest;
     const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
@@ -299,11 +333,8 @@ function performRequest(target, options) {
                 timers.clear();
             },
         };
-        const cleanupAgent = () => {
-            if (agent && typeof agent.destroy === "function") {
-                agent.destroy();
-            }
-        };
+        // Agent 是共享的，单个请求失败不能销毁它，否则会连带打断其他在途请求。
+        const cleanupAgent = () => { };
         const fail = (err) => {
             if (settled)
                 return;

package/dist/cli.js

@@ -14,7 +14,10 @@ export function createProgram() {
         .name("llms")
         .description("为 Claude Code / Codex / OpenCode 切换供应商、模型与上游代理")
         .version(getVersion())
-        .option("--json", "部分命令支持 JSON 输出（见子命令）");
+        // 注意：不要在根命令上声明 --json。commander 会把它当作根命令的选项，
+        // 从而吞掉所有子命令自己的 --json（子命令 opts.json 恒为 undefined）。
+        // JSON 输出一律由各子命令自行声明。
+        .showSuggestionAfterError();
     program
         .command("path")
         .description("显示 llm-switch 本地配置目录")
@@ -42,11 +45,20 @@ export async function run(argv = process.argv) {
         await program.parseAsync(argv);
     }
     catch (err) {
-        if (err &&
-            typeof err === "object" &&
-            "code" in err &&
-            (err.code === "commander.helpDisplayed" ||
-                err.code === "commander.version")) {
+        const code = err && typeof err === "object" && "code" in err
+            ? String(err.code)
+            : "";
+        if (code === "commander.helpDisplayed" ||
+            code === "commander.help" ||
+            code === "commander.version") {
+            return;
+        }
+        // commander 已经把用法错误写到 stderr 了，不要再加「错误：」重复打印一遍。
+        if (code.startsWith("commander.")) {
+            process.exitCode =
+                typeof err.exitCode === "number"
+                    ? err.exitCode
+                    : 1;
             return;
         }
         const message = err instanceof Error ? err.message : String(err);

package/dist/commands/bridge-cmd.js

@@ -1,9 +1,9 @@
-import { ensureBridgeForProfile, isBridgeAlive, isPidRunning, readPid, runBridgeForeground, startBridgeDaemon, stopBridge, } from "../bridge/manager.js";
+import { bridgeToolForCliTool, ensureBridgeForProfile, isBridgeAlive, isPidRunning, profileNeedsBridge, readPid, runBridgeForeground, startBridgeDaemon, stopBridge, } from "../bridge/manager.js";
 import { bridgeBaseUrl, bridgeRootUrl, readBridgeState, } from "../bridge/state.js";
 import { parseBridgePort } from "../bridge/runtime.js";
 import { DEFAULT_BRIDGE_HOST, DEFAULT_BRIDGE_PORT } from "../bridge/types.js";
 import { getActiveProfile, resolveProfileOrThrow } from "../store/profiles.js";
-import { isTool } from "../types.js";
+import { TOOLS, isTool } from "../types.js";
 export function registerBridgeCommand(program) {
     const bridge = program
         .command("bridge")
@@ -81,7 +81,7 @@ export function registerBridgeCommand(program) {
         }
         console.log(`状态：${alive ? "运行中" : "未运行"}`);
         console.log(`根地址：${data.rootUrl}`);
-        console.log(`Codex/OpenCode base：${data.codexBaseUrl}`);
+        console.log(`OpenAI 兼容 base：${data.codexBaseUrl}`);
         console.log(`PID：${pid ?? "-"}`);
         for (const tool of ["codex", "claude", "opencode"]) {
             const u = data.upstreams[tool];
@@ -96,19 +96,26 @@ export function registerBridgeCommand(program) {
     bridge
         .command("reload")
         .description("用当前启用的 profile 刷新某一侧上游（不重启进程）")
-        .argument("[tool]", "claude 或 codex（默认 codex）", "codex")
+        .argument("[tool]", `claude | codex | opencode（默认 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");
+        if (!isTool(toolName)) {
+            throw new Error(`未知工具「${toolName}」。可选：${TOOLS.join("、")}`);
+        }
+        // 三个工具都可能走 bridge（openai-chat 上游），reload 必须全部支持。
+        const tool = bridgeToolForCliTool(toolName);
+        if (!tool) {
+            throw new Error(`${toolName} 不使用本地 bridge`);
         }
-        const tool = toolName;
         const profile = opts.profile
             ? resolveProfileOrThrow(tool, opts.profile)
             : getActiveProfile(tool);
         if (!profile) {
-            throw new Error(`没有可用的 ${tool} profile`);
+            throw new Error(`没有已启用的 ${tool} profile。可用：llms ${tool} use，或 llms bridge reload ${tool} --profile <name>`);
+        }
+        if (!profileNeedsBridge(profile)) {
+            throw new Error(`${tool}/${profile.name} 是 ${profile.apiFormat} 原生直连，不经过 bridge，无需 reload。`);
         }
         const connection = await ensureBridgeForProfile(profile, tool);
         console.log(`已刷新 ${tool} 上游 ${profile.name} → bridge ${connection.baseUrl}`);