mslxdff 0.1.107 → 0.1.109

package/package.json

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

package/src/chat-pipeline/index.js

@@ -4,6 +4,7 @@ import { planRoute } from "./planner.js";
 import { createEngine } from "./engine.js";
 import { runHook } from "../plugins.js";
 import { isFreeModel } from "../models.js";
+import { shouldUseGroupForModel } from "../state/schemas/use-group.js";
 import { clientIp, summarizePrompt } from "../routes/helpers.js";
 
 /**
@@ -85,7 +86,7 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
 
     const plan = planRoute(policy, {
       candidates: order,
-      viaRoute: Boolean(!useAuto && requested.includes("/") && canForwardPeers) ? { via: true } : null,
+      viaRoute: Boolean(!useAuto && requested.includes("/") && canForwardPeers && shouldUseGroupForModel(requested)) ? { via: true } : null,
     });
     await engine.run(plan, {
       reqId, startedAt, req, res, body: req?.body, policy,

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

@@ -35,7 +35,7 @@ export async function runSerialTrial(ctx, deps = {}) {
   const workbuddyUid = ctx.workbuddyUid ?? ctx.policy?.workbuddyUid ?? null;
 
   let viaRouteLastErr = null;
-  if (!useAuto && requested && requested.includes("/") && canForwardPeers && !lockModel && peers) {
+  if (!useAuto && requested && requested.includes("/") && canForwardPeers && !lockModel && peers && shouldUseGroupForModel(requested)) {
     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 };
@@ -131,7 +131,7 @@ export async function runSerialTrial(ctx, deps = {}) {
     }
     if (canForwardPeers) {
       if (!shouldUseGroupForModel(model)) {
-        evt("group-skip", { reqId, model, reason: "useGroup=off for opencode (peer)" });
+        evt("group-skip", { reqId, model, reason: "useGroup=off (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 };
@@ -139,7 +139,7 @@ export async function runSerialTrial(ctx, deps = {}) {
     }
     if (groups) {
       if (!shouldUseGroupForModel(model)) {
-        evt("group-skip", { reqId, model, reason: "useGroup=off for opencode (broadband)" });
+        evt("group-skip", { reqId, model, reason: "useGroup=off (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 };

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

@@ -33,7 +33,7 @@ export async function handleUseGroup(args) {
     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(`  usage: mslxdff -use-group on|off  (本机失败时是否走组员网络，默认 on)`);
     console.log(`  env:   MSLXDFF_USE_GROUP=0|1  (优先级高于 state)`);
     process.exit(0);
   }
@@ -50,7 +50,7 @@ export async function handleUseGroup(args) {
 
   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 组员中继`);
+  console.log(`  ${parsed ? "允许" : "不再允许"}走组员网络（via-route/hedge/peer/broadband，全部供应商）`);
+  if (!parsed) console.log(`  提示：所有请求将仅在本机重试，不再走组员中继`);
   process.exit(0);
 }

package/src/cli/help.js

@@ -43,7 +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 -use-group [on|off]     本机失败时是否走组员网络（默认 on；off 则所有供应商仅本机，MSLXDFF_USE_GROUP 环境变量可覆盖）
   mslxdff -help                    show this help
 
 Environment:
@@ -63,7 +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_USE_GROUP       组员中继总开关（默认 on；0/off/false 关闭后所有供应商仅本机，不走 via-route/hedge/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/providers/cline/auth.js

@@ -19,6 +19,22 @@ export function parseCooldown(body, status) {
   return 60 * 1000;
 }
 
+/**
+ * 真死 vs 假死：对标官方 getValidClineCredentials 契约——只有 invalid_grant
+ *（refresh token 被拒）才判死，需重新授权；网络抖动/5xx/超时是瞬时失败，
+ * 手里 token 仍有效时继续用，且绝不清掉已存凭证。
+ */
+export function isInvalidGrant(bodyText, status) {
+  const t = String(bodyText || "").toLowerCase();
+  if (/invalid_grant|invalid_token/.test(t)) return true;
+  // 路由拼错/版本提示类 401（"...latest version...re-authenticate your Cline account"）
+  // 只是打错了地址，不是 token 死，绝不能判死，否则好号会被永久冷冻。
+  if (/latest version|re-authenticate/.test(t)) return false;
+  if ((status === 400 || status === 403) && /invalid|expired|revoked/.test(t)) return true;
+  if (status === 401 && /invalid_grant|invalid token|token[^.]{0,30}(expired|revoked|invalid)/.test(t)) return true;
+  return false;
+}
+
 /**
  * 一次性 refresh：bench/诊断用，不落盘、不建池。
  * 返回 accessToken 或 null。
@@ -90,6 +106,7 @@ export function createAuthPool({
     for (let k = 0; k < list.length; k++) {
       const acc = list[accountIndex % list.length];
       accountIndex = (accountIndex + 1) % list.length;
+      if (acc.dead) continue;
       if (!acc.cooldownUntil || acc.cooldownUntil <= clock()) {
         currentAccount = acc;
         return acc;
@@ -100,9 +117,13 @@ export function createAuthPool({
 
   async function refreshOne(account) {
     const now = clock();
+    if (account.dead) throw new Error("invalid_grant");
     if (account.cooldownUntil > now) throw new Error("account_cooldown");
     if (account.accessToken && now < account.expiry) return account.accessToken;
-    const url = joinUrl(resolvedBase, "/api/v1/auth/refresh");
+    // base 可能已含 /api/v1（state 里 clinebot baseUrl 就是 …/api/v1），直接拼会 double 成
+    // …/api/v1/api/v1/auth/refresh → 上游回 401 Unauthorized（版本/重认证提示），绝不能当 token 死。
+    const baseNoV1 = resolvedBase.replace(/\/api\/v1\/?$/, "");
+    const url = joinUrl(baseNoV1, "/api/v1/auth/refresh");
     const opts = {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -111,7 +132,12 @@ export function createAuthPool({
     if (dispatcher) opts.dispatcher = dispatcher;
     let res;
     try { res = await fetchImpl(url, opts); } catch { account.cooldownUntil = now + 60 * 1000; throw new Error("refresh_failed"); }
-    if (!res.ok) { account.cooldownUntil = now + 60 * 1000; throw new Error("refresh_failed"); }
+    if (!res.ok) {
+      let t = "";
+      try { t = await res.text(); } catch {}
+      if (isInvalidGrant(t, res.status)) { account.dead = true; throw new Error("invalid_grant"); }
+      account.cooldownUntil = now + 60 * 1000; throw new Error("refresh_failed");
+    }
     let data;
     try { data = await res.json(); } catch { account.cooldownUntil = now + 60 * 1000; throw new Error("refresh_no_token"); }
     const accessToken = data?.data?.accessToken || data?.accessToken || data?.access_token;
@@ -138,11 +164,12 @@ export function createAuthPool({
     if (pool.length === 0) throw new Error("缺少 CLINE_REFRESH_TOKEN（请用 cline_oauth.py 获取）");
     for (let attempt = 0; attempt < pool.length; attempt++) {
       const acc = pool[attempt % pool.length];
+      if (acc.dead) continue;
       if (acc.cooldownUntil && acc.cooldownUntil > clock()) continue;
       currentAccount = acc;
       try { return await refreshOne(acc); } catch (e) { if (e.message === "account_cooldown") continue; continue; }
     }
-    const acc = pool[0];
+    const acc = pool.find((a) => !a.dead) || null;
     if (!acc) throw new Error("无可用 Cline 账号");
     currentAccount = acc;
     acc.cooldownUntil = 0;

package/src/providers/cline/chat.js

@@ -155,9 +155,14 @@ export function createChatService({
     const sessionId = genSessionId();
     const isStream = body?.stream === true;
     const upstreamModel = stripProviderPrefix(model);
+    // token 口径双写：对标官方 withMaxCompletionTokensForReasoningModels——
+    // cline 上游默认 reasoning_effort high，推理模型认 max_completion_tokens，
+    // 只发 max_tokens 会被部分通道拒；双写兼容最稳。
+    const tokLimit = body?.max_tokens || body?.max_completion_tokens || 4096;
     const upstreamBody = {
       model: upstreamModel,
-      max_tokens: body?.max_tokens || body?.max_completion_tokens || 4096,
+      max_tokens: tokLimit,
+      max_completion_tokens: tokLimit,
       session_id: sessionId,
       reasoning_effort: body?.reasoning_effort || body?.reasoningEffort || "high",
       messages: body?.messages || [],

package/src/providers/cline/models.js

@@ -16,10 +16,34 @@ export function createModelsService({ id, baseUrl, modelsPath, fetchImpl, dispat
   let cache = null;
   let fetchedAt = 0;
 
+  // 离线兜底：对标官方 FALLBACK（free 数组实证含 z-ai/glm-5.3-flash）。
+  // 上游挂了/401 时也不返回空数组，保证 -provider clinebot models 与 picks 仍有免费可用。
+  const FALLBACK_FREE = [
+    { id: "deepseek/deepseek-v4-flash", name: "deepseek-v4-flash" },
+    { id: "z-ai/glm-5.3-flash", name: "glm-5.3-flash" },
+    { id: "poolside/laguna-s-2.1:free", name: "laguna-s-2.1:free" },
+  ];
+
+  function fallbackList() {
+    const out = FALLBACK_FREE.map((m) => ({ ...m, id: joinModelId(id, m.id) }));
+    cache = out; fetchedAt = Date.now();
+    return out;
+  }
+
+  // 端点归一化：官方取 {bareHost}/api/v1/ai/cline/recommended-models。
+  // baseUrl 可能是裸 host（https://api.cline.bot）也可能是带 /api/v1 的，
+  // 统一收敛到 …/api/v1/ai/cline/recommended-models；用户自定义 path 原样尊重。
+  function resolveModelsUrl() {
+    const custom = modelsPath && modelsPath !== "/models" && modelsPath !== "/ai/cline/recommended-models";
+    if (custom) return joinUrl(resolvedBase, resolvedPath);
+    const bare = resolvedBase.replace(/\/api\/v1\/?$/, "");
+    return joinUrl(bare, "/api/v1/ai/cline/recommended-models");
+  }
+
   async function listModels() {
     const now = Date.now();
     if (cache && now - fetchedAt < CACHE_TTL) return cache;
-    const url = joinUrl(resolvedBase, resolvedPath);
+    const url = resolveModelsUrl();
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(new Error(`${id} models timed out`)), 15_000);
     try {
@@ -29,20 +53,22 @@ export function createModelsService({ id, baseUrl, modelsPath, fetchImpl, dispat
       const opts = { headers, signal: controller.signal };
       if (dispatcher) opts.dispatcher = dispatcher;
       const res = await fetchImpl(url, opts);
-      if (!res.ok) return [];
+      if (!res.ok) return fallbackList();
       const json = await res.json().catch(() => ({}));
       if (isClineBotHost(resolvedBase) && Array.isArray(json.free)) {
         const out = json.free.filter((m) => m && typeof m.id === "string").map((m) => ({ ...m, id: joinModelId(id, m.id) }));
+        if (!out.length) return fallbackList();
         cache = out; fetchedAt = now; return out;
       }
       const raw = Array.isArray(json.data) ? json.data : Array.isArray(json.models) ? json.models : Array.isArray(json) ? json : [];
       const out = raw.filter((m) => m && typeof m.id === "string").map((m) => ({ ...m, id: joinModelId(id, m.id) }));
+      if (!out.length) return fallbackList();
       cache = out; fetchedAt = now; return out;
-    } catch { return []; } finally { clearTimeout(timer); }
+    } catch { return fallbackList(); } finally { clearTimeout(timer); }
   }
 
   async function preheat() {
-    const url = joinUrl(resolvedBase, resolvedPath);
+    const url = resolveModelsUrl();
     const t0 = performance.now();
     try {
       const headers = { Accept: "application/json" };

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

@@ -35,19 +35,8 @@ export function getEffectiveUseGroup({ file = defaultStateFile() } = {}) {
   return loadUseGroup({ file });
 }
 
-// 仅对 opencode 供应商生效：opencode 的模型为裸 id 或 opencode/ 前缀
+// 全局开关：off 则所有供应商都不走组员网络（via-route/hedge/peer/broadband 全禁），仅本机直连
 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 });
 }