mslxdff 0.1.87 → 0.1.89

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/providers/cline/chat.js

@@ -1,5 +1,6 @@
 import { joinUrl, sleep } from "../base.js";
 import { clineHeaders } from "./headers.js";
+import { createTransport } from "../../transport/index.js";
 
 function genSessionId() { return `sess_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`; }
 
@@ -12,40 +13,27 @@ function unwrapData(obj) {
 }
 
 async function streamToNonStream(upstream) {
-  const reader = upstream.body.getReader();
-  const decoder = new TextDecoder();
-  let buf = "";
   let content = "";
   let reasoning = "";
   let finishReason = null;
   let model = "";
   let id = "";
   let usage = null;
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    buf += decoder.decode(value, { stream: true });
-    let idx;
-    while ((idx = buf.indexOf("\n")) >= 0) {
-      const line = buf.slice(0, idx);
-      buf = buf.slice(idx + 1);
-      if (!line.startsWith("data:")) continue;
-      const payload = line.slice(5).trim();
-      if (!payload || payload === "[DONE]") continue;
-      try {
-        const obj = JSON.parse(payload);
-        const normalized = unwrapData(obj);
-        const choice = normalized?.choices?.[0];
-        if (!choice) continue;
-        const delta = choice.delta || {};
-        if (delta.content) content += delta.content;
-        if (delta.reasoning) reasoning += delta.reasoning;
-        if (choice.finish_reason) finishReason = choice.finish_reason;
-        if (normalized.id) id = normalized.id;
-        if (normalized.model) model = normalized.model;
-        if (normalized.usage) usage = normalized.usage;
-      } catch {}
-    }
+  for await (const ev of upstream.stream()) {
+    if (!ev || ev === "[DONE]") continue;
+    try {
+      const obj = JSON.parse(ev);
+      const normalized = unwrapData(obj);
+      const choice = normalized?.choices?.[0];
+      if (!choice) continue;
+      const delta = choice.delta || {};
+      if (delta.content) content += delta.content;
+      if (delta.reasoning) reasoning += delta.reasoning;
+      if (choice.finish_reason) finishReason = choice.finish_reason;
+      if (normalized.id) id = normalized.id;
+      if (normalized.model) model = normalized.model;
+      if (normalized.usage) usage = normalized.usage;
+    } catch {}
   }
   const msg = { role: "assistant", content };
   if (reasoning) msg.reasoning = reasoning;
@@ -68,42 +56,34 @@ export function createChatService({
   dispatcher,
   authPool,
   connectTimeoutMs = 30_000,
-  retry = { network: { attempts: 2, delayMs: 300 } },
 } = {}) {
   const resolvedBase = String(baseUrl).trim().replace(/\/+$/, "");
-  // chat 固定落在 /api/v1/chat/completions：base 已含 /api/v1 则只拼 /chat/completions，
-  // 否则拼 /api/v1/chat/completions（避免双 /api/v1 或 /v1 错路径导致 401/empty response）
   const resolvedChat = chatPath || (String(resolvedBase).includes("/api/v1") ? "/chat/completions" : "/api/v1/chat/completions");
+  const transport = createTransport({ fetchImpl, dispatcher, keepAlive: !!dispatcher, timeoutMs: connectTimeoutMs, retry: {} });
 
   async function clineFetch(body, sessionId) {
     const token = await authPool.getAccessToken();
     const headers = clineHeaders(sessionId, token);
     const finalUrl = joinUrl(resolvedBase, resolvedChat);
-    const opts = { method: "POST", headers, body: JSON.stringify(body) };
-    if (dispatcher) opts.dispatcher = dispatcher;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(new Error(`${id} timed out after ${connectTimeoutMs}ms`)), connectTimeoutMs);
-    opts.signal = controller.signal;
-    try { return await fetchImpl(finalUrl, opts); } finally { clearTimeout(timer); }
+    const isStream = body?.stream === true;
+    return transport.request({ url: finalUrl, headers, body, stream: isStream, timeoutMs: connectTimeoutMs });
   }
 
-  // 判断限流信号
-  function isLimitHit(status, bodyText, isStream) {
+  function isLimitHit(status, bodyText) {
     if (status === 429) return true;
     if (status >= 500 && String(bodyText).includes("empty response content")) return true;
-    if (status === 200 && !isStream && String(bodyText).includes("empty response content")) return true;
     return false;
   }
 
-  async function clineFetchWithRetry(body, sessionId, isStream) {
+  async function clineFetchWithRetry(body, sessionId) {
     const maxRetries = 4;
     let lastResp = null;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
       const resp = await authPool.enqueue(() => clineFetch(body, sessionId));
       lastResp = resp;
       let bodyText = "";
-      try { bodyText = await resp.clone().text(); } catch {}
-      const hit = isLimitHit(resp.status, bodyText, isStream);
+      if (resp.status !== 200) { try { bodyText = await resp.text(); } catch {} }
+      const hit = isLimitHit(resp.status, bodyText);
       if (hit) {
         const { parseCooldown } = await import("./auth.js");
         const cooldownMs = parseCooldown(bodyText, resp.status);
@@ -126,7 +106,7 @@ export function createChatService({
     let lastData = null;
     let resp = firstResp;
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      if (!resp) resp = await clineFetchWithRetry(body, sessionId, true);
+      if (!resp) resp = await clineFetchWithRetry(body, sessionId);
       if (!resp.ok) {
         const errText = await resp.text().catch(() => "");
         const hdrs = new Headers(resp.headers);
@@ -165,7 +145,6 @@ export function createChatService({
     const sessionId = genSessionId();
     const isStream = body?.stream === true;
     const upstreamModel = String(model).split("/").pop().includes(":") ? model : model;
-    // 构造上游 body：保留外部 model 名，Cline 上游用同名
     const upstreamBody = {
       model: upstreamModel,
       max_tokens: body?.max_tokens || body?.max_completion_tokens || 4096,
@@ -178,16 +157,11 @@ export function createChatService({
     for (const k of ["temperature", "top_p", "tools", "tool_choice", "stop", "presence_penalty", "frequency_penalty", "response_format", "user", "n", "seed"]) {
       if (body[k] !== undefined) upstreamBody[k] = body[k];
     }
-
-    // 网络层重试
     for (let netAttempt = 0; netAttempt < 3; netAttempt++) {
       try {
-        const resp = await clineFetchWithRetry(upstreamBody, sessionId, true);
+        const resp = await clineFetchWithRetry(upstreamBody, sessionId);
         if (!resp) throw new Error("empty response");
-        if (!resp.ok) {
-          // 直通错误（403/400 等）
-          return resp;
-        }
+        if (!resp.ok) return resp;
         if (isStream) return resp;
         if (forceStream) {
           const ret = await nonStreamWithContentCheck(upstreamBody, sessionId, resp);
@@ -196,7 +170,6 @@ export function createChatService({
           const hdrs = new Headers({ "Content-Type": "application/json" });
           return new Response(JSON.stringify(ret.data), { status: 200, headers: hdrs });
         }
-        // 普通非流式（非 deepseek）
         const raw = await resp.json().catch(() => null);
         if (!raw) return resp;
         const normalized = unwrapData(raw);