mslxdff 0.1.88 → 0.1.90

package/src/chat-pipeline/auto-race.js

@@ -0,0 +1,124 @@
+import { performance } from "node:perf_hooks";
+import { injectReasoningContent } from "../reasoning.js";
+import { runHook } from "../plugins.js";
+import { errMsg } from "../routes/helpers.js";
+import { handleLocalRelay } from "../routes/chat/local-handler.js";
+import { handleExhaustedAll } from "../routes/chat/exhausted-handler.js";
+
+/**
+ * auto 首次并发择优 — 从 engine.js 抽出的第一段。
+ * 无 prior-success 且多非冷却候选时并发竞速，胜者走 local relay。
+ * 返回 { done:true } 表示已终结（handled/exhausted），调用方直接 return；
+ * 返回 { done:false, order } 表示未终结，调用方用过滤后的 order 继续。
+ */
+export async function runAutoRace(ctx, deps = {}) {
+  const { localRelay = handleLocalRelay, exhaustedAll = handleExhaustedAll } = deps;
+  const {
+    reqId, requested, body, hops, useAuto, lockModel, plugins,
+    auto, upstream, perf0, stages, mark, evt, logCall, logError,
+    startedAt, handlerCtx, res,
+  } = ctx;
+  let order = ctx.order;
+  const shareKeys = ctx.shareKeys ?? ctx.policy?.shareKeys ?? {};
+  const workbuddyUid = ctx.workbuddyUid ?? ctx.policy?.workbuddyUid ?? null;
+
+  if (!(useAuto && order.length > 1 && auto && !lockModel)) return { done: false, order };
+  const statuses = auto.statuses?.() ?? {};
+  const hasPriorSuccess = Object.values(statuses).some((e) => e && typeof e === "object" && e.status === "normal");
+  const nonCoolingOrder = order.filter((m) => { try { return !auto.isCooling(m); } catch { return true; } });
+  if (hasPriorSuccess || nonCoolingOrder.length <= 1) return { done: false, order };
+
+  const concLimit = (() => {
+    const v = Number(process.env.MSLXDFF_AUTO_CONCURRENT);
+    if (Number.isInteger(v) && v > 0) return Math.min(v, nonCoolingOrder.length);
+    return Math.min(nonCoolingOrder.length, 5);
+  })();
+  let raceModels = nonCoolingOrder.slice(0, concLimit);
+  if (plugins?.length) {
+    const k = [];
+    for (const m of raceModels) {
+      const b = await runHook(plugins, "model:beforeTry", { reqId, requested, model: m, hops });
+      if (b.value === false || b.value?.skip) continue;
+      k.push(m);
+    }
+    raceModels = k;
+  }
+  if (!raceModels.length) {
+    order = order.filter((m) => !new Set(nonCoolingOrder.slice(0, concLimit)).has(m));
+    if (!order.length) {
+      await exhaustedAll({ res, body, lastErr: { model: requested, status: 502, message: "all concurrent candidates skipped by plugin" }, order: nonCoolingOrder.slice(0, concLimit), requested, handlerCtx: { ...handlerCtx, reqId, startedAt }, evt, logCall, mark, perf0, stages });
+      return { done: true };
+    }
+    return { done: false, order };
+  }
+
+  evt("auto-concurrent-race", { reqId, models: raceModels, skippedFaulty: order.length - nonCoolingOrder.length, limit: concLimit });
+  const raceStart = performance.now();
+  const attempts = raceModels.map(async (m) => {
+    let f = { ...injectReasoningContent(m, body), model: m };
+    if (plugins?.length) {
+      const u = await runHook(plugins, "upstream:request", { reqId, requested, model: m, payload: f, stream: Boolean(body.stream) });
+      if (u.changed && u.value?.payload) f = u.value.payload;
+    }
+    let r = null;
+    try {
+      const o = {};
+      if (Object.keys(shareKeys).length) o.shareKeys = shareKeys;
+      if (workbuddyUid) o.workbuddyUid = workbuddyUid;
+      r = await upstream.chat(f, Object.keys(o).length ? o : undefined);
+    } catch (e) {
+      if (plugins?.length) runHook(plugins, "upstream:response", { reqId, requested, model: m, status: null, ok: false, error: errMsg(e), timing: e?._t ?? null }).catch(() => {});
+      return { model: m, ok: false, error: errMsg(e), status: 502, timing: e?._t ?? null };
+    }
+    if (plugins?.length) runHook(plugins, "upstream:response", { reqId, requested, model: m, status: r instanceof Error ? null : r?.status ?? null, ok: !(r instanceof Error) && r ? r.status < 400 : false, error: r instanceof Error ? errMsg(r) : null, timing: r?._t ?? null }).catch(() => {});
+    if (r && r.status >= 400) {
+      const a = r.status === 403 && r.headers?.get?.("x-mslxdff-allowlist") === "1";
+      if (a) return { model: m, ok: false, error: "allowlist", status: 403, allowlist: true };
+      return { model: m, ok: false, error: `upstream ${r.status}`, status: r.status, res: r, timing: r._t ?? null };
+    }
+    if (r instanceof Error) return { model: m, ok: false, error: errMsg(r), status: 502 };
+    return { model: m, ok: true, res: r, status: r.status, timing: r._t ?? null };
+  });
+  const results = await Promise.allSettled(attempts);
+  const okList = results.map((r, i) => ({ r, i, model: raceModels[i] }))
+    .filter(({ r }) => r.status === "fulfilled" && r.value?.ok)
+    .map(({ r, i, model }) => ({ model, idx: i, val: r.value, t: r.value.timing?.totalMs ?? r.value.timing?.ms ?? Number.MAX_SAFE_INTEGER }));
+  if (okList.length) {
+    okList.sort((a, b) => a.t - b.t);
+    const best = okList[0];
+    const winModel = best.model;
+    evt("auto-concurrent-win", { reqId, model: winModel, timing: best.val.timing, totalMs: Math.round(performance.now() - raceStart), tried: raceModels.length });
+    for (const { r, i } of results.map((r, i) => ({ r, i }))) {
+      const m = raceModels[i];
+      if (r.status === "fulfilled" && r.value?.ok) {
+        if (m === winModel) {
+          const latencyMs = r.value.timing?.totalMs ?? Math.round(performance.now() - raceStart);
+          await auto.recordOk(m, { latencyMs });
+          try { const { savePreferredModel } = await import("../state.js"); savePreferredModel(m); evt("auto-concurrent-preferred", { reqId, model: m }); } catch {}
+        }
+      } else if (r.status === "fulfilled" && !r.value?.ok && !r.value?.allowlist) await auto.recordError(m, { status: r.value.status || 502 });
+      else if (r.status === "rejected") await auto.recordError(m, { status: 502 });
+    }
+    handlerCtx.model = winModel;
+    const lr = await localRelay({ upRes: best.val.res, model: winModel, body, order: raceModels, idx: best.idx, lastErr: null, requested, useAuto, lockModel, auto, handlerCtx, evt, logCall, logError, mark, perf0, stages, startedAt, plugins, res });
+    if (lr.handled) return { done: true };
+    if (!lr.lastErr) return { done: true };
+  } else {
+    evt("auto-concurrent-all-fail", { reqId, tried: raceModels.length, totalMs: Math.round(performance.now() - raceStart) });
+    for (const { r, i } of results.map((r, i) => ({ r, i }))) {
+      const m = raceModels[i];
+      if (r.status === "fulfilled" && !r.value?.ok && !r.value?.allowlist) await auto.recordError(m, { status: r.value.status || 502 });
+      else if (r.status === "rejected") await auto.recordError(m, { status: 502 });
+    }
+  }
+  const triedSet = new Set(raceModels);
+  order = order.filter((m) => !triedSet.has(m));
+  if (!order.length) {
+    const failedStatuses = results.map((r) => (r.status === "fulfilled" ? r.value?.status : null)).filter((s) => Number.isInteger(s));
+    const lastStatus = failedStatuses[failedStatuses.length - 1] || failedStatuses[0] || 502;
+    const last = { model: raceModels[0] || requested, status: lastStatus, message: "all concurrent candidates failed" };
+    await exhaustedAll({ res, body, lastErr: last, order: raceModels, requested, handlerCtx: { ...handlerCtx, reqId, startedAt }, evt, logCall, mark, perf0, stages });
+    return { done: true };
+  }
+  return { done: false, order };
+}

