mslxdff 0.1.127 → 0.1.129

package/package.json

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

package/src/chat-pipeline/engine.js

@@ -7,7 +7,7 @@ import { runSerialTrial } from "./serial-trial.js";
  */
 export function createEngine(deps = {}) {
   const { raceDeps, serialDeps } = deps;
-  async function run(_plan, state) {
+  async function run(state) {
     const race = await runAutoRace(state, raceDeps);
     if (race.done) return;
     await runSerialTrial({ ...state, order: race.order }, serialDeps);

package/src/chat-pipeline/index.js

@@ -1,15 +1,13 @@
 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 { isFreeModel } from "../models.js";
-import { shouldUseGroupForModel } from "../state/schemas/use-group.js";
 import { clientIp, summarizePrompt } from "../routes/helpers.js";
 
 /**
  * ChatPipeline 深模块门面 — 对外 execute(req) 单一 inlet
- * 内部组合 Policy→Planner→Engine：解析 header/model → 产 order → 委托 engine 执行
+ * 内部组合 Policy→Engine：解析 header/model → 产 order → 委托 engine 执行
  * gateway 仅薄适配：readBody + request:received hook + 调 execute
  */
 export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, token, plugins, maxHops } = {}) {
@@ -31,6 +29,20 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
       req.body = { ...req.body, model: requested };
     }
 
+    // 事件/日志帮手先于 order 推导声明：evt 在 auto-scope 分支即被使用，
+    // 声明置后会让 useAuto && autoProvider 的请求在 TDZ 上崩（线上 -chat 回退路径）
+    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(() => {});
+    };
+
     // order 推导 + plugin model:select 可改
     // 语义：指定模型 = 死锁单模型（本机→组员同款，挂了就报挂，不兜其他 picks）；只有 auto 才轮 picks
     // x-mslxdff-auto-provider 头可把 auto 候选限定到单供应商（opencode=裸 id 免费池），-chat 默认带
@@ -55,18 +67,6 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
     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) });
@@ -88,11 +88,7 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
     const handlerCtx = { reqId, model: null, body: req?.body, hops, peers, plugins, evt, logError, logCall, logs, workbuddyUid, sessionId: clientSession };
     if (clientSession) evt("client-session", { reqId, sessionId: clientSession.slice(0, 24) });
 
-    const plan = planRoute(policy, {
-      candidates: order,
-      viaRoute: Boolean(!useAuto && requested.includes("/") && canForwardPeers && shouldUseGroupForModel(requested)) ? { via: true } : null,
-    });
-    await engine.run(plan, {
+    await engine.run({
       reqId, startedAt, req, res, body: req?.body, policy,
       useAuto, lockModel, requested, hops,
       canFallback, canForwardPeers,
@@ -102,5 +98,5 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
     });
   }
 
-  return { execute, _policy: analyzePolicy, _plan: planRoute, _engine: engine };
+  return { execute, _policy: analyzePolicy, _engine: engine };
 }

package/src/chat-pipeline/policy.js

@@ -40,7 +40,7 @@ export function analyzePolicy({ headers = {}, body = {} } = {}) {
     if (!aliasInfo) aliasInfo = null;
   }
 
