mslxdff 0.1.128 → 0.1.129

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.128",
+  "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/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 };
-}