package/src/chat-pipeline/engine.js

@@ -0,0 +1,17 @@
+import { runAutoRace } from "./auto-race.js";
+import { runSerialTrial } from "./serial-trial.js";
+
+/**
+ * ExecutionEngine（薄编排）— auto 并发择优 → 串行 trial。
+ * 重活下沉 auto-race.js / serial-trial.js，本文件仅做顺序编排。
+ */
+export function createEngine(deps = {}) {
+  const { raceDeps, serialDeps } = deps;
+  async function run(_plan, state) {
+    const race = await runAutoRace(state, raceDeps);
+    if (race.done) return;
+    await runSerialTrial({ ...state, order: race.order }, serialDeps);
+  }
+
+  return { run };
+}

package/src/chat-pipeline/index.js

@@ -0,0 +1,86 @@
+import { performance } from "node:perf_hooks";
+import { analyzePolicy } from "./policy.js";
+import { planRoute } from "./planner.js";
+import { createEngine } from "./engine.js";
+import { runHook } from "../plugins.js";
+import { clientIp, summarizePrompt } from "../routes/helpers.js";
+
+/**
+ * ChatPipeline 深模块门面 — 对外 execute(req) 单一 inlet
+ * 内部组合 Policy→Planner→Engine：解析 header/model → 产 order → 委托 engine 执行
+ * gateway 仅薄适配：readBody + request:received hook + 调 execute
+ */
+export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, token, plugins, maxHops } = {}) {
+  const engine = createEngine();
+
+  async function execute({ req, res } = {}) {
+    const startedAt = Date.now();
+    const reqId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+    const perf0 = performance.now();
+    const stages = [];
+    const mark = (name) => stages.push([name, Math.round(performance.now() - perf0)]);
+
+    const policy = analyzePolicy({ headers: req?.headers || {}, body: req?.body || {} });
+    const { requested, useAuto, lockModel, hops, shareKeys, workbuddyUid, aliasInfo } = policy;
+    mark("parsed");
+    if (aliasInfo) { try { res?.setHeader?.("x-mslxdff-alias", aliasInfo); } catch {} }
+    // mslxdff/ 前缀或 alias 命中时，把 body.model 改写为还原后的模型（与原 gateway 语义一致）
+    if (aliasInfo && req?.body && req.body.model !== requested) {
+      req.body = { ...req.body, model: requested };
+    }
+
+    // order 推导 + plugin model:select 可改
+    let order;
+    if (lockModel) order = [requested];
+    else if (useAuto) order = auto ? await auto.candidates() : [""];
+    else order = auto ? await auto.candidatesFor(requested) : [requested];
+    if (!order.length) order = [""];
+    const canFallback = order.length > 1;
+    const canForwardPeers = Boolean(peers) && hops < (maxHops ?? 3);
+    mark("ordered");
+
+    const logCall = (model, status) => logs?.appendCall({ reqId, model, auto: useAuto, status, durationMs: Date.now() - startedAt, stream: Boolean(req?.body?.stream), stages });
+    const logError = (model, status, message) => logs?.appendError({ reqId, model, auto: useAuto, status, message, stages });
+    const evt = (type, data) => {
+      const entry = { ts: Date.now(), reqId, type, ...data, model: data.model ?? requested, auto: useAuto, durationMs: Date.now() - startedAt, stages: [...stages] };
+      if (bus) bus.emit(entry);
+      logs?.appendEvent?.(entry);
+    };
+    const done = (info) => {
+      if (!plugins?.length) return;
+      runHook(plugins, "request:completed", { reqId, requested, useAuto, hops, stream: Boolean(req?.body?.stream), durationMs: Date.now() - startedAt, ...info }).catch(() => {});
+    };
+
+    evt("request", { reqId, hops, ip: clientIp(req), stream: Boolean(req?.body?.stream), prompt: summarizePrompt(req?.body), rawModel: policy.rawModel, requested, lockModel: lockModel || null });
+    if (aliasInfo) evt("alias", { reqId, alias: aliasInfo, rawModel: policy.rawModel, requested });
+    if (Object.keys(shareKeys).length) evt("share-keys", { reqId, providers: Object.keys(shareKeys) });
+    evt("ordered", { reqId, order, canFallback, canForwardPeers, useAuto, statuses: auto?.statuses?.() ?? null });
+
+    if (plugins?.length && !lockModel) {
+      const sel = await runHook(plugins, "model:select", { reqId, requested, useAuto, order: [...order], hops, stream: Boolean(req?.body?.stream) });
+      if (sel.changed && Array.isArray(sel.value) && sel.value.length) {
+        order = sel.value.filter(Boolean);
+        if (!order.length) order = [requested];
+        evt("plugin-hook", { reqId, hook: "model:select", applied: true, order: [...order] });
+      }
+      for (const e of sel.errors) evt("plugin-hook-error", { reqId, hook: "model:select", plugin: e.plugin, error: e.error });
+    }
+
+    const handlerCtx = { reqId, model: null, body: req?.body, hops, peers, plugins, evt, logError, logCall, logs, workbuddyUid };
+
+    const plan = planRoute(policy, {
+      candidates: order,
+      viaRoute: Boolean(!useAuto && requested.includes("/") && canForwardPeers) ? { via: true } : null,
+    });
+    await engine.run(plan, {
+      reqId, startedAt, req, res, body: req?.body, policy,
+      useAuto, lockModel, requested, hops,
+      canFallback, canForwardPeers,
+      perf0, stages, mark, evt, logCall, logError, done, handlerCtx,
+      auto, upstream, peers, groups, bus, token, plugins, logs,
+      order,
+    });
+  }
+
+  return { execute, _policy: analyzePolicy, _plan: planRoute, _engine: engine };
+}