-  // workbuddy <uid>:model 形式的 uid 钉死在 normalizeFullId 侧处理，这里透传原始 requested 供 planner 二次剥离
+  // workbuddy <uid>:model 形式的 uid 钉死在 normalizeFullId 侧处理，这里透传原始 requested
   // 若 requested 含 workbuddy/ 前缀且含 :，则尝试提取 uid
   let extractedUid = workbuddyUid;
   if (!extractedUid && requested.startsWith("workbuddy/") && requested.includes(":")) {
@@ -52,7 +52,7 @@ export function analyzePolicy({ headers = {}, body = {} } = {}) {
   const useAuto = isAutoModel(requested);
 
   // 对 workbuddy 前缀的 model，做 normalizeFullId 归一（剥 uid 供上游）
-  // 但保留 requested 为完整带前缀形态，供 planner 做 ViaRoute 判定
+  // 但保留 requested 为完整带前缀形态，供 serial-trial 做 ViaRoute 判定与组员路由
   let normalizedForUpstream = requested;
   try {
     const norm = normalizeFullId(requested);

package/src/model-capabilities/index.js

@@ -121,7 +121,7 @@ export function createCapabilitiesService({
   return { ready, get, list, providers, npmIndex: () => new Map(npmIndex) };
 }
 
-// 模块级单例（与 globalDedup 同模式）：HTTP handler 懒加载，测试 _reset 后注入
+// 模块级单例：HTTP handler 懒加载，测试 _reset 后注入
 let _global = null;
 export function globalCapabilities() {
   if (!_global) _global = createCapabilitiesService({ cacheFile: defaultCacheFile() });

package/src/providers/cline/index.js

@@ -117,10 +117,10 @@ export function createClineProvider({
     return list;
   }
 
-  const { preheat } = (() => {
-    try { return modelsSvc; } catch { return { preheat: async () => ({ ok: false }) }; }
+  const { preheat, checkFreeUpdates } = (() => {
+    try { return modelsSvc; } catch { return { preheat: async () => ({ ok: false }), checkFreeUpdates: async () => ({ ok: false }) }; }
   })();
 
   async function close() { if (agent?.close) try { await agent.close(); } catch {} }
-  return { id, chat, chatWithKeys, listModels, preheat, close, agent, keyRing: ring, baseUrl: resolvedBase, _authPool: authPool };
+  return { id, chat, chatWithKeys, listModels, preheat, checkFreeUpdates, close, agent, keyRing: ring, baseUrl: resolvedBase, _authPool: authPool };
 }

package/src/providers/cline/models.js

@@ -71,9 +71,9 @@ export function createModelsService({ id, baseUrl, modelsPath, fetchImpl, dispat
     } catch { return fallbackList(); } finally { clearTimeout(timer); }
   }
 
-  // 每次 daemon 启动（server-lifecycle → dispatcher.preheat）自检 free 列表：
+  // 每次 daemon 启动自检 free 列表（server-lifecycle 显式调 checkFreeUpdates，不经 dispatcher.preheat）：
   // 对比快照报增删并留痕（daemon.log），顺带把结果填缓存（省一次 listModels 请求）。
-  // 快照路径由 index.js 注入 logDir 下文件；未注入时仅跳过自检，不影响预热。
+  // 快照路径由 index.js 注入 logDir 下文件；未注入时仅跳过自检，不影响拉取。
   function readSnapshotFree() {
     try { const j = JSON.parse(readFileSync(snapshotPath, "utf8")); return Array.isArray(j?.free) ? j.free : null; } catch { return null; }
   }
@@ -104,7 +104,8 @@ export function createModelsService({ id, baseUrl, modelsPath, fetchImpl, dispat
     return { added, removed };
   }
 
-  async function preheat() {
+  // 启动自检入口：拉 recommended-models → 填缓存 → 对比快照报 free 增删。
+  async function checkFreeUpdates() {
     const url = resolveModelsUrl();
     const t0 = performance.now();
     try {
@@ -142,5 +143,10 @@ export function createModelsService({ id, baseUrl, modelsPath, fetchImpl, dispat
     }
   }
 
-  return { listModels, preheat };
+  // preheat 保留为别名：dispatcher 已不再调 clinebot，手动/测试/未来钩子仍可用，行为与自检一致
+  async function preheat() {
+    return checkFreeUpdates();
+  }
+
+  return { listModels, preheat, checkFreeUpdates };
 }

package/src/providers/dispatcher.js

@@ -92,17 +92,18 @@ export function createProviderDispatcher(providers = [], opts = {}) {
     return out;
   }
 
+  // 只预热默认供应商（opencode）：连接池与模型缓存预热是其主链路收益；
+  // 其他供应商按需在首次请求时自拉（10min 缓存）。不再逐家预热，避免 daemon 每次启动
+  // 对所有上游各发一次 GET；MSLXDFF_PREHEAT=0 的关闭由唯一被调的 opencode preheat 自行尊重。
+  // 见 .agents/notes/implemented/simplification/2026-09-16-preheat-opencode-only.md
   async function preheat() {
-    const results = [];
-    for (const p of providers) {
-      if (typeof p.preheat !== "function") continue;
-      try {
-        results.push(await p.preheat());
-      } catch {
-        results.push({ ok: false, error: "preheat failed" });
-      }
+    const p = byId.get(DEFAULT_PROVIDER);
+    if (!p || typeof p.preheat !== "function") return { ok: false, skipped: true };
+    try {
+      return await p.preheat();
+    } catch {
+      return { ok: false, error: "preheat failed" };
     }
-    return results.length ? results[0] : { ok: false, skipped: true };
   }
 
   async function close() {

package/src/runtime/server-lifecycle.js

@@ -123,6 +123,12 @@ export async function startServerLifecycle({ VERSION, token, created, upstream,
       else if (r.ok) console.log(`[preheat] opencode models ok ${r.status} ${r.ms}ms`);
       else console.log(`[preheat] opencode models failed ${r.error || r.status || ""} ${r.ms || 0}ms`);
     }).catch(() => {});
+    // clinebot free 目录自检（独立于 opencode 连接预热：dispatcher.preheat 只做默认供应商）
+    // 见 .agents/notes/implemented/simplification/2026-09-16-preheat-opencode-only.md
+    try {
+      const cline = upstream?.byId?.get?.("clinebot") ?? upstream?.byId?.get?.("cline");
+      if (cline?.checkFreeUpdates) void cline.checkFreeUpdates().catch(() => {});
+    } catch {}
   }, 100).unref?.();
 
   // responses 模型判定改元数据驱动（models.dev provider.npm）：就绪后注入，每小时重查使新模型自动识别

package/src/chat-pipeline/dedup.js

@@ -1,83 +0,0 @@
-import { createHash } from "node:crypto";
-
-/**
- * 请求去重（防前端双击/重试风暴）
- * key = ip | requested | stream | bodyHash(messages+model变体)
- * 窗口内重复到达的相同请求直接 429 返回，提示前端去重
- * 默认窗口 1000ms，可用 MSLXDFF_DEDUP_WINDOW_MS 覆盖，0 为关闭
- */
-export function dedupWindowMs() {
-  const raw = process.env.MSLXDFF_DEDUP_WINDOW_MS;
-  if (raw != null && String(raw).trim() !== "") {
-    const n = Number(raw);
-    if (Number.isFinite(n) && n >= 0) return Math.floor(n);
-  }
-  return 1000;
-}
-
-function hashBody(body) {
-  try {
-    const m = body?.messages;
-    const s = JSON.stringify({
-      model: body?.model || "",
-      stream: Boolean(body?.stream),
-      max_tokens: body?.max_tokens ?? body?.maxTokens ?? null,
-      messages: Array.isArray(m) ? m.map((x) => ({ role: x.role, content: typeof x.content === "string" ? x.content.slice(0, 4000) : JSON.stringify(x.content).slice(0, 4000) })) : [],
-      // 工具调用等也纳入，避免误判
-      tools: body?.tools ? JSON.stringify(body.tools).slice(0, 1000) : "",
-    });
-    return createHash("sha1").update(s).digest("hex").slice(0, 16);
-  } catch {
-    return String(body?.model || "").slice(0, 32);
-  }
-}
-
-let _global = null;
-export function globalDedup() {
-  if (!_global) _global = createDedup({ windowMs: dedupWindowMs() });
-  // 若环境变量在运行时被改，同步窗口
-  const want = dedupWindowMs();
-  if (_global.windowMs !== want) {
-    _global.windowMs = want;
-  }
-  return _global;
-}
-export function _resetGlobalDedup() { _global = null; }
-
-export function createDedup({ windowMs = dedupWindowMs(), now = Date.now } = {}) {
-  const map = new Map(); // key -> at
-  let sweepAt = 0;
-
-  function sweep() {
-    const t = now();
-    if (t - sweepAt < windowMs) return;
-    sweepAt = t;
-    for (const [k, at] of map) {
-      if (t - at > windowMs) map.delete(k);
-    }
-  }
-
-  function keyFor({ ip, requested, body }) {
-    const h = hashBody(body);
-    const stream = body?.stream ? "1" : "0";
-    return `${ip || "-"}|${requested || "-"}|${stream}|${h}`;
-  }
-
-  function check({ ip, requested, body }) {
-    if (!windowMs) return { dup: false, key: null };
-    sweep();
-    const key = keyFor({ ip, requested, body });
-    const at = map.get(key);
-    const t = now();
-    if (at != null && t - at < windowMs) {
-      return { dup: true, key, ageMs: t - at };
-    }
-    map.set(key, t);
-    return { dup: false, key };
-  }
-
-  function _size() { return map.size; }
-  function _clear() { map.clear(); }
-
-  return { check, keyFor, _size, _clear, windowMs };
-}

package/src/chat-pipeline/planner.js

@@ -1,31 +0,0 @@
-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 };
-}