mslxdff 0.1.104 → 0.1.106

package/package.json

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

package/src/auto.js

@@ -29,10 +29,10 @@ export const DEFAULT_AUTO_MODELS = [
   PREFERRED_MODEL,
   "mimo-v2.5-free",
   "deepseek-v4-flash-free",
-  "ling-3.0-flash-free",
+  "ling-3.0-flash-fin-free",
   "nemotron-3-ultra-free",
-  "north-mini-code-free",
-  "laguna-s-2.1-free",
+  "nemotron-3.5-lightning-free",
+  "muse-spark-1.3-contributor-free",
 ].filter((id, i, arr) => id && arr.indexOf(id) === i);
 
 export function isAutoModel(model) {

package/src/chat/engine.js

@@ -43,7 +43,7 @@ export function createEngine({
     return next;
   }
 
-  async function runTurn(userText, messages) {
+  async function runTurn(userText, messages, modelOverride) {
     const tools = GTOOLS();
     messages.push({ role: "user", content: userText });
     let loops = 0;
@@ -70,7 +70,7 @@ export function createEngine({
       const tCall = performance.now();
       let res;
       const activeTools = forceNoTools ? [] : tools;
-      res = await CWF({ messages, tools: activeTools });
+      res = await CWF({ messages, tools: activeTools, model: modelOverride || undefined });
       if (forceNoTools && res.ok && res.message?.tool_calls?.length) {
         onTrace(`[guard] 禁工具模式下仍收到 tool_calls，已拦截`);
         res.message.tool_calls = [];

package/src/chat/gateway.js

@@ -41,7 +41,7 @@ export function createGatewayClient({
     return { data: [] };
   });
 
-  async function chatViaGateway({ messages, tools }) {
+  async function chatViaGateway({ messages, tools, autoProvider = "opencode" }) {
     const TRACE = env.MSLXDFF_CHAT_TRACE !== "0";
     const t0 = TRACE ? performance.now() : 0;
     let port = defaultPort;
@@ -72,7 +72,11 @@ export function createGatewayClient({
       const timer = setTimeout(() => controller.abort(), gatewayTimeoutMs);
       const res = await _fetch(url, {
         method: "POST",
-        headers: { "Content-Type": "application/json", ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+        headers: {
+          "Content-Type": "application/json",
+          ...(autoProvider ? { "x-mslxdff-auto-provider": autoProvider } : {}),
+          ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        },
         body: JSON.stringify(body),
         signal: controller.signal,
       });

package/src/chat/orchestrator.js

@@ -53,6 +53,13 @@ export function createOrchestrator({
 
   async function chatWithFallback(opts) {
     if (chatWithFallbackImpl) return chatWithFallbackImpl(opts);
+    // 严格模式：显式指定了具体模型（非 auto/空）→ 只用该模型，失败即报错，绝不降级到其他模型
+    const pinned = String(opts?.model || "").trim();
+    if (pinned && pinned.toLowerCase() !== "auto") {
+      const r = await safeChatOnce(opts, pinned);
+      if (r.ok) return { ...r, model: pinned };
+      return { ok: false, error: `指定模型 ${pinned} 失败：${r.error}（已锁定不自动换模型；如需自动择优请输入 /model auto）`, status: r.status || 502, pinnedModel: pinned };
+    }
     const TRACE = env.MSLXDFF_CHAT_TRACE !== "0";
     const HEDGE_MS = (() => {
       const v = Number(env.MSLXDFF_HEDGE_DELAY_MS);

package/src/chat/prompt.js

@@ -22,8 +22,8 @@ function readModels() {
       if (ids.length) return ids;
     }
   } catch {}
-  // 兜底：硬编码常见 free 模型，供离线时参考
-  return ["mimo-v2.5-free", "big-pickle", "deepseek-v4-flash-free", "hy3-free", "laguna-free", "kimi-k2-free", "nemotron-3-nano-free", "big-pickle"];
+  // 兜底：硬编码常见 free 模型，供离线时参考（2026-09 实测 /zen/v1/models free 池）
+  return ["big-pickle", "mimo-v2.5-free", "ling-3.0-flash-fin-free", "deepseek-v4-flash-free", "nemotron-3.5-lightning-free", "nemotron-3-ultra-free", "muse-spark-1.3-contributor-free", "muse-spark-1.2-contributor-free"];
 }
 
 export function buildSystemPrompt({ modelsOverride } = {}) {

package/src/chat/repl.js

@@ -31,6 +31,12 @@ export async function startRepl({ singleShot } = {}) {
     curlTool,
     onTrace: trace,
   });
+  let pinnedModel = null; // /model 锁定的模型：严格单模型，不通即报错（null=默认链）
+
+  function applyPrompt() {
+    const label = pinnedModel || CHAT_PREFERRED.split("-")[0];
+    rl.setPrompt(`\x1b[36m${label}>\x1b[0m `);
+  }
 
   if (singleShot) {
     const text = String(singleShot).trim();
@@ -47,22 +53,24 @@ export async function startRepl({ singleShot } = {}) {
 
   await printBanner();
   const rl = createReadline(`\x1b[36m${CHAT_PREFERRED.split("-")[0]}>\x1b[0m `);
+  applyPrompt();
   rl.prompt();
   for await (const line of rl) {
     const raw = String(line || "").trim();
     if (!raw) { rl.prompt(); continue; }
-    const slash = handleSlash(raw, { messages, system });
+    const slash = handleSlash(raw, { messages, system, pinnedModel });
     if (slash.handled) {
       if (slash.exit) { console.log("再见"); saveHistory(messages.slice(1)); rl.close(); return; }
       if (slash.messages) messages = slash.messages;
+      if ("pinnedModel" in slash) { pinnedModel = slash.pinnedModel; applyPrompt(); }
       rl.prompt();
       continue;
     }
     try {
-      const spinner = createSpinner("已发送给 AI，等待回复中");
+      const spinner = createSpinner(pinnedModel ? `已发送给 ${pinnedModel}，等待回复中` : "已发送给 AI，等待回复中");
       spinner.start();
       let r;
-      try { r = await engine.runTurn(raw, messages); }
+      try { r = await engine.runTurn(raw, messages, pinnedModel); }
       finally { spinner.stop(`\x1b[90m✓ AI 已回复\x1b[0m`); }
       if (r.text && !r.text.startsWith("OK") && !r.text.startsWith("FAIL")) console.log(r.text);
       if (r.model || r.latency) printFooter(r);

package/src/chat/terminal.js

@@ -3,10 +3,25 @@ import { stdin, stdout } from "node:process";
 import { formatBannerLines, formatStatsDetail, collectStats, probeGateway } from "./stats.js";
 import { createSpinner } from "./spinner.js";
 import { normalizeFullId } from "../providers/model-id.js";
+import { isFreeModel } from "../models.js";
+import { getModelsForPrompt } from "./prompt.js";
 import { loadHistory, saveHistory, clearHistory, histPath, estimateChars } from "./store.js";
 
+// -chat 只用 opencode 上游的免费模型：裸 id（无供应商前缀）+ free 池
+const FALLBACK_FREE_POOL = ["big-pickle", "mimo-v2.5-free", "ling-3.0-flash-fin-free", "deepseek-v4-flash-free", "nemotron-3.5-lightning-free", "nemotron-3-ultra-free", "muse-spark-1.3-contributor-free", "muse-spark-1.2-contributor-free"];
+
+function freePoolNow() {
+  try {
+    const ids = getModelsForPrompt().filter((id) => typeof id === "string" && !id.includes("/") && isFreeModel(id));
+    if (ids.length) return ids;
+  } catch {}
+  return FALLBACK_FREE_POOL;
+}
+
 export const SLASH_HELP = `自然语言直接说，斜杠快捷：
   /help     本帮助
+  /model    查看/锁定模型（仅限 opencode free 池；锁定后严格只用该模型，不通即报错）
+            /model mimo-v2.5-free 锁定 · /model auto 解除锁定（回默认 mimo→pickle→auto 链）
   /stats    详细统计（网关 -d 的请求/延迟/模型）
   /history  查看对话历史
   /clear    清空历史
@@ -67,6 +82,31 @@ export function handleSlash(line, ctx) {
     console.log(SLASH_HELP);
     return { handled: true };
   }
+  if (low.startsWith("/model")) {
+    const arg = raw.slice(6).trim();
+    if (!arg) {
+      if (ctx.pinnedModel) console.log(`\x1b[36m当前锁定模型：${ctx.pinnedModel}（严格单模型，不通即报错）\x1b[0m`);
+      else console.log(`\x1b[90m未锁定模型 · 默认链：mimo-v2.5-free → big-pickle → 网关 auto\x1b[0m`);
+      return { handled: true };
+    }
+    if (arg === "auto" || arg === "clear" || arg === "off" || arg === "解锁" || arg === "解除") {
+      console.log(`\x1b[90m已解除模型锁定 · 回默认链：mimo-v2.5-free → big-pickle → 网关 auto\x1b[0m`);
+      return { handled: true, pinnedModel: null };
+    }
+    const id = arg;
+    if (id.includes("/")) {
+      console.log(`\x1b[31m[拒绝] ${id} 带供应商前缀 — -chat 只支持 opencode 上游模型（裸 id，直连 opencode.ai 免费池）\x1b[0m`);
+      console.log(`\x1b[90m其他供应商（deepseek/ workbuddy/ clinebot/ 等）请走网关：mslxdff -model set <id> 或 curl 本机 /v1/chat/completions\x1b[0m`);
+      return { handled: true };
+    }
+    if (!isFreeModel(id) || !freePoolNow().includes(id)) {
+      console.log(`\x1b[31m[拒绝] ${id} 不在 opencode free 池 — -chat 只能用 opencode 免费模型\x1b[0m`);
+      console.log(`\x1b[90m当前 free 池：${freePoolNow().join(", ")}\x1b[0m`);
+      return { handled: true };
+    }
+    console.log(`\x1b[36m[已锁定] ${id} · 严格只用该模型，不通即报错（不自动换模型）· 解除：/model auto\x1b[0m`);
+    return { handled: true, pinnedModel: id };
+  }
   if (["/stats", "/status", "stats", "status"].includes(low)) {
     console.log(formatStatsDetail());
     return { handled: true };

package/src/chat-pipeline/index.js

@@ -3,6 +3,7 @@ import { analyzePolicy } from "./policy.js";
 import { planRoute } from "./planner.js";
 import { createEngine } from "./engine.js";
 import { runHook } from "../plugins.js";
+import { isFreeModel } from "../models.js";
 import { clientIp, summarizePrompt } from "../routes/helpers.js";
 
 /**
@@ -21,7 +22,7 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
     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;
+    const { requested, useAuto, autoProvider, lockModel, hops, shareKeys, workbuddyUid, aliasInfo } = policy;
     mark("parsed");
     if (aliasInfo) { try { res?.setHeader?.("x-mslxdff-alias", aliasInfo); } catch {} }
     // mslxdff/ 前缀或 alias 命中时，把 body.model 改写为还原后的模型（与原 gateway 语义一致）
@@ -31,10 +32,20 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
 
     // order 推导 + plugin model:select 可改
     // 语义：指定模型 = 死锁单模型（本机→组员同款，挂了就报挂，不兜其他 picks）；只有 auto 才轮 picks
+    // x-mslxdff-auto-provider 头可把 auto 候选限定到单供应商（opencode=裸 id 免费池），-chat 默认带
     let order;
     if (lockModel) order = [requested];
-    else if (useAuto) order = auto ? await auto.candidates() : [""];
-    else {
+    else if (useAuto) {
+      let cands = auto ? await auto.candidates() : [""];
+      if (autoProvider) {
+        const before = cands.length;
+        cands = cands.filter((m) => (autoProvider === "opencode"
+          ? !String(m).includes("/") && isFreeModel(m)
+          : String(m).startsWith(`${autoProvider}/`)));
+        evt("auto-scope", { reqId, provider: autoProvider, before, after: cands.length });
+      }
+      order = cands;
+    } else {
       if (auto && requested) { try { await auto.candidatesFor(requested); } catch {} }
       order = [requested];
     }

package/src/chat-pipeline/policy.js

@@ -13,6 +13,8 @@ export function analyzePolicy({ headers = {}, body = {} } = {}) {
   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();
+  // auto 范围限定：x-mslxdff-auto-provider: opencode → auto 候选只留该供应商（opencode=裸 id 免费池）
+  const autoProvider = (headers["x-mslxdff-auto-provider"] || headers["X-Mslxdff-Auto-Provider"] || "").toString().trim().toLowerCase() || null;
   const rawModel = body.model || "";
 
   let normalizedRequested = normalizeModel(lockModel || rawModel || "");
@@ -64,6 +66,7 @@ export function analyzePolicy({ headers = {}, body = {} } = {}) {
     normalizedForUpstream,
     aliasInfo,
     useAuto,
+    autoProvider,
     shareKeys,
     workbuddyUid: extractedUid,
     lockModel,

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

@@ -9,6 +9,7 @@ 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";
+import { shouldUseGroupForModel } from "../state/schemas/use-group.js";
 
 /**
  * 串行 trial — 从 engine.js 抽出的第二段：via-route 单路径 → 串行 trial →
@@ -112,7 +113,8 @@ export async function runSerialTrial(ctx, deps = {}) {
       const isStream = Boolean(body.stream);
       const d = hedgeDelayMs();
       const hasPeers = Boolean(peers) && peers.ordered().length > 0;
-      const doHedge = shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers, model }) && upRes.status === 200 && upRes.body;
+      const canUseGroup = shouldUseGroupForModel(model);
+      const doHedge = canUseGroup && shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers, model }) && 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 };
@@ -128,12 +130,20 @@ export async function runSerialTrial(ctx, deps = {}) {
       }
     }
     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 (!shouldUseGroupForModel(model)) {
+        evt("group-skip", { reqId, model, reason: "useGroup=off for opencode (peer)" });
+      } else {
+        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 (!shouldUseGroupForModel(model)) {
+        evt("group-skip", { reqId, model, reason: "useGroup=off for opencode (broadband)" });
+      } else {
+        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 });

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

@@ -54,13 +54,6 @@ export function filterBenchModels({ providerId, allowed, picks, allowAny = false
 }
 
 export async function handleVia({ providerId, opts, fetchImpl, loadConfigs, loadKeys, loadAllowed, loadBaseUrl, loadAllowAny, loadModelPicks, getOnlinePeersFn }) {
-  // DeepSeek 防禁言：via 也不测（显式传入直接返回；all 形态在 targetIds 收集处排除）
-  if (String(providerId || "").trim().toLowerCase() === "deepseek") {
-    const msg = "跳过 deepseek bench-via —— 网页通道易触发禁言/频率风控，体检用 mslxdff -provider deepseek health";
-    if (opts.json) console.log(JSON.stringify({ meta: { at: new Date().toISOString(), samples: opts.samples, timeout: opts.timeoutMs, includeOpencode: false, peers: [], opencodeSkipped: true, deepseekSkipped: true }, results: [], advice: msg }, null, 2));
-    else console.log(msg);
-    return;
-  }
   const { getOnlinePeers, orchestrateVia, resolveIncludeOpencode } = await import("../../../bench/via.js");
   const peers = await (typeof getOnlinePeersFn === "function" ? getOnlinePeersFn() : getOnlinePeers());
   if (!peers.length) {
@@ -106,8 +99,6 @@ export async function handleVia({ providerId, opts, fetchImpl, loadConfigs, load
     const ids = new Set(Object.keys(configs));
     ids.add("opencode"); ids.add("openrouter");
     for (const pid of [...ids]) {
-      // DeepSeek 网页通道防禁言：all 形态直接排除，即使 allowlist 非空也不进候选
-      if (String(pid).toLowerCase() === "deepseek") continue;
       const allowed = loadAllowed(pid) || [];
       if (allowed.length) targetIds.push(pid);
     }

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

@@ -36,14 +36,6 @@ export async function handleProviderBench(id, sub, rest, args, deps = {}) {
   const isBench = sub === "bench" || sub === "benchmark" || sub === "eval" || sub === "test" || _isBenchViaAll;
   if (!isBench) return false;
   const opts = parseBenchArgs(_restArr);
-  // DeepSeek 网页通道防禁言：bench 轰炸易触发 muted/频率风控，一律跳过（体检用 health 探活代替）
-  const benchPidLower = String(id || "").trim().toLowerCase();
-  if (benchPidLower === "deepseek" || benchPidLower === "ds") {
-    const advice = "DeepSeek 网页通道（本机私有凭据）易触发禁言/频率风控，不支持 bench 测速。请用轻量体检：mslxdff -provider deepseek health";
-    if (opts.json) console.log(JSON.stringify({ ok: false, skipped: "deepseek", advice }, null, 2));
-    else console.log(`跳过 deepseek bench —— ${advice}`);
-    return true;
-  }
   if (opts.via) {
     const stateMod = await import("../../../state.js");
     const loadConfigs = deps.loadProviderConfigs || stateMod.loadProviderConfigs;

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

@@ -65,10 +65,6 @@ export async function handleProvider(args) {
   }
   const { handleClineLogin } = await import("./cline-login.js");
   if (await handleClineLogin(id, sub)) return true;
-  const { handleDeepseekLogin } = await import("./deepseek-login.js");
-  if (await handleDeepseekLogin(id, sub, rest)) return true;
-  const { handleDeepseekHealth } = await import("./deepseek-health.js");
-  if (await handleDeepseekHealth(id, sub, rest)) return true;
   const { handleWorkbuddyLogin } = await import("./workbuddy-login.js");
   if (await handleWorkbuddyLogin(id, sub, rest)) return true;
   const { handleProviderConfig } = await import("./config.js");

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

@@ -28,15 +28,12 @@ export async function handleProviderModels(id, sub, args, rest) {
   try {
     const { createGenericProvider } = await import("../../../providers/generic.js");
     const { createWorkbuddyProvider } = await import("../../../providers/workbuddy.js");
-    const { createDeepseekProvider } = await import("../../../providers/deepseek.js");
     const baseUrl = cfg?.baseUrl || (id === "workbuddy" ? "https://copilot.tencent.com" : "");
     const keys = loadProviderKeys(id);
     const auths = cfg?.auths || [];
     let provider;
     if (id === "workbuddy") {
       provider = createWorkbuddyProvider({ baseUrl, apiKeys: keys, auths, file: defaultStateFile() });
-    } else if (id === "deepseek") {
-      provider = createDeepseekProvider({ apiKeys: keys, file: defaultStateFile() });
     } else {
       if (!baseUrl) {
         console.error(`provider ${id}: missing baseUrl — set via: mslxdff -provider ${id} set-url <baseUrl>`);

package/src/cli/commands/use-group.js

@@ -0,0 +1,56 @@
+import { loadUseGroup, saveUseGroup, getEffectiveUseGroup, getUseGroupEnv } from "../../state/schemas/use-group.js";
+import { argValue } from "../policy.js";
+
+function parseInput(v) {
+  if (v === undefined || v === null || v === "") return null;
+  const s = String(v).trim().toLowerCase();
+  if (["1", "true", "on", "yes", "enable", "enabled", "open"].includes(s)) return true;
+  if (["0", "false", "off", "no", "disable", "disabled", "close", "closed"].includes(s)) return false;
+  return null;
+}
+
+export async function handleUseGroup(args) {
+  const hasFlag = args.some((a) => ["-use-group", "--use-group", "-use_group", "--use_group", "-usegroup", "--usegroup"].includes(a));
+  if (!hasFlag) return false;
+
+  // 取值：支持 -use-group true / -use-group=true / --use-group=off
+  let raw = argValue(args, "-use-group", "--use-group", "-use_group", "--use_group", "-usegroup", "--usegroup");
+  // 兼容 -use-group=true 这种等号形态
+  if (raw === null || raw === undefined) {
+    const eq = args.find((a) => a.startsWith("-use-group=") || a.startsWith("--use-group=") || a.startsWith("-use_group=") || a.startsWith("--use_group="));
+    if (eq) raw = eq.split("=")[1];
+  }
+  // 如果 flag 后面紧跟的不是另一个 flag，则视为值；否则视为查询
+  if (raw !== null && raw !== undefined && String(raw).startsWith("-")) raw = null;
+
+  const envVal = getUseGroupEnv();
+  const effective = getEffectiveUseGroup();
+  const stored = loadUseGroup();
+
+  if (raw === null || raw === undefined || raw === "") {
+    // 查询模式
+    console.log(`use-group: ${effective ? "on" : "off"} (effective)`);
+    console.log(`  stored: ${stored ? "on" : "off"} (state.json useGroup)`);
+    if (envVal !== null) console.log(`  env MSLXDFF_USE_GROUP=${envVal ? "on" : "off"} (overrides stored)`);
+    console.log(`  default: on`);
+    console.log(`  usage: mslxdff -use-group on|off  (opencode 供应商本机失败时是否走组员网络，默认 on)`);
+    console.log(`  env:   MSLXDFF_USE_GROUP=0|1  (优先级高于 state)`);
+    process.exit(0);
+  }
+
+  const parsed = parseInput(raw);
+  if (parsed === null) {
+    console.error(`invalid value for -use-group: ${raw} (expected on/off/true/false/1/0)`);
+    process.exit(1);
+  }
+
+  if (envVal !== null) {
+    console.log(`note: env MSLXDFF_USE_GROUP=${envVal ? "on" : "off"} is set and overrides stored value; unset env to use stored value`);
+  }
+
+  saveUseGroup(parsed);
+  console.log(`use-group set to ${parsed ? "on" : "off"} (stored in state.json)`);
+  console.log(`  opencode 供应商：本机失败时 ${parsed ? "允许" : "不再"} 通过组员网络请求上游`);
+  if (!parsed) console.log(`  提示：opencode 请求将仅在本机重试，不再走 peer/broadband 组员中继`);
+  process.exit(0);
+}

package/src/cli/help.js

@@ -43,6 +43,7 @@ Usage:
   mslxdff -autostart status        查看自启状态
   mslxdff -chat ["prompt"]       chat REPL（mimo-v2.5-free 优先/big-pickle 兜底，自然语言转命令，模糊匹配由模型完成，历史持久化，超长自动压缩，仅拦 -uninstall，daemon 重启不影响）
   mslxdff -resetban [ip]           clear join-failure bans (all, or one ip)
+  mslxdff -use-group [on|off]     opencode 供应商本机失败时是否走组员网络（默认 on；off 则仅本机，MSLXDFF_USE_GROUP 环境变量可覆盖）
   mslxdff -help                    show this help
 
 Environment:
@@ -62,6 +63,7 @@ Environment:
   MSLXDFF_BAN_THRESHOLD   failed joins before an ip is banned (default 5)
   MSLXDFF_BAN_WINDOW_MS   ban duration after too many failures (default 48h)
   MSLXDFF_HEDGE_DELAY_MS  hedge peer race when local stream first chunk slow (default 1000, 0/off to disable)
+  MSLXDFF_USE_GROUP       opencode 组员中继开关（默认 on；0/off/false 关闭后 opencode 仅本机，不走 peer/broadband）
   MSLXDFF_AUTO_UPDATE   auto-update: hourly by default, 0/off/false to disable, 1/true or ms
   MSLXDFF_AUTO_UPDATE_MS  same as above, explicit ms (overrides AUTO_UPDATE)
 `);

package/src/cli/index.js

@@ -49,6 +49,8 @@ export async function run(args = process.argv.slice(2)) {
   if (await handleLeaveGroup(args)) return;
   if (await handleDelGroup(args)) return;
 
+  const { handleUseGroup } = await import("./commands/use-group.js");
+  if (await handleUseGroup(args)) return;
   const { handlePort, handleDaemonFlag, handleBareRun } = await import("./commands/daemon.js");
   if (await handlePort(args)) return;
   if (await handleDaemonFlag(args, VERSION)) return;

package/src/providers/registry.js

@@ -15,11 +15,6 @@ export const customProviders = [
     match: (id, baseUrl) => id === "cline" || id === "clinebot" || String(baseUrl).includes("cline.bot"),
     load: () => import("./cline.js").then((m) => m.createClineProvider),
   },
-  {
-    id: "deepseek",
-    match: (id, baseUrl) => id === "deepseek" || String(baseUrl).includes("chat.deepseek.com"),
-    load: () => import("./deepseek.js").then((m) => m.createDeepseekProvider),
-  },
 ];
 
 // 供 bench/probe 等需要定制化解析模型列表的场景

package/src/routes/hedge.js

@@ -18,8 +18,7 @@ function shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers, mod
   if (!canForwardPeers) return false;
   if (!hasPeers) return false;
   if (!d || d <= 0) return false;
-  // deepseek = 本机私有凭据供应商（组员节点没有凭据），对冲必败且 both-fail 会误杀本地慢首块流（reasoner 思考 3-30s），不走组员
-  if (String(model || "").startsWith("deepseek/")) return false;
+  // 不做供应商级禁对冲特判：对冲仅按 useGroup/流式/peer 可用性决定
   // muse-spark 走 /responses 流式（event: 包装 + 加密 reasoning），组员旧版无此整形且聚合 JSON 带错 header，必抢赢本地慢首块，需本地直出
   if (String(model || "").toLowerCase().startsWith("muse-spark")) return false;
   return true;

package/src/runtime/providers-setup.js

@@ -76,8 +76,7 @@ export async function setupProviders() {
       const customFactory = await getCustomProviderFactory(gid, base);
       if (customFactory) {
         if (gid === "workbuddy" && !keys.length) continue;
-        if (gid === "deepseek" && !keys.length) continue;
-        if (gid !== "workbuddy" && gid !== "deepseek" && (!base || !keys.length)) continue;
+        if (gid !== "workbuddy" && (!base || !keys.length)) continue;
         try {
           const provider = gid === "workbuddy"
             ? await customFactory({ baseUrl: base || "https://copilot.tencent.com", apiKeys: keys, auths })

package/src/state/facade.js

@@ -57,3 +57,4 @@ export {
 export { loadPeers, savePeers, loadPeerErrors, savePeerErrors, loadPeerStats, savePeerStats } from "./schemas/peer.js";
 export { loadGroups, loadGroupsJoined, saveGroupsJoined, loadBans, saveBans, saveGroups } from "./schemas/group.js";
 export { loadTimezone, loadTimezoneState, saveTimezone, clearTimezone, getTimezoneEnv, DEFAULT_TZ, isValidTimezone } from "./schemas/timezone.js";
+export { loadUseGroup, saveUseGroup, getEffectiveUseGroup, shouldUseGroupForModel, isUseGroupEnabled, getUseGroupEnv } from "./schemas/use-group.js";

package/src/state/schemas/use-group.js

@@ -0,0 +1,56 @@
+import { defaultStateFile, readState, writeStateImmediate } from "../store.js";
+
+function parseBool(v) {
+  if (typeof v === "boolean") return v;
+  if (typeof v === "number") return v !== 0;
+  if (typeof v === "string") {
+    const s = v.trim().toLowerCase();
+    if (["0", "false", "off", "no", "disable", "disabled", "close", "closed"].includes(s)) return false;
+    if (["1", "true", "on", "yes", "enable", "enabled", "open"].includes(s)) return true;
+  }
+  return null;
+}
+
+export function loadUseGroup({ file = defaultStateFile() } = {}) {
+  const raw = readState(file).useGroup;
+  const parsed = parseBool(raw);
+  return parsed === null ? true : parsed; // 默认开
+}
+
+export function saveUseGroup(value, { file = defaultStateFile() } = {}) {
+  const b = Boolean(value);
+  writeStateImmediate(file, { useGroup: b });
+  return b;
+}
+
+export function getUseGroupEnv() {
+  const raw = process.env.MSLXDFF_USE_GROUP;
+  if (raw === undefined || raw === null || raw === "") return null;
+  return parseBool(raw);
+}
+
+export function getEffectiveUseGroup({ file = defaultStateFile() } = {}) {
+  const env = getUseGroupEnv();
+  if (env !== null) return env;
+  return loadUseGroup({ file });
+}
+
+// 仅对 opencode 供应商生效：opencode 的模型为裸 id 或 opencode/ 前缀
+export function shouldUseGroupForModel(model, { file = defaultStateFile() } = {}) {
+  const m = String(model || "").trim();
+  if (!m) return getEffectiveUseGroup({ file });
+  // 带前缀：判断是否为 opencode
+  if (m.includes("/")) {
+    const head = m.split("/")[0].trim().toLowerCase();
+    if (head === "opencode" || head === "oc") {
+      return getEffectiveUseGroup({ file });
+    }
+    return true; // 其他供应商不受此开关限制
+  }
+  // 裸 id 视为 opencode
+  return getEffectiveUseGroup({ file });
+}
+
+export function isUseGroupEnabled({ file } = {}) {
+  return getEffectiveUseGroup({ file });
+}

package/src/cli/commands/provider/deepseek-health.js

@@ -1,46 +0,0 @@
-// -provider deepseek health：逐账号探活（防禁言体系）
-// 用法：mslxdff -provider deepseek health [--json]
-// 对池内每个账号发最小真实请求（Hello world + PoW），检测 muted/限频/凭据坏；
-// 禁言账号自动冷却 5min（解封后再次探活即自动恢复）。不经过组员、直连本机凭据。
-export async function handleDeepseekHealth(id, sub, rest) {
-  if (id !== "deepseek" && id !== "ds") return false;
-  if (sub !== "health" && sub !== "check") return false;
-
-  const args = rest || [];
-  const jsonOut = args.some((a) => a === "--json" || a === "-json");
-
-  const { loadProviderKeys } = await import("../../../state.js");
-  const keys = loadProviderKeys("deepseek") || [];
-  if (!keys.length) {
-    console.error("❌ 没有 DeepSeek 凭据，先登录：");
-    console.error("  mslxdff -provider deepseek login --token <userToken>");
-    process.exit(1);
-  }
-
-  const { createAuthPool } = await import("../../../providers/deepseek/auth.js");
-  const { deepseekHealth } = await import("../../../providers/deepseek/health.js");
-  const authPool = createAuthPool({ tokens: keys });
-
-  if (!jsonOut) {
-    console.log(`🔍 DeepSeek 探活中（${keys.length} 个账号，逐个发最小请求）...`);
-  }
-  const report = await deepseekHealth({ authPool });
-
-  if (jsonOut) {
-    console.log(JSON.stringify(report, null, 2));
-  } else {
-    for (const r of report) {
-      console.log(`  ${r.ok ? "✓" : "✗"} ...${r.tokenTail}  ${r.detail}`);
-    }
-    const okCount = report.filter((r) => r.ok).length;
-    console.log(`\n结果：${okCount}/${report.length} 健康`);
-    if (okCount === 0) {
-      console.log("全部账号异常 —— 修复建议：");
-      console.log("  1. chat.deepseek.com 登录后 F12 → Application → Local Storage → 复制 userToken");
-      console.log("  2. mslxdff -provider deepseek login --token <userToken>  追加账号");
-      console.log("  3. 禁言账号等待解除后再次探活即自动恢复");
-    }
-  }
-  if (report.length && report.every((r) => !r.ok)) process.exitCode = 1;
-  return true;
-}