package/src/chat-pipeline/planner.js

@@ -0,0 +1,31 @@
+import { DEFAULT_AUTO_MODELS, rankModels } from "../auto.js";
+
+/**
+ * RoutePlanner 纯决策 — 根据 Policy + auto 状态产 RoutePlan
+ * 无网络副作用，供单测注入 FakeAuto
+ */
+export function planRoute(policy, autoState = {}) {
+  const { requested, useAuto, lockModel } = policy;
+  const { candidates = [], errors = {}, latencies = {}, viaRoute = null } = autoState;
+
+  // 锁模型时直接单点
+  if (lockModel) {
+    return { strategy: "direct", order: [requested], concLimit: 1, hedgeDelayMs: 0 };
+  }
+  // ViaRoute 单路径（显式锁模型且 via 表命中）
+  if (viaRoute && !useAuto && requested.includes("/")) {
+    return { strategy: "via", order: [requested], via: viaRoute, concLimit: 1, hedgeDelayMs: 0 };
+  }
+  // Auto 并发择优
+  if (useAuto && candidates.length > 1) {
+    const concLimit = Math.min(candidates.length, 5);
+    return { strategy: "autoRace", order: candidates, concLimit, hedgeDelayMs: 1000 };
+  }
+  // 显式模型回退链
+  if (!useAuto && candidates.length) {
+    const others = candidates.filter((m) => m !== requested);
+    const order = requested ? [requested, ...others] : candidates;
+    return { strategy: "direct", order, concLimit: 1, hedgeDelayMs: 0 };
+  }
+  return { strategy: "direct", order: requested ? [requested] : [""], concLimit: 1, hedgeDelayMs: 0 };
+}

