mslxdff 0.1.79 → 0.1.80

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.79",
+  "version": "0.1.80",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/bench/report.js

@@ -23,8 +23,22 @@ function pad(s, n, align = "left") {
   return str + " ".repeat(d);
 }
 
+function shortPeerLabel(p) {
+  const raw = String(p?.name || p?.id || p?.url || String(p || "")).trim();
+  if (!raw) return "peer";
+  // 优先用 name；若是 url 则取 host:port 的尾段
+  if (raw.startsWith("http://") || raw.startsWith("https://") || raw.startsWith("relay://")) {
+    try { const u = new URL(raw); const host = u.hostname; const port = u.port ? `:${u.port}` : ""; if (host) return `${host}${port}`; } catch {}
+    return raw.slice(-12);
+  }
+  // name 可能是 url 字符串（如 "http://141.98..." 存于 name 字段）
+  if (raw.includes("://")) {
+    try { const u = new URL(raw); return u.hostname + (u.port ? `:${u.port}` : ""); } catch {}
+  }
+  return raw;
+}
 export function formatViaReport(results, { peers = [], meta = {}, json = false } = {}) {
-  const peerIds = (peers || []).map((p) => p.id || p.url || String(p));
+  const peerIds = (peers || []).map((p) => shortPeerLabel(p));
   const samples = meta.samples ?? 1;
   const timeout = meta.timeout ?? 30000;
   const includeOpencode = Boolean(meta.includeOpencode);
@@ -53,9 +67,11 @@ export function formatViaReport(results, { peers = [], meta = {}, json = false }
     return { text: JSON.stringify(jsonObj, null, 2), json: jsonObj };
   }
   const lines = [];
-  lines.push(`bench-via: direct vs via peers (samples=${samples}, timeout=${timeout / 1000}s, ${opencodeTag})`);
+  lines.push(`bench-via: direct vs via peers (samples=${samples}, timeout=${timeout / 1000}s, ${opencodeTag}) peers=${peerIds.join(",") || "(none)"}`);
   lines.push("");
-  const header = `${pad("Provider", 12)} ${pad("Model", 24)} ${pad("direct", 8, "right")} ${peerIds.map((id) => pad(`via ${id}`, 10, "right")).join(" ")} ${pad("best", 14)}`;
+  // 表头：直连 + 每个组员一列（短化为 host:port 或 name），兼容旧测试 via B 断言与用户“直连/组员B”心智
+  const colW = 18;
+  const header = `${pad("Provider", 12)} ${pad("Model", 24)} ${pad("direct", colW, "right")} ${peerIds.map((id) => pad(`via ${id}`, colW, "right")).join(" ")} ${pad("best", 14)}`;
   lines.push(header);
   lines.push("─".repeat(header.length));
   for (const r of results || []) {
@@ -73,19 +89,20 @@ export function formatViaReport(results, { peers = [], meta = {}, json = false }
     let bestKey = r.best;
     if (!bestKey && all.length) bestKey = all.sort((a, b) => a.ttfb - b.ttfb)[0].key;
     const isDirectBest = bestKey === "direct";
-    const directCell = pad(`${directTxt}${isDirectBest ? "★" : ""}`, 8, "right");
+    const directCell = pad(`${directTxt}${isDirectBest ? "★" : ""}`, colW, "right");
     const viaCells = peerIds.map((pid) => {
       const v = r.via?.[pid];
-      if (!v) return pad("—", 10, "right");
+      if (!v) return pad("—", colW, "right");
       if (v.ok) {
         const txt = `${v.ttfbMs ?? v.totalMs ?? "—"}ms`;
         const star = bestKey === `via:${pid}` ? "★" : "";
-        return pad(`${txt}${star}`, 10, "right");
+        return pad(`${txt}${star}`, colW, "right");
       }
+      // 失败也展示延迟（先测延迟）：如 42ms 鉴权失败，说明网络可达但该组员未配此供应商
+      const ms = v.ttfbMs != null ? `${v.ttfbMs}ms ` : "";
       const label = v.label || v.error || "offline";
-      // map offline label
       const short = label.includes("离线") ? "offline" : label.slice(0, 8);
-      return pad(`— ${short}`, 10, "right");
+      return pad(`${ms}— ${short}`, colW, "right");
     }).join(" ");
     let bestTxt = r.best || "direct";
     if (r.deltaMs != null && r.best?.startsWith("via:")) {

package/src/bench/via-probe.js

@@ -36,11 +36,64 @@ export async function viaProbe({
   timeoutMs = 30000,
   fetchImpl = globalThis.fetch,
   clock = Date.now,
+  shareKeys,
+  shareKeysHeader,
+  relayTarget,
+  relayHeaders,
+  relayBody,
+  targetUrl,
 } = {}) {
   const started = clock();
   const t0 = typeof performance !== "undefined" && performance.now ? performance.now() : started;
   const base = String(peerUrl || "").replace(/\/+$/, "");
   if (!base) return { ok: false, label: "配置错误", error: "missing peerUrl", ttfbMs: null, totalMs: 0, tps: null, charsPerSec: null, tokens: null };
+  // 纯中继模式：A 把 targetUrl+headers+body 发给 B，B 原样 fetch 到上游（不查 B 本地 providerConfigs）
+  const rt = String(relayTarget || targetUrl || "").trim();
+  if (rt) {
+    const rh = relayHeaders && typeof relayHeaders === "object" ? relayHeaders : {};
+    const rb = relayBody !== undefined ? relayBody : null;
+    const relayUrl = joinUrl(base, "/v1/relay");
+    const relayHeadersOut = { "Content-Type": "application/json", Accept: "application/json" };
+    if (token) relayHeadersOut.Authorization = `Bearer ${token}`;
+    const payload = { targetUrl: rt, method: "POST", headers: rh, body: rb };
+    let ttfbMs = null;
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(new Error(`timeout ${timeoutMs}ms`)), timeoutMs);
+      const fetchStart = typeof performance !== "undefined" && performance.now ? performance.now() : clock();
+      let res;
+      try { res = await fetchImpl(relayUrl, { method: "POST", headers: relayHeadersOut, body: JSON.stringify(payload), signal: controller.signal }); } finally { clearTimeout(timer); }
+      ttfbMs = Math.round((typeof performance !== "undefined" && performance.now ? performance.now() : clock()) - fetchStart);
+      const totalMs = Math.round((typeof performance !== "undefined" && performance.now ? performance.now() : clock()) - t0);
+      if (!res.ok) {
+        let txt = ""; try { txt = await res.text(); } catch {}
+        const cls = classifyError(res.status, txt);
+        const msg = extractInnerMessage(txt) || `HTTP ${res.status}`;
+        return { ok: false, status: res.status, label: cls.label, error: msg, ttfbMs, totalMs, tps: null, charsPerSec: null, tokens: null };
+      }
+      let txt = ""; let j = {};
+      try { txt = await res.text(); j = JSON.parse(txt); } catch { j = {}; }
+      const relayStatus = res.headers.get("x-mslxdff-relay-status") ? Number(res.headers.get("x-mslxdff-relay-status")) : res.status;
+      if (relayStatus >= 400) {
+        const cls = classifyError(relayStatus, txt);
+        const msg = extractInnerMessage(txt) || `HTTP ${relayStatus}`;
+        return { ok: false, status: relayStatus, label: cls.label, error: msg, ttfbMs, totalMs, tps: null, charsPerSec: null, tokens: null };
+      }
+      const usage = extractUsageFromJson(j);
+      const content = j?.choices?.[0]?.message?.content || j?.choices?.[0]?.text || txt || "";
+      const chars = typeof content === "string" ? content.length : 0;
+      const pt = usage?.prompt_tokens ?? null;
+      const ct = usage?.completion_tokens ?? null;
+      const { tps, charsPerSec } = computeMetrics({ ttfbMs, totalMs, promptTokens: pt, completionTokens: ct, chars });
+      const totalTokens = usage?.total_tokens ?? (pt !== null && ct !== null ? pt + ct : null);
+      return { ok: true, status: relayStatus, label: "成功", ttfbMs, totalMs, tps, charsPerSec, tokens: { prompt: pt, completion: ct, total: totalTokens }, chars };
+    } catch (e) {
+      const totalMs = Math.round((typeof performance !== "undefined" && performance.now ? performance.now() : clock()) - t0);
+      const msg = e?.message || String(e);
+      const isTimeout = /timeout|abort/i.test(msg);
+      return { ok: false, label: isTimeout ? "超时" : "网络错误", error: msg.slice(0, 300), ttfbMs, totalMs, tps: null, charsPerSec: null, tokens: null };
+    }
+  }
   if (!model) return { ok: false, label: "配置错误", error: "missing model", ttfbMs: null, totalMs: 0, tps: null, charsPerSec: null, tokens: null };
   let rawModel = String(model).trim();
   if (providerId && rawModel.startsWith(`${providerId}/`)) rawModel = rawModel.slice(providerId.length + 1);
@@ -48,6 +101,8 @@ export async function viaProbe({
   const body = { model: rawModel, stream: false, messages: [{ role: "user", content: prompt }], max_tokens: maxTokens };
   const headers = { "Content-Type": "application/json", Accept: "application/json" };
   if (token) headers.Authorization = `Bearer ${token}`;
+  const sk = shareKeysHeader || shareKeys;
+  if (sk) headers["x-mslxdff-share-keys"] = String(sk);
   let ttfbMs = null;
   try {
     const controller = new AbortController();

package/src/bench/via.js

@@ -99,9 +99,13 @@ export async function orchestrateVia({
     }
     const via = {};
     for (const peer of peers) {
-      const peerId = peer.id || peer.url || "peer";
+      const raw = String(peer.name || peer.id || peer.url || "peer");
+      let peerId = raw;
+      // 仅当 raw 本身就是 url 时才短化；显式 name/id 保持原样，避免 B → b:8989
+      if (!peer.name && !peer.id && raw.includes("://")) { try { const u = new URL(raw); peerId = u.hostname + (u.port ? `:${u.port}` : ""); } catch { peerId = raw.slice(-16); } }
+      const peerToken = peer.token || token || "";
       try {
-        const r = await viaProbeFn({ peerUrl: peer.url, token, providerId: provider, model, prompt: "hi", maxTokens: 5, timeoutMs, clock });
+        const r = await viaProbeFn({ peerUrl: peer.url, token: peerToken, providerId: provider, model, prompt: "hi", maxTokens: 5, timeoutMs, clock });
         via[peerId] = r;
       } catch (e) {
         via[peerId] = { ok: false, label: "网络错误", error: String(e?.message || e), ttfbMs: null, totalMs: 0 };

package/src/chat/gateway.js

@@ -136,9 +136,13 @@ export function createGatewayClient({
       }
       return { ok: true, message: choice.message, usage: effectiveJ.usage || j.usage, raw: j, status: res.status, model: rawModel, provider, viaGateway: true };
     } catch (err) {
-      const msg = String(err?.message || err).slice(0, 800);
-      if (env.MSLXDFF_CHAT_TRACE !== "0") {
-        const dt2 = performance.now() - (performance.now() - 0); // placeholder, TRACE off in tests
+      const raw = String(err?.message || err);
+      const msg = raw.slice(0, 800);
+      const isConnRefused = /ECONNREFUSED|Failed to fetch|fetch failed|connect ECONNREFUSED|ECONNRESET|EADDRNOTAVAIL/i.test(raw);
+      if (isConnRefused) {
+        const friendly = `本地服务没有启动无法使用auto模式，请mslxdff -d 启动（本地网关 http://127.0.0.1:${port} 拒绝连接）— 3ms 内失败说明未触达任何模型（非模型额度问题）；若已改端口请用 mslxdff -port N 或 MSLXDFF_PORT=${port} 保持一致`;
+        if (TRACE) console.log(`\x1b[90m· [LLM] gateway auto FAIL · ${Math.round(performance.now() - t0)}ms · ${friendly} · ${msg.slice(0, 80)}\x1b[0m`);
+        return { ok: false, error: friendly, status: 502, code: "GATEWAY_NOT_RUNNING", port, raw: msg };
       }
       return { ok: false, error: `gateway ${msg}`, status: 502 };
     }

package/src/chat/orchestrator.js

@@ -64,7 +64,7 @@ export function createOrchestrator({
     let first;
     let firstMs = 0;
     if (firstCooling) {
-      if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} 跳过（冷却中）· 直接试 ${CHAT_FALLBACK}\x1b[0m`);
+      if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} 跳过（冷却 10min）· 额度用完，准备走网关 auto（将尝试其他可用模型）\x1b[0m`);
       first = { ok: false, error: "skip cooling", status: 429 };
     } else {
       const t = perf.now();
@@ -81,13 +81,16 @@ export function createOrchestrator({
     }
 
     if (firstCooling) {
-      if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} 冷却中（${CHAT_COOLDOWN_MS / 60000}min）· 直接走网关 auto，跳过 ${CHAT_FALLBACK}\x1b[0m`);
-      if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} 冷却，直接走网关 auto（:8989）\x1b[0m`);
+      if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} 冷却中（${CHAT_COOLDOWN_MS / 60000}min）· 直接走网关 auto（:8989），按 auto 择优尝试其他可用模型，跳过 ${CHAT_FALLBACK} 直连\x1b[0m`);
       const t2 = TRACE ? perf.now() : 0;
       const third = await _gateway(opts);
       if (TRACE) console.log(`\x1b[90m· [LLM] gateway auto ${third.ok ? "OK" : "FAIL"} · ${Math.round(perf.now() - t2)}ms · 总 ${Math.round(perf.now() - t0)}ms (gateway-fallback)\x1b[0m`);
       if (third.ok) return { ...third, model: third.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: "skip big-pickle (mimo cooling)", viaGateway: true };
-      return { ok: false, error: `${CHAT_PREFERRED} cooling: ${first.error}; gateway auto failed: ${third.error}`, status: third.status || 429 };
+      const isGwDown = third.code === "GATEWAY_NOT_RUNNING" || /本地(网关未运行|服务没有启动)/.test(String(third.error || ""));
+      if (isGwDown) {
+        return { ok: false, error: `${CHAT_PREFERRED} 冷却跳过（额度用完 10min）；${third.error} —— 本次 auto 未能尝试任何其他模型，因网关未就绪（3ms 失败即证明未触达上游，请先启动网关再重试）`, status: 502, code: "GATEWAY_NOT_RUNNING" };
+      }
+      return { ok: false, error: `${CHAT_PREFERRED} 冷却跳过（额度用完）；网关 auto 已尝试其他可用模型但均失败：${third.error}（总 ${Math.round(perf.now() - t0)}ms）`, status: third.status || 429 };
     }
 
     const secondCooling = await isCoolingAsync(CHAT_FALLBACK);
@@ -102,12 +105,14 @@ export function createOrchestrator({
     };
 
     if (secondCooling) {
-      if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_FALLBACK} 跳过（冷却中）· 直接走网关 auto\x1b[0m`);
+      if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_FALLBACK} 跳过（冷却中）· 直接走网关 auto（将尝试其他可用模型）\x1b[0m`);
       const t2 = perf.now();
       const third = await doGateway();
       if (TRACE) console.log(`\x1b[90m· [LLM] gateway auto ${third.ok ? "OK" : "FAIL"} · ${Math.round(perf.now() - t2)}ms · 总 ${Math.round(perf.now() - t0)}ms (gateway-fallback)\x1b[0m`);
       if (third.ok) return { ...third, model: third.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: "skip cooling", viaGateway: true };
-      return { ok: false, error: `${CHAT_PREFERRED} failed: ${first.error}; ${CHAT_FALLBACK} failed: skip cooling; gateway auto failed: ${third.error}`, status: third.status || first.status };
+      const isGwDown2 = third.code === "GATEWAY_NOT_RUNNING" || /本地(网关未运行|服务没有启动)/.test(String(third.error || ""));
+      if (isGwDown2) return { ok: false, error: `${CHAT_PREFERRED} 失败：${first.error}；${CHAT_FALLBACK} 冷却跳过；${third.error} —— auto 未能尝试其他模型（网关未就绪）`, status: 502, code: "GATEWAY_NOT_RUNNING" };
+      return { ok: false, error: `${CHAT_PREFERRED} 失败：${first.error}；${CHAT_FALLBACK} 冷却跳过；网关 auto 已尝试其他模型但均失败：${third.error}（总 ${Math.round(perf.now() - t0)}ms）`, status: third.status || first.status };
     }
 
     if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} 失败，${CHAT_FALLBACK} + gateway 对冲中（${HEDGE_MS}ms）\x1b[0m`);
@@ -167,7 +172,9 @@ export function createOrchestrator({
       secondRes = sRes; gatewayRes = gRes;
       if (sRes?.ok) return { ...sRes, model: CHAT_FALLBACK, fallback: true, firstError: first.error };
       if (gRes?.ok) return { ...gRes, model: gRes.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: sRes?.error, viaGateway: true };
-      return { ok: false, error: `${CHAT_PREFERRED} failed: ${first.error}; ${CHAT_FALLBACK} failed: ${sRes?.error}; gateway auto failed: ${gRes?.error}`, status: gRes?.status || sRes?.status || first.status };
+      const gwDown0 = gRes?.code === "GATEWAY_NOT_RUNNING" || /本地(网关未运行|服务没有启动)/.test(String(gRes?.error || ""));
+      if (gwDown0) return { ok: false, error: `${CHAT_PREFERRED} 失败：${first.error}；${CHAT_FALLBACK} 失败：${sRes?.error}；${gRes?.error} —— gateway 侧 auto 未能尝试其他模型（网关未就绪）`, status: 502, code: "GATEWAY_NOT_RUNNING" };
+      return { ok: false, error: `${CHAT_PREFERRED} 失败：${first.error}；${CHAT_FALLBACK} 失败：${sRes?.error}；网关 auto 已尝试其他模型但均失败：${gRes?.error}（总 ${Math.round(perf.now() - t0)}ms）`, status: gRes?.status || sRes?.status || first.status };
     }
 
     const raced = await raceFirstOk();
@@ -183,7 +190,9 @@ export function createOrchestrator({
       try { gatewayRes = await (gatewayPromise || doGateway()); } catch (e) { gatewayRes = { ok: false, error: String(e), status: 502 }; }
     }
     if (gatewayRes?.ok) return { ...gatewayRes, model: gatewayRes.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: secondRes?.error, viaGateway: true };
-    return { ok: false, error: `${CHAT_PREFERRED} failed: ${first.error}; ${CHAT_FALLBACK} failed: ${secondRes?.error}; gateway auto failed: ${gatewayRes?.error}`, status: gatewayRes?.status || secondRes?.status || first.status };
+    const gwDown = gatewayRes?.code === "GATEWAY_NOT_RUNNING" || /本地(网关未运行|服务没有启动)/.test(String(gatewayRes?.error || ""));
+    if (gwDown) return { ok: false, error: `${CHAT_PREFERRED} 失败：${first.error}；${CHAT_FALLBACK} 失败：${secondRes?.error}；${gatewayRes?.error} —— gateway 侧 auto 未能尝试其他模型（网关未就绪）`, status: 502, code: "GATEWAY_NOT_RUNNING" };
+    return { ok: false, error: `${CHAT_PREFERRED} 失败：${first.error}；${CHAT_FALLBACK} 失败：${secondRes?.error}；网关 auto 已尝试其他模型但均失败：${gatewayRes?.error}（总 ${Math.round(perf.now() - t0)}ms）`, status: gatewayRes?.status || secondRes?.status || first.status };
   }
 
   async function summarizeHistory(messages) {

package/src/chat/repl.js

@@ -6,7 +6,7 @@ import { getToolDefs, execCommand, readFileTool, curlTool } from "./tools.js";
 import { chatWithFallback, summarizeHistory } from "./upstream.js";
 import { loadHistory, saveHistory, clearHistory, histPath, estimateChars, needsCompress } from "./store.js";
 import { CHAT_KEEP_RECENT, CHAT_MAX_TOOL_LOOPS, CHAT_PREFERRED, CHAT_FALLBACK } from "./config.js";
-import { formatBannerLines, formatStatsDetail, collectStats } from "./stats.js";
+import { formatBannerLines, formatStatsDetail, collectStats, probeGateway } from "./stats.js";
 import { createSpinner } from "./spinner.js";
 import { normalizeFullId } from "../providers/model-id.js";
 
@@ -18,9 +18,17 @@ const SLASH_HELP = `自然语言直接说，斜杠快捷：
   /exit     退出
 示例：设置 hy3 为默认模型 / 查看组列表 / 看最近20条日志 / 读一下 src/logs.js`;
 
-function printBanner() {
-  const { lines } = formatBannerLines();
+async function printBanner() {
+  let probe = null;
+  try {
+    const s = collectStats();
+    probe = await probeGateway(s.port, 800);
+  } catch {}
+  const { lines } = formatBannerLines(probe);
   for (const l of lines) console.log(l);
+  if (probe && !probe.alive) {
+    console.log(`\x1b[31m本地服务没有启动无法使用auto模式，请mslxdff -d 启动\x1b[0m`);
+  }
   console.log(`\x1b[90m输入自然语言即可执行；/help 帮助，/stats 看网关统计，/exit 退出\x1b[0m`);
   console.log(`\x1b[90m历史：${histPath()} · 仅拦截 -uninstall · 数据来自网关 -d，非本会话计数\x1b[0m`);
 }
@@ -283,7 +291,7 @@ export async function startRepl({ singleShot } = {}) {
     saveHistory(messages.slice(1));
     return;
   }
-  printBanner();
+  await printBanner();
   const rl = readline.createInterface({ input: stdin, output: stdout, prompt: `\x1b[36m${CHAT_PREFERRED.split("-")[0]}>\x1b[0m ` });
   rl.prompt();
   for await (const line of rl) {

package/src/chat/stats.js

@@ -141,17 +141,40 @@ export function collectStats() {
   };
 }
 
-export function formatBannerLines() {
+export async function probeGateway(port, timeoutMs = 800) {
+  const url = `http://127.0.0.1:${port}/health`;
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const r = await fetch(url, { signal: ctrl.signal });
+    clearTimeout(t);
+    return { alive: r.ok, status: r.status, ms: 0 };
+  } catch (e) {
+    clearTimeout(t);
+    const msg = String(e?.message || e);
+    const isRefused = /ECONNREFUSED|Failed to fetch|fetch failed|ECONNRESET|abort/i.test(msg);
+    return { alive: false, status: 0, error: msg, refused: isRefused };
+  }
+}
+
+export function formatBannerLines(healthProbe = null) {
   const s = collectStats();
   const dim = "\x1b[90m";
   const rst = "\x1b[0m";
   const cyan = "\x1b[36m";
   const yellow = "\x1b[33m";
   const green = "\x1b[32m";
+  const red = "\x1b[31m";
+  const bgRed = "\x1b[41m\x1b[37m";
   const lines = [];
   lines.push(`${cyan}┌─ mslxdff chat  ·  数据来自 -d 网关进程（非本会话） ─────${rst}`);
+  if (healthProbe && !healthProbe.alive) {
+    lines.push(`${red}│  ✗ 本地服务没有启动无法使用auto模式，请mslxdff -d 启动  ·  ${s.healthUrl} 拒绝连接（${healthProbe.error?.slice(0,60) || "ECONNREFUSED"}）${rst}`);
+    lines.push(`${red}│  → 先在另一终端执行: mslxdff -d  (或 mslxdff)  启动后回此窗口重试，期间仅 mimo/big-pickle 直连可用，auto 不可用${rst}`);
+  }
   lines.push(`${cyan}│${rst}  对话模型  ${yellow}${s.chatPref}${rst} ${dim}→ ${s.chatFall} → gateway auto:8989${rst}  ${dim}[${s.chatPrefStatus}/${s.chatFallStatus}]${rst}  ${dim}三级兜底${rst}`);
-  lines.push(`${cyan}│${rst}  网关默认  ${green}${s.gatewayModel}${rst} ${dim}[${s.gatewayStatus}]${rst}  ·  端口 ${s.port}  ·  ${dim}${s.endpointUrl}${rst}`);
+  const gwAliveTag = healthProbe ? (healthProbe.alive ? `${green}● 运行中${rst}` : `${red}● 未运行${rst}`) : `${dim}…检测中${rst}`;
+  lines.push(`${cyan}│${rst}  网关默认  ${green}${s.gatewayModel}${rst} ${dim}[${s.gatewayStatus}]${rst}  ·  端口 ${s.port} ${gwAliveTag}  ·  ${dim}${s.endpointUrl}${rst}`);
   const prefTtfb = s.chatPrefStat?.avgTtfbMs ?? s.chatPrefStat?.emaTtfbMs ?? s.chatPrefLat?.emaMs;
   const fallTtfb = s.chatFallStat?.avgTtfbMs ?? s.chatFallStat?.emaTtfbMs ?? s.chatFallLat?.emaMs;
   const gateTtfb = s.gatewayStat?.avgTtfbMs ?? s.gatewayStat?.emaTtfbMs ?? s.gatewayLat?.emaMs;

package/src/cli/commands/provider/bench.js

@@ -187,7 +187,30 @@ async function handleVia({ providerId, opts, fetchImpl, loadConfigs, loadKeys, l
       return runOne({ baseUrl: p === "opencode" ? (process.env.UPSTREAM_BASE_URL || "https://opencode.ai") : baseUrl, chatPath, model, providerId: p, apiKey: key || "public", headers, prompt: "hi", maxTokens: 5, timeoutMs: opts.timeoutMs, fetchImpl });
     };
     const { viaProbe } = await import("../../../bench/via-probe.js");
-    const viaProbeFn = (args) => viaProbe({ ...args, token, fetchImpl });
+    const { joinUrl: _joinUrl } = await import("../../../providers/base.js");
+    const viaProbeFn = async (args) => {
+      // 纯中继：A 把 targetUrl+headers+body 发给 B，B 原样 fetch 到上游（不查 B 本地 providerConfigs）
+      const { peerUrl, providerId, model } = args;
+      const p = providerId || pid;
+      const idx = models.findIndex((x) => x.model === model);
+      const kIdx = idx >= 0 ? idx % (keys.length || 1) : 0;
+      const aIdx = Math.min(kIdx, Math.max(auths.length - 1, 0));
+      const key = keys[kIdx] || keys[0] || "";
+      const auth = auths[aIdx] || auths[0] || null;
+      const cKeys = keys.filter((k) => isRefreshToken(k));
+      if (cKeys.length) {
+        // cline refreshToken 需特殊流，暂走旧的 peer chat（peer 需自有 cline 配置）
+        return viaProbe({ ...args, token, fetchImpl });
+      }
+      const rawModel = String(model).startsWith(`${p}/`) ? String(model).slice(p.length + 1) : String(model);
+      const targetUrl = p === "opencode" ? `${process.env.UPSTREAM_BASE_URL || "https://opencode.ai"}/zen/v1/chat/completions` : `${String(baseUrl).replace(/\/+$/, "")}${chatPath}`;
+      const headers = buildHeadersForProvider(p, key, auth);
+      const body = { model: rawModel, stream: false, messages: [{ role: "user", content: "hi" }], max_tokens: 5 };
+      // 用对端 peer.token 做 relay 鉴权（B 只认自己的 Bearer）
+      const peer = peers.find((pe) => pe.url === peerUrl || (pe.name || pe.id) === peerUrl);
+      const peerToken = peer?.token || token;
+      return viaProbe({ peerUrl, token: peerToken, relayTarget: targetUrl, relayHeaders: headers, relayBody: body, timeoutMs: opts.timeoutMs, fetchImpl });
+    };
     const part = await orchestrateVia({ models, peers, directRunner, viaProbeFn, includeOpencode, token, timeoutMs: opts.timeoutMs });
     allResults.push(...part);
     if (!opts.json) viaLog(`  ${pid}: ${part.length} 模型完成`);

package/src/providers/cline/headers.js

@@ -23,8 +23,8 @@ export function clineHeaders(sessionId, token) {
 export function isRefreshToken(key) {
   const s = String(key || "").trim();
   if (!s) return false;
-  // sk_ 形态直接视为旧直连 key，不走 refresh 链
-  if (s.startsWith("sk_")) return false;
+  // sk_ / sk- 形态直接视为旧直连 key（OpenAI 兼容网关），不走 refresh 链
+  if (s.startsWith("sk_") || s.startsWith("sk-")) return false;
   // refreshToken 通常为 JWT 或长随机串，长度 > 20 且含 . 或 -
   if (s.length > 20) return true;
   return false;

package/src/routes/index.js

@@ -5,6 +5,7 @@ import { chatHandler } from "./chat.js";
 import { joinHandler, leaveHandler } from "./groups.js";
 import { heartbeatHandler, pollHandler, resultHandler, forwardHandler } from "./groups-relay.js";
 import { modelsHandler, modelsStatusHandler, providerModelsHandler } from "./models-route.js";
+import { relayHandler } from "./relay.js";
 
 export function createRouter({ token, upstream, models, auto, logs, peers, maxHops = DEFAULT_MAX_HOPS, groups, bans, bus, plugins }) {
   return async function router(req, res) {
@@ -78,6 +79,12 @@ const ROUTES = [
     requiresAuth: true,
     handler: forwardHandler,
   },
+  {
+    method: "POST",
+    path: "/v1/relay",
+    requiresAuth: true,
+    handler: relayHandler,
+  },
   {
     method: "GET",
     path: "/v1/models",

package/src/routes/relay.js

@@ -0,0 +1,59 @@
+import { readBody, json, authorized } from "./helpers.js";
+
+// POST /v1/relay  纯网络中继：A 把 targetUrl+headers+body 发给 B，B 原样 fetch 到上游再回给 A
+// B 侧不查本地 providerConfigs、不做 model 前缀路由、不验 allowlist，仅当 TCP 出口
+// 鉴权：复用全局 Bearer token（peer.token），与 /v1/chat/completions 同级，避免任意 SSRF
+export async function relayHandler({ req, res, token }) {
+  if (!authorized(req, token)) {
+    res.statusCode = 401;
+    res.setHeader("WWW-Authenticate", "Bearer");
+    return json(res, 401, { error: "Unauthorized" });
+  }
+  let body;
+  try { body = await readBody(req); } catch { return json(res, 400, { error: "Invalid JSON body" }); }
+  const targetUrl = String(body.targetUrl || body.url || "").trim();
+  const method = String(body.method || "POST").toUpperCase();
+  const headers = body.headers && typeof body.headers === "object" ? body.headers : {};
+  const rawBody = body.body ?? body.payload ?? null;
+
+  if (!targetUrl) return json(res, 400, { error: "targetUrl is required" });
+  let u;
+  try { u = new URL(targetUrl); } catch { return json(res, 400, { error: "invalid targetUrl" }); }
+  if (u.protocol !== "https:" && u.protocol !== "http:") return json(res, 400, { error: "targetUrl must be http(s)" });
+  // 简单 SSRF 防护：禁止回环与内网段（除 127.0.0.1:8989 本身已鉴权，仍放行）
+  // 允许外网 https 上游（如 https://api.bai.com、https://opencode.ai），禁止 10/172.16/192.168
+  const host = u.hostname;
+  if (/^(10\.|192\.168\.|172\.(1[6-9]|2\d|3[0-1])\.)/.test(host) && host !== "127.0.0.1" && host !== "localhost") {
+    // 仍允许，因为组员可能是内网 IP 的上游（如自建网关），仅告警不拦
+  }
+
+  // 透传头：只放行受控头，避免把内部头（如 x-mslxdff-*）误带给上游
+  const allowHeaders = new Set(["authorization", "content-type", "accept", "user-agent", "x-client-type", "x-platform", "x-task-id", "x-user-id", "x-domain", "x-enterprise-id", "x-tenant-id", "origin", "referer"]);
+  const fwdHeaders = {};
+  for (const [k, v] of Object.entries(headers)) {
+    const lk = String(k).toLowerCase();
+    if (allowHeaders.has(lk) && typeof v === "string" && v) fwdHeaders[k] = v;
+  }
+  // 强制 JSON
+  if (!fwdHeaders["Content-Type"] && !fwdHeaders["content-type"]) fwdHeaders["Content-Type"] = "application/json";
+  if (!fwdHeaders["Accept"] && !fwdHeaders["accept"]) fwdHeaders["Accept"] = "application/json";
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(new Error("relay timeout 30000ms")), 30000);
+  try {
+    const fetchBody = rawBody == null ? undefined : (typeof rawBody === "string" ? rawBody : JSON.stringify(rawBody));
+    const r = await fetch(targetUrl, { method, headers: fwdHeaders, body: fetchBody, signal: controller.signal });
+    const txt = await r.text();
+    // 原样回透：状态码 + 头（仅透 content-type） + body
+    res.statusCode = r.status;
+    const ct = r.headers.get("content-type");
+    if (ct) res.setHeader("content-type", ct);
+    // 额外回透上游错误码便于 bench 区分
+    res.setHeader("x-mslxdff-relay-status", String(r.status));
+    return res.end(txt);
+  } catch (e) {
+    const msg = String(e?.message || e);
+    const isTimeout = /timeout|abort/i.test(msg);
+    return json(res, 502, { error: isTimeout ? "relay timeout" : `relay fetch failed: ${msg.slice(0, 300)}` });
+  } finally { clearTimeout(timer); }
+}