package/src/chat-pipeline/policy.js

@@ -0,0 +1,73 @@
+import { normalizeModel } from "../reasoning.js";
+import { isAutoModel } from "../auto.js";
+import { parseHops } from "../routes/helpers.js";
+import { parseShareKeysHeader, SHARE_KEYS_HEADER } from "../providers/share-keys.js";
+import { normalizeFullId, getModelAlias } from "../providers/model-id.js";
+
+/**
+ * PolicyStage 纯函数 — 解析 model 别名 / 白名单前置 / header 透传
+ * 零网络副作用，输入 headers+body，输出 PolicyResult
+ */
+export function analyzePolicy({ headers = {}, body = {} } = {}) {
+  const hops = parseHops(headers["x-mslxdff-hops"] || headers["X-Mslxdff-Hops"] || "");
+  const shareKeys = parseShareKeysHeader(headers[SHARE_KEYS_HEADER] || headers["x-mslxdff-share-keys"] || "");
+  const workbuddyUid = (headers["x-mslxdff-workbuddy-uid"] || headers["x-workbuddy-uid"] || "").toString().trim();
+  const lockModel = (headers["x-mslxdff-model-lock"] || headers["X-Mslxdff-Model-Lock"] || "").toString();
+  const rawModel = body.model || "";
+
+  let normalizedRequested = normalizeModel(lockModel || rawModel || "");
+  const aliasResolved = getModelAlias(normalizedRequested);
+  if (aliasResolved) {
+    normalizedRequested = aliasResolved;
+  }
+  let requested = normalizedRequested;
+  let aliasInfo = null;
+
+  if (requested.startsWith("mslxdff/")) {
+    const rawPart = requested.slice("mslxdff/".length);
+    aliasInfo = `${requested} -> ${rawPart} (mslxdff provider stripped)`;
+    requested = rawPart;
+    const alias2 = getModelAlias(requested);
+    if (alias2) {
+      aliasInfo = `${rawModel} -> ${alias2} (mslxdff + alias)`;
+      requested = alias2;
+    }
+  } else if (aliasResolved) {
+    // 非 mslxdff 的 dash 形态已在首轮 aliasResolved 处理
+    aliasInfo = aliasResolved !== (lockModel || rawModel) ? `${rawModel} -> ${aliasResolved} (alias)` : null;
+    if (!aliasInfo) aliasInfo = null;
+  }
+
+  // workbuddy <uid>:model 形式的 uid 钉死在 normalizeFullId 侧处理，这里透传原始 requested 供 planner 二次剥离
+  // 若 requested 含 workbuddy/ 前缀且含 :，则尝试提取 uid
+  let extractedUid = workbuddyUid;
+  if (!extractedUid && requested.startsWith("workbuddy/") && requested.includes(":")) {
+    const after = requested.slice("workbuddy/".length);
+    const uidPart = after.split(":")[0];
+    if (uidPart) extractedUid = uidPart;
+  }
+
+  const useAuto = isAutoModel(requested);
+
+  // 对 workbuddy 前缀的 model，做 normalizeFullId 归一（剥 uid 供上游）
+  // 但保留 requested 为完整带前缀形态，供 planner 做 ViaRoute 判定
+  let normalizedForUpstream = requested;
+  try {
+    const norm = normalizeFullId(requested);
+    if (norm && norm.raw) normalizedForUpstream = norm.raw ? `${norm.provider ? norm.provider + "/" : ""}${norm.raw}` : requested;
+  } catch {}
+
+  return {
+    rawModel,
+    requested,
+    normalizedRequested,
+    normalizedForUpstream,
+    aliasInfo,
+    useAuto,
+    shareKeys,
+    workbuddyUid: extractedUid,
+    lockModel,
+    hops,
+    bodyModel: body.model || null,
+  };
+}

package/src/chat-pipeline/serial-trial.js

@@ -0,0 +1,144 @@
+import { performance } from "node:perf_hooks";
+import { injectReasoningContent } from "../reasoning.js";
+import { runHook } from "../plugins.js";
+import { errMsg, json } from "../routes/helpers.js";
+import { hedgeDelayMs, shouldHedge } from "../routes/hedge.js";
+import { handleHedge } from "../routes/chat/hedge-handler.js";
+import { handleLocalRelay } from "../routes/chat/local-handler.js";
+import { handlePeerRelay } from "../routes/chat/peer-handler.js";
+import { handleBroadbandRelay } from "../routes/chat/broadband-handler.js";
+import { handleViaRoute } from "../routes/chat/via-route-handler.js";
+import { handleExhaustedLocal, handleExhaustedAll } from "../routes/chat/exhausted-handler.js";
+
+/**
+ * 串行 trial — 从 engine.js 抽出的第二段：via-route 单路径 → 串行 trial →
+ * hedge/local/peer/broadband/exhausted。恒终结，返回 { done:true }。
+ */
+export async function runSerialTrial(ctx, deps = {}) {
+  const {
+    viaRoute = handleViaRoute,
+    hedge = handleHedge,
+    localRelay = handleLocalRelay,
+    peerRelay = handlePeerRelay,
+    broadbandRelay = handleBroadbandRelay,
+    exhaustedLocal = handleExhaustedLocal,
+    exhaustedAll = handleExhaustedAll,
+  } = deps;
+  const {
+    order, reqId, requested, body, hops, useAuto, lockModel, plugins,
+    auto, upstream, peers, groups, bus, token, canFallback, canForwardPeers,
+    perf0, stages, mark, evt, logCall, logError, done, handlerCtx,
+    res, startedAt, logs,
+  } = ctx;
+  const shareKeys = ctx.shareKeys ?? ctx.policy?.shareKeys ?? {};
+  const workbuddyUid = ctx.workbuddyUid ?? ctx.policy?.workbuddyUid ?? null;
+
+  let viaRouteLastErr = null;
+  if (!useAuto && requested && requested.includes("/") && canForwardPeers && !lockModel && peers) {
+    try {
+      const vr = await viaRoute({ model: requested, body, peers, handlerCtx, evt, logCall, logError, mark, perf0, stages, startedAt, plugins, res, requested, useAuto, lockModel, auto });
+      if (vr.handled) return { done: true };
+      if (vr.lastErr) viaRouteLastErr = vr.lastErr;
+    } catch (e) {
+      evt("via-route-exception", { reqId, model: requested, error: errMsg(e) });
+    }
+  }
+
+  let lastErr = viaRouteLastErr;
+  for (let idx = 0; idx < order.length; idx++) {
+    const model = order[idx];
+    handlerCtx.model = model;
+    evt("model-try", { reqId, model, idx, remaining: order.length - idx });
+    if (plugins?.length) {
+      const bt = await runHook(plugins, "model:beforeTry", { reqId, requested, model, idx, hops });
+      for (const e of bt.errors) evt("plugin-hook-error", { reqId, hook: "model:beforeTry", plugin: e.plugin, error: e.error });
+      if (bt.value === false || bt.value?.skip === true) { evt("plugin-hook", { reqId, hook: "model:beforeTry", applied: true, skipped: model }); continue; }
+    }
+    let upRes = null;
+    let forwarded = { ...injectReasoningContent(model, body), model };
+    if (plugins?.length) {
+      const ur = await runHook(plugins, "upstream:request", { reqId, requested, model, payload: forwarded, stream: Boolean(body.stream) });
+      for (const e of ur.errors) evt("plugin-hook-error", { reqId, hook: "upstream:request", plugin: e.plugin, error: e.error });
+      if (ur.changed && ur.value?.payload && typeof ur.value.payload === "object") { forwarded = ur.value.payload; evt("plugin-hook", { reqId, hook: "upstream:request", applied: true, model, rewrittenModel: forwarded.model ?? null }); }
+    }
+    const tUp = performance.now();
+    evt("upstream-try", { reqId, model, attempt: idx + 1 });
+    try {
+      const chatOpts = {};
+      if (Object.keys(shareKeys).length) chatOpts.shareKeys = shareKeys;
+      if (workbuddyUid) chatOpts.workbuddyUid = workbuddyUid;
+      upRes = await upstream.chat(forwarded, Object.keys(chatOpts).length ? chatOpts : undefined);
+      evt("upstream-done", { reqId, model, ok: !(upRes instanceof Error) && upRes.status < 400, status: upRes instanceof Error ? null : upRes.status, timing: upRes._t ?? null, error: null });
+    } catch (err) {
+      if (auto) await auto.recordError(model, { message: errMsg(err) });
+      lastErr = { model, upstream: null, status: 502, message: errMsg(err) };
+      logError(model, 502, errMsg(err));
+      evt("upstream-error", { reqId, model, status: 502, message: errMsg(err), timing: err._t ?? { attempts: [], waitMs: 0, totalMs: Math.round(performance.now() - tUp) } });
+    }
+    if (plugins?.length) {
+      runHook(plugins, "upstream:response", {
+        reqId, requested, model,
+        status: upRes instanceof Error ? null : upRes instanceof Object ? (upRes.status ?? null) : null,
+        ok: !(upRes instanceof Error) && upRes ? upRes.status < 400 : false,
+        error: upRes instanceof Error ? errMsg(upRes) : null,
+        timing: upRes?._t ?? null,
+      }).catch(() => {});
+    }
+    mark(`up-${model}`);
+    if (upRes && upRes.status >= 400) {
+      const isAllowlistBlock = upRes.status === 403 && (upRes.headers?.get?.("x-mslxdff-allowlist") === "1");
+      if (isAllowlistBlock) {
+        let bodyText = null; try { bodyText = await upRes.clone().text(); } catch {}
+        let errBody = { error: `model not allowed for provider` };
+        try { errBody = bodyText ? JSON.parse(bodyText) : errBody; } catch { errBody = { error: bodyText || "model not allowed" }; }
+        if (useAuto) {
+          logError(model, 403, errBody.error || "model not allowed");
+          evt("upstream-error", { reqId, model, status: 403, message: errBody.error, timing: upRes._t ?? null, allowlist: true, skipped: true });
+          lastErr = { model, upstream: upRes, status: 403, message: errBody.error || "model not allowed" };
+          if (canFallback && idx < order.length - 1) { evt("fallback", { reqId, from: model, to: order[idx + 1] ?? null, reason: `allowlist skip ${errBody.error || "blocked"}` }); continue; }
+          return json(res, 403, errBody);
+        }
+        logError(model, 403, errBody.error || "model not allowed");
+        evt("upstream-error", { reqId, model, status: 403, message: errBody.error, timing: upRes._t ?? null, allowlist: true });
+        return json(res, 403, errBody);
+      }
+      if (auto) await auto.recordError(model, { status: upRes.status });
+      lastErr = { model, upstream: upRes, status: upRes.status, message: null };
+      logError(model, upRes.status, `upstream ${upRes.status}`);
+      evt("upstream-error", { reqId, model, status: upRes.status, message: null, timing: upRes._t ?? null });
+      upRes = null;
+    }
+    if (upRes) {
+      const isStream = Boolean(body.stream);
+      const d = hedgeDelayMs();
+      const hasPeers = Boolean(peers) && peers.ordered().length > 0;
+      const doHedge = shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers }) && upRes.status === 200 && upRes.body;
+      if (doHedge) {
+        const hr = await hedge({ upRes, model, body, order, idx, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, logError, mark, perf0, stages, startedAt, plugins, res, hedgeDelayMs: d });
+        if (hr.handled) return { done: true };
+        if (hr.lastErr) lastErr = hr.lastErr;
+        if (hr.upRes === null) upRes = null;
+        else if (hr.upRes) upRes = hr.upRes;
+      }
+      if (upRes) {
+        const lr = await localRelay({ upRes, model, body, order, idx, lastErr, requested, useAuto, lockModel, auto, handlerCtx, evt, logCall, logError, mark, perf0, stages, startedAt, plugins, res });
+        if (lr.handled) return { done: true };
+        if (lr.lastErr) { lastErr = lr.lastErr; continue; }
+        return { done: true };
+      }
+    }
+    if (canForwardPeers) {
+      const pr = await peerRelay({ model, body, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, mark, perf0, stages, startedAt, plugins, res });
+      if (pr.handled) return { done: true };
+    }
+    if (groups) {
+      const br = await broadbandRelay({ model, body, hops, lastErr, requested, useAuto, lockModel, auto, groups, token, bus, logs, handlerCtx, evt, mark, perf0, stages, res, startedAt, plugins });
+      if (br.handled) return { done: true };
+    }
+    if (canFallback) { evt("fallback", { reqId, from: model, to: order[idx + 1] ?? null, reason: lastErr?.message || `upstream ${lastErr?.status ?? 502}` }); continue; }
+    await exhaustedLocal({ res, body, lastErr, order, handlerCtx: { ...handlerCtx, model, reqId }, evt, logCall, mark, perf0, stages, done, requested, useAuto });
+    return { done: true };
+  }
+  await exhaustedAll({ res, body, lastErr, order, requested, handlerCtx: { ...handlerCtx, reqId, startedAt }, evt, logCall, mark, perf0, stages });
+  return { done: true };
+}

package/src/cli/commands/model/list-providers.js

@@ -0,0 +1,75 @@
+/**
+ * 其他供应商 allowlist 段 + 遗留别名映射展示。
+ * 输入均为已算好的数据；state/model-id 走动态 import（与原内联一致，避免循环依赖）。
+ */
+export async function renderOtherProviders({ pickedIds, ids, fullAliases }) {
+  const { loadProviderConfigs, loadProviderAllowedModels, loadProviderAllowAnyModels, loadProviderBaseUrl } = await import("../../../state.js");
+  const { loadModelAliases: _la2, getAliasForModel: _gaf } = await import("../../../providers/model-id.js");
+  try { _la2(); } catch {}
+  const configs = loadProviderConfigs();
+  const otherIds = Object.keys(configs).filter((k) => String(k).toLowerCase() !== "opencode");
+  const order2 = ["workbuddy", "clinebot", "openrouter", "bai"];
+  otherIds.sort((a, b) => {
+    const ia = order2.indexOf(a), ib = order2.indexOf(b);
+    if (ia !== -1 || ib !== -1) {
+      if (ia === -1) return 1;
+      if (ib === -1) return -1;
+      return ia - ib;
+    }
+    return a.localeCompare(b);
+  });
+  if (otherIds.length) {
+    console.log(`\n────────────────────────────────────────`);
+    console.log(`其他供应商 (allowlist，原名 + 别名) (${otherIds.length} providers):`);
+    for (const pid of otherIds) {
+      const allowed = loadProviderAllowedModels(pid);
+      const allowAny = loadProviderAllowAnyModels(pid);
+      const baseUrl = loadProviderBaseUrl(pid) || configs[pid]?.baseUrl || "";
+      const header = allowAny
+        ? (allowed.length ? `allowlist ${allowed.length} (allowAny ON)` : `allowAny ON (allowlist 空=放行全部)`)
+        : (allowed.length ? `allowlist ${allowed.length} (allowAny OFF)` : `allowlist 空 + allowAny OFF = 阻塞`);
+      console.log(`\n  ── ${pid} (${header})${baseUrl ? `  baseUrl=${baseUrl}` : ""} ──`);
+      if (!allowed.length) {
+        if (allowAny) {
+          console.log(`     (未设 allowlist，全部模型放行)  查看 live 列表: mslxdff -provider ${pid} models`);
+          console.log(`     限制可用模型: mslxdff -provider ${pid} allowlist set <model1> <model2>`);
+        } else {
+          console.log(`     阻塞中：无可用模型 — 设白名单: mslxdff -provider ${pid} allowlist set <model1> <model2>`);
+          console.log(`     或放行全部: mslxdff -provider ${pid} allowAny on`);
+        }
+      } else {
+        for (const raw of allowed) {
+          const canonical = `${pid}/${raw}`;
+          let alias = null;
+          try { alias = _gaf(canonical); } catch {}
+          if (!alias && String(canonical).includes("/")) alias = String(canonical).replace(/\//g, "-");
+          const aliasStr = alias && alias !== canonical ? `  (别名: ${alias})` : "";
+          const pickedMark = pickedIds.includes(canonical) || pickedIds.includes(alias || "") ? "*" : " ";
+          console.log(`     ${pickedMark} ${canonical}${aliasStr}`);
+        }
+        console.log(`     管理: mslxdff -provider ${pid} allowlist [list|add|remove|clear] | allowAny on|off`);
+      }
+    }
+  } else {
+    console.log(`\n────────────────────────────────────────`);
+    console.log(`其他供应商 (allowlist，原名 + 别名): (none — 尚未配置)`);
+    console.log(`  添加示例: mslxdff -provider add myapi https://api.example.com/v1 sk-xxx --models-path /v1/models`);
+  }
+  const aliasEntries = Object.entries(fullAliases).filter(([alias, canonical]) => {
+    if (ids.includes(canonical)) return false;
+    for (const pid of otherIds) {
+      const allowed = loadProviderAllowedModels(pid);
+      for (const raw of allowed) {
+        const can = `${pid}/${raw}`;
+        if (can === canonical) return false;
+      }
+    }
+    return true;
+  });
+  if (aliasEntries.length) {
+    console.log(`\n  本地别名 (不在 allowlist 里的遗留映射 ${aliasEntries.length}):`);
+    for (const [alias, canonical] of aliasEntries) {
+      console.log(`     ${canonical}  =>  ${alias}`);
+    }
+  }
+}

package/src/cli/commands/model/list-render.js

@@ -0,0 +1,79 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+/** 构建 id → 别名映射（原 list 两处重复逻辑收敛） */
+export function buildAliasMap(ids, getAliasForModel) {
+  const aliasMap = {};
+  for (const id of ids) {
+    const alias = getAliasForModel(id);
+    if (alias) aliasMap[id] = alias;
+    else if (String(id).includes("/")) {
+      const dashAlias = String(id).replace(/\//g, "-");
+      if (dashAlias !== id) aliasMap[id] = dashAlias;
+    }
+  }
+  return aliasMap;
+}
+
+/** 读本地别名全表（遗留映射展示用） */
+export function readFullAliases() {
+  try {
+    const aliasesFile = join(homedir(), ".config", "mslxdff", "model-aliases.json");
+    const raw = JSON.parse(readFileSync(aliasesFile, "utf8"));
+    if (raw && typeof raw === "object") return raw;
+  } catch {}
+  return {};
+}
+
+/** `--provider <id>` 分支的分组渲染 */
+export function renderProviderList({ ids, at, pickedIds, modelListProvider, sortedProvs, groups, aliasMap }) {
+  console.log(`${ids.length} model(s) for ${modelListProvider}${at} (${pickedIds.length} picked, * = picked):`);
+  const mark = (id) => (pickedIds.includes(id) ? "*" : " ");
+  for (const prov of sortedProvs) {
+    const list = groups[prov];
+    console.log(`\n  ── ${prov} (${list.length}) ──`);
+    for (const id of list) {
+      const alias = aliasMap[id];
+      const aliasStr = alias ? `  (别名: ${alias})` : "";
+      console.log(`  ${mark(id)} ${id}${aliasStr}`);
+    }
+  }
+  console.log(`\npicked only constrains auto; manage with: mslxdff -models (TTY) | mslxdff -model pick <id> | mslxdff -model unpick <id> | mslxdff -model pick clear`);
+}
+
+/** 全量 free 列表的分组渲染 */
+export function renderFreeList({ ids, at, pickedIds, sortedProvs, groups, aliasMap }) {
+  console.log(`${ids.length} free model(s)${at} (${pickedIds.length} picked, * = picked):`);
+  const mark = (id) => (pickedIds.includes(id) ? "*" : " ");
+  for (const prov of sortedProvs) {
+    const list = groups[prov];
+    console.log(`\n  ── ${prov} (${list.length}) ──`);
+    for (const id of list) {
+      const alias = aliasMap[id];
+      const aliasStr = alias ? `  (别名: ${alias})` : "";
+      console.log(`  ${mark(id)} ${id}${aliasStr}`);
+    }
+  }
+}
+
+/** 按供应商分组 + 排序（opencode/workbuddy/clinebot/openrouter 优先） */
+export function groupByProvider(ids) {
+  const groups = {};
+  for (const id of ids) {
+    const prov = String(id).includes("/") ? String(id).split("/")[0] : "opencode";
+    if (!groups[prov]) groups[prov] = [];
+    groups[prov].push(id);
+  }
+  const order = ["opencode", "workbuddy", "clinebot", "openrouter"];
+  const sortedProvs = Object.keys(groups).sort((a, b) => {
+    const ia = order.indexOf(a), ib = order.indexOf(b);
+    if (ia !== -1 || ib !== -1) {
+      if (ia === -1) return 1;
+      if (ib === -1) return -1;
+      return ia - ib;
+    }
+    return a.localeCompare(b);
+  });
+  return { groups, sortedProvs };
+}