mslxdff 0.1.66 → 0.1.67

package/package.json

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

package/src/chat/cooling.js

@@ -0,0 +1,99 @@
+/**
+ * 冷却深模块：对 state 的 10min 冷却 + EMA 延迟做唯一封装
+ * 注入化便于单测（内存 Map + now）
+ */
+
+export function createCooling({
+  loadModelErrors,
+  saveModelErrors,
+  loadModelLatencies,
+  saveModelLatencies,
+  flush,
+  now = () => Date.now(),
+  cooldownMs = 10 * 60 * 1000,
+  slowCooldownMs = 10 * 60 * 1000,
+} = {}) {
+  const _loadErrors = loadModelErrors || (() => ({}));
+  const _saveErrors = saveModelErrors || (() => {});
+  const _loadLats = loadModelLatencies || (() => ({}));
+  const _saveLats = saveModelLatencies || (() => {});
+  const _flush = flush || (() => {});
+
+  async function isCooling(id) {
+    try {
+      const errors = _loadErrors() || {};
+      const e = errors[id];
+      if (!e || typeof e !== "object") return false;
+      const at = Number(e.at || 0);
+      if (!at) return false;
+      const isSlow = !!e.slow;
+      const cd = isSlow ? slowCooldownMs : cooldownMs;
+      return now() - at < cd && (e.status === "limit" || e.status === "error");
+    } catch {
+      return false;
+    }
+  }
+
+  async function recordError(id, status, { slow = false, latencyMs = 0 } = {}) {
+    try {
+      const errors = _loadErrors() || {};
+      const isLimit = Number(status) === 429 || String(status).includes("429");
+      const entryStatus = isLimit ? "limit" : "error";
+      errors[id] = { status: entryStatus, at: now(), code: Number.isInteger(Number(status)) ? Number(status) : null, slow: !!slow };
+      _saveErrors(errors);
+      try { _flush(); } catch {}
+      if (slow && Number.isFinite(latencyMs) && latencyMs > 0) {
+        try {
+          const lat = _loadLats() || {};
+          const prev = lat[id]?.emaMs;
+          const ema = prev ? Math.round(prev * 0.7 + latencyMs * 0.3) : Math.round(latencyMs);
+          lat[id] = { emaMs: ema, lastMs: Math.round(latencyMs), at: now(), count: (lat[id]?.count ?? 0) + 1 };
+          _saveLats(lat);
+          try { _flush(); } catch {}
+        } catch {}
+      }
+    } catch {}
+  }
+
+  async function recordOk(id, latencyMs) {
+    try {
+      const errors = _loadErrors() || {};
+      errors[id] = { status: "normal", at: now(), code: 200, slow: false };
+      _saveErrors(errors);
+      try { _flush(); } catch {}
+      if (Number.isFinite(latencyMs) && latencyMs > 0) {
+        const lat = _loadLats() || {};
+        const prev = lat[id]?.emaMs;
+        const ema = prev ? Math.round(prev * 0.7 + latencyMs * 0.3) : Math.round(latencyMs);
+        lat[id] = { emaMs: ema, lastMs: Math.round(latencyMs), at: now(), count: (lat[id]?.count ?? 0) + 1 };
+        _saveLats(lat);
+        try { _flush(); } catch {}
+      }
+    } catch {}
+  }
+
+  // 兼容旧命名
+  const recordChatError = recordError;
+  const recordChatOk = recordOk;
+  const isCoolingAsync = isCooling;
+
+  return { isCooling, isCoolingAsync, recordError, recordChatError, recordOk, recordChatOk };
+}
+
+// 默认实例（对接真实 state.js）
+let _default = null;
+export function getDefaultCooling() {
+  if (_default) return _default;
+  // 懒加载 state，避免循环
+  _default = createCooling({
+    loadModelErrors: () => {
+      try { const s = require("../state.js"); return s.loadModelErrors(); } catch { return {}; }
+    },
+    saveModelErrors: (o) => { try { const s = require("../state.js"); s.saveModelErrors(o); } catch {} },
+    loadModelLatencies: () => { try { const s = require("../state.js"); return s.loadModelLatencies(); } catch { return {}; } },
+    saveModelLatencies: (o) => { try { const s = require("../state.js"); s.saveModelLatencies(o); } catch {} },
+    flush: () => { try { const s = require("../state.js"); s.flushStateSync(); } catch {} },
+    now: () => Date.now(),
+  });
+  return _default;
+}

package/src/chat/direct.js

@@ -0,0 +1,57 @@
+import { performance } from "node:perf_hooks";
+
+function isInput400(status, msg, hasTools) {
+  return status === 400 && /prompt|messages/i.test(String(msg || "")) && hasTools;
+}
+
+/**
+ * 直连深模块：mimo/pickle 经 createUpstreamClient 的 stream:false 调用
+ * 注入化：便于用 fake client 触发 400→去 tools 重试
+ */
+export function createDirectClient({ createUpstreamClient, chatTimeoutMs = 15000, env = process.env, fetchImpl = globalThis.fetch } = {}) {
+  const _create = createUpstreamClient || (() => { throw new Error("createUpstreamClient not injected"); });
+
+  async function doChat({ messages, tools, model }, withoutTools) {
+    const prevAnon = env.MSLXDFF_FREE_ANON;
+    const needDisable = model === "mimo-v2.5-free" || model === "big-pickle";
+    if (needDisable) env.MSLXDFF_FREE_ANON = "0";
+    const client = _create({ connectTimeoutMs: chatTimeoutMs, keepAlive: false, fetchImpl });
+    const body = { model: model || "mimo-v2.5-free", messages, stream: false };
+    if (!withoutTools && tools?.length) {
+      body.tools = tools;
+      body.tool_choice = "auto";
+    }
+    try {
+      const res = await client.chat(body);
+      const txt = await res.text();
+      let j;
+      try { j = JSON.parse(txt); } catch { return { ok: false, error: `non-json upstream: ${txt.slice(0, 800)}`, status: res.status }; }
+      if (!res.ok) {
+        const msg = j?.error?.message || txt.slice(0, 800);
+        if (!withoutTools && isInput400(res.status, msg, !!tools?.length)) {
+          try { await client.close(); } catch {}
+          // 重试去 tools
+          const retry = await doChat({ messages, model }, true);
+          if (retry.ok) return { ...retry, retriedWithoutTools: true };
+          return { ok: false, error: msg, status: res.status, retried: retry.error };
+        }
+        return { ok: false, error: msg, status: res.status };
+      }
+      const choice = j.choices?.[0];
+      if (!choice) return { ok: false, error: "no choice", status: res.status };
+      return { ok: true, message: choice.message, usage: j.usage, raw: j, status: res.status };
+    } finally {
+      try { await client.close(); } catch {}
+      if (needDisable) {
+        if (prevAnon === undefined) delete env.MSLXDFF_FREE_ANON;
+        else env.MSLXDFF_FREE_ANON = prevAnon;
+      }
+    }
+  }
+
+  async function chatOnce(opts) {
+    return doChat(opts, false);
+  }
+
+  return { chatOnce, _doChat: doChat };
+}

package/src/chat/gateway.js

@@ -0,0 +1,148 @@
+import { performance } from "node:perf_hooks";
+import { parseSse } from "./sse.js";
+import { DEFAULT_PORT } from "../state.js";
+
+/**
+ * 网关深模块：POST 127.0.0.1:port/v1/chat/completions model:auto
+ * 注入化：fetch/loadToken/getPort/readModelsJson 均可伪，便于单测
+ */
+export function createGatewayClient({
+  fetchImpl = globalThis.fetch,
+  loadToken,
+  getPort,
+  defaultPort = DEFAULT_PORT,
+  readModelsJson,
+  gatewayTimeoutMs = 25000,
+  env = process.env,
+} = {}) {
+  const _fetch = fetchImpl;
+  const _loadToken = loadToken || (async () => {
+    try {
+      const state = await import("../state.js");
+      const loaded = await state.loadToken();
+      return String(loaded?.token || "").trim();
+    } catch { return ""; }
+  });
+  const _getPort = getPort || (() => {
+    try { const s = require("../state.js"); const p = s.getPort(); if (Number.isInteger(p) && p > 0) return p; } catch {}
+    const v = Number(env.MSLXDFF_PORT);
+    if (Number.isInteger(v) && v > 0) return v;
+    return defaultPort;
+  });
+  const _readModels = readModelsJson || (async () => {
+    try {
+      const { readFileSync, existsSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { homedir } = await import("node:os");
+      const cache = join(homedir(), ".config", "mslxdff", "models.json");
+      if (existsSync(cache)) return JSON.parse(readFileSync(cache, "utf8"));
+    } catch {}
+    return { data: [] };
+  });
+
+  async function chatViaGateway({ messages, tools }) {
+    const TRACE = env.MSLXDFF_CHAT_TRACE !== "0";
+    const t0 = TRACE ? performance.now() : 0;
+    let port = defaultPort;
+    let token = "";
+    try {
+      token = String((await _loadToken()) || "").trim();
+      const p = _getPort();
+      if (Number.isInteger(p) && p > 0) port = p;
+    } catch {}
+    if (!token) {
+      try {
+        const { readFileSync, existsSync } = await import("node:fs");
+        const { join } = await import("node:path");
+        const { homedir } = await import("node:os");
+        const sf = env.MSLXDFF_STATE_FILE || join(homedir(), ".config", "mslxdff", "state.json");
+        if (existsSync(sf)) {
+          const j = JSON.parse(readFileSync(sf, "utf8"));
+          if (typeof j.token === "string" && j.token.trim()) token = j.token.trim();
+        }
+      } catch {}
+    }
+    const url = `http://127.0.0.1:${port}/v1/chat/completions`;
+    const body = { model: "auto", messages, stream: false };
+    if (tools?.length) { body.tools = tools; body.tool_choice = "auto"; }
+
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), gatewayTimeoutMs);
+      const res = await _fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+      clearTimeout(timer);
+      const txt = await res.text();
+      let j;
+      try { j = JSON.parse(txt); } catch {
+        if (txt.includes("data:")) {
+          try {
+            const parsed = parseSse(txt);
+            if (parsed.sseOk && (parsed.content || parsed.toolCalls.length)) {
+              const hasToolCalls = parsed.toolCalls.length > 0;
+              const hasContent = !!parsed.content;
+              let finishReason = parsed.finishReason;
+              if (hasToolCalls && !hasContent) finishReason = "tool_calls";
+              const tool_calls = hasToolCalls ? parsed.toolCalls : undefined;
+              const msg = { role: "assistant", content: parsed.content || "" };
+              if (tool_calls) msg.tool_calls = tool_calls;
+              j = { id: `sse-${Date.now()}`, object: "chat.completion", model: parsed.model, choices: [{ index: 0, finish_reason: finishReason, message: msg }], usage: parsed.usage };
+            } else if (parsed.sseOk) {
+              return { ok: false, error: `gateway SSE no content: ${txt.slice(0, 800)}`, status: res.status };
+            } else {
+              return { ok: false, error: `gateway non-json: ${txt.slice(0, 800)}`, status: res.status };
+            }
+          } catch {
+            return { ok: false, error: `gateway non-json: ${txt.slice(0, 800)}`, status: res.status };
+          }
+        } else {
+          return { ok: false, error: `gateway non-json: ${txt.slice(0, 800)}`, status: res.status };
+        }
+      }
+      if (!res.ok) {
+        const msg = j?.error?.message || j?.error || j?.data?.error?.message || j?.data?.error || txt.slice(0, 800);
+        if (TRACE) console.log(`\x1b[90m· [LLM] gateway auto FAIL · ${Math.round(performance.now() - t0)}ms · HTTP ${res.status} ${String(msg).slice(0, 80)}\x1b[0m`);
+        return { ok: false, error: msg, status: res.status };
+      }
+      const choice = j.choices?.[0] || j.data?.choices?.[0];
+      const effectiveJ = j.choices ? j : (j.data?.choices ? j.data : j);
+      if (!choice) {
+        if (TRACE) console.log(`\x1b[90m· [gateway debug] no choice, txt=${txt.slice(0, 800)} · j=${JSON.stringify(j).slice(0, 800)}\x1b[0m`);
+        return { ok: false, error: `gateway no choice: ${txt.slice(0, 800)}`, status: res.status };
+      }
+      let provider = "opencode";
+      const rawModel = effectiveJ.model || j.model || choice.message?.model || "auto";
+      try {
+        const c = await _readModels();
+        const ids = (c.data || []).map((x) => x.id).filter(Boolean);
+        for (const pid of ids) {
+          const slash = pid.indexOf("/");
+          const prov = slash > 0 ? pid.slice(0, slash) : "opencode";
+          const raw = slash > 0 ? pid.slice(slash + 1) : pid;
+          if (pid === rawModel || raw === rawModel || pid.endsWith("/" + rawModel)) { provider = prov; break; }
+        }
+        if (provider === "opencode" && rawModel.includes("/")) {
+          const maybe = rawModel.split("/")[0];
+          if (["workbuddy", "clinebot", "sensenova", "openrouter", "generic"].includes(maybe)) provider = maybe;
+        }
+      } catch {}
+      if (TRACE) {
+        const dt = Math.round(performance.now() - t0);
+        console.log(`\x1b[90m· [LLM] gateway auto OK · ${dt}ms · 模型 ${provider !== "opencode" ? provider + "/" : ""}${rawModel} · 总 ${dt}ms (gateway-fallback)\x1b[0m`);
+      }
+      return { ok: true, message: choice.message, usage: effectiveJ.usage || j.usage, raw: j, status: res.status, model: rawModel, provider, viaGateway: true };
+    } catch (err) {
+      const msg = String(err?.message || err).slice(0, 800);
+      if (env.MSLXDFF_CHAT_TRACE !== "0") {
+        const dt2 = performance.now() - (performance.now() - 0); // placeholder, TRACE off in tests
+      }
+      return { ok: false, error: `gateway ${msg}`, status: 502 };
+    }
+  }
+
+  return { chatViaGateway };
+}

package/src/chat/orchestrator.js

@@ -0,0 +1,218 @@
+import { performance as nodePerf } from "node:perf_hooks";
+
+const ORIG_PREFERRED = "mimo-v2.5-free";
+const ORIG_FALLBACK = "big-pickle";
+
+/**
+ * 编排深模块：mimo → pickle → gateway 三级降级 + 800ms 对冲
+ * 注入化：chatOnce / chatViaGateway / cooling / config / env / performance
+ */
+export function createOrchestrator({
+  chatOnce,
+  chatViaGateway,
+  cooling,
+  config = {},
+  env = process.env,
+  performance: perf = nodePerf,
+  chatWithFallbackImpl,
+} = {}) {
+  const CHAT_PREFERRED = config.CHAT_PREFERRED || ORIG_PREFERRED;
+  const CHAT_FALLBACK = config.CHAT_FALLBACK || ORIG_FALLBACK;
+  const CHAT_GATEWAY_TIMEOUT_MS = config.CHAT_GATEWAY_TIMEOUT_MS || 25000;
+  const CHAT_COOLDOWN_MS = 10 * 60 * 1000;
+  const CHAT_SLOW_COOLDOWN_MS = 10 * 60 * 1000;
+
+  const _chatOnce = chatOnce || (async () => ({ ok: false, error: "no chatOnce", status: 500 }));
+  const _gateway = chatViaGateway || (async () => ({ ok: false, error: "no gateway", status: 500 }));
+  const _cooling = cooling || {
+    isCooling: async () => false,
+    recordError: async () => {},
+    recordOk: async () => {},
+  };
+
+  async function isCoolingAsync(id) {
+    try { return await _cooling.isCooling(id); } catch { return false; }
+  }
+  async function recordChatError(id, status, opts) {
+    try { await _cooling.recordError(id, status, opts); } catch {}
+  }
+  async function recordChatOk(id, latencyMs) {
+    try { await _cooling.recordOk(id, latencyMs); } catch {}
+  }
+
+  async function safeChatOnce(opts, model) {
+    try {
+      const r = await _chatOnce({ ...opts, model });
+      return r;
+    } catch (err) {
+      const msg = String(err?.message || err).slice(0, 800);
+      const status = err?._t ? 502 : 502;
+      return { ok: false, error: msg, status, _thrown: err };
+    }
+  }
+
+  async function chatWithFallback(opts) {
+    if (chatWithFallbackImpl) return chatWithFallbackImpl(opts);
+    const TRACE = env.MSLXDFF_CHAT_TRACE !== "0";
+    const HEDGE_MS = (() => {
+      const v = Number(env.MSLXDFF_HEDGE_DELAY_MS);
+      return Number.isInteger(v) && v >= 0 ? v : 800;
+    })();
+    const t0 = TRACE ? perf.now() : 0;
+
+    const firstCooling = await isCoolingAsync(CHAT_PREFERRED);
+    let first;
+    let firstMs = 0;
+    if (firstCooling) {
+      if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} 跳过（冷却中）· 直接试 ${CHAT_FALLBACK}\x1b[0m`);
+      first = { ok: false, error: "skip cooling", status: 429 };
+    } else {
+      const t = perf.now();
+      first = await safeChatOnce(opts, CHAT_PREFERRED);
+      firstMs = Math.round(perf.now() - t);
+      if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} ${first.ok ? "OK" : "FAIL"} · ${Math.round(perf.now() - t0)}ms${first.ok ? "" : ` · ${String(first.error).slice(0, 80)}`}\x1b[0m`);
+      if (first.ok) {
+        await recordChatOk(CHAT_PREFERRED, firstMs);
+        return { ...first, model: CHAT_PREFERRED };
+      } else {
+        const slow = firstMs > 20000;
+        await recordChatError(CHAT_PREFERRED, first.status, { slow, latencyMs: firstMs });
+      }
+    }
+
+    if (firstCooling) {
+      if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} 冷却中（${CHAT_COOLDOWN_MS / 60000}min）· 直接走网关 auto，跳过 ${CHAT_FALLBACK}\x1b[0m`);
+      if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} 冷却，直接走网关 auto（:8989）\x1b[0m`);
+      const t2 = TRACE ? perf.now() : 0;
+      const third = await _gateway(opts);
+      if (TRACE) console.log(`\x1b[90m· [LLM] gateway auto ${third.ok ? "OK" : "FAIL"} · ${Math.round(perf.now() - t2)}ms · 总 ${Math.round(perf.now() - t0)}ms (gateway-fallback)\x1b[0m`);
+      if (third.ok) return { ...third, model: third.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: "skip big-pickle (mimo cooling)", viaGateway: true };
+      return { ok: false, error: `${CHAT_PREFERRED} cooling: ${first.error}; gateway auto failed: ${third.error}`, status: third.status || 429 };
+    }
+
+    const secondCooling = await isCoolingAsync(CHAT_FALLBACK);
+    const doGateway = () => _gateway(opts);
+    const doSecond = async () => {
+      const t = perf.now();
+      const r = await safeChatOnce(opts, CHAT_FALLBACK);
+      const ms = Math.round(perf.now() - t);
+      if (r.ok) await recordChatOk(CHAT_FALLBACK, ms);
+      else await recordChatError(CHAT_FALLBACK, r.status, { slow: ms > 20000, latencyMs: ms });
+      return { res: r, ms };
+    };
+
+    if (secondCooling) {
+      if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_FALLBACK} 跳过（冷却中）· 直接走网关 auto\x1b[0m`);
+      const t2 = perf.now();
+      const third = await doGateway();
+      if (TRACE) console.log(`\x1b[90m· [LLM] gateway auto ${third.ok ? "OK" : "FAIL"} · ${Math.round(perf.now() - t2)}ms · 总 ${Math.round(perf.now() - t0)}ms (gateway-fallback)\x1b[0m`);
+      if (third.ok) return { ...third, model: third.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: "skip cooling", viaGateway: true };
+      return { ok: false, error: `${CHAT_PREFERRED} failed: ${first.error}; ${CHAT_FALLBACK} failed: skip cooling; gateway auto failed: ${third.error}`, status: third.status || first.status };
+    }
+
+    if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} 失败，${CHAT_FALLBACK} + gateway 对冲中（${HEDGE_MS}ms）\x1b[0m`);
+    const t1 = TRACE ? perf.now() : 0;
+    let secondRes = null;
+    let secondMs = 0;
+    let gatewayRes = null;
+
+    const secondPromise = doSecond().then(({ res, ms }) => {
+      secondRes = res; secondMs = ms;
+      if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_FALLBACK} ${res.ok ? "OK" : "FAIL"} · ${Math.round(perf.now() - t1)}ms · 总 ${Math.round(perf.now() - t0)}ms (hedge)\x1b[0m`);
+      return res;
+    });
+
+    let gatewayPromise = null;
+    const gatewayDelay = HEDGE_MS > 0 ? HEDGE_MS : 0;
+    if (gatewayDelay > 0) {
+      gatewayPromise = new Promise((resolve) => {
+        setTimeout(async () => {
+          const r = await doGateway();
+          gatewayRes = r;
+          resolve(r);
+        }, gatewayDelay);
+      });
+    } else {
+      gatewayPromise = doGateway().then((r) => { gatewayRes = r; return r; });
+    }
+
+    const raceFirstOk = async () => {
+      const secondOrTimeout = await Promise.race([
+        secondPromise.then((r) => ({ kind: "second", r })),
+        new Promise((resolve) => setTimeout(() => resolve({ kind: "timeout" }), gatewayDelay)),
+      ]);
+      if (secondOrTimeout.kind === "second" && secondOrTimeout.r?.ok) {
+        return { ok: true, res: secondOrTimeout.r, model: CHAT_FALLBACK, fallback: true, firstError: first.error };
+      }
+      if (!gatewayPromise || secondOrTimeout.kind === "timeout") {
+        const immediate = doGateway().then((r) => { gatewayRes = r; return r; });
+        if (gatewayPromise) {
+          gatewayRes = await Promise.race([gatewayPromise, immediate]);
+        } else {
+          gatewayRes = await immediate;
+        }
+      } else {
+        gatewayRes = await gatewayPromise;
+      }
+      if (gatewayRes?.ok) return { ok: true, res: gatewayRes, model: gatewayRes.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: secondRes?.error, viaGateway: true };
+      if (secondRes?.ok) return { ok: true, res: secondRes, model: CHAT_FALLBACK, fallback: true, firstError: first.error };
+      return { ok: false, gatewayRes, secondRes };
+    };
+
+    if (gatewayDelay === 0) {
+      const [sRes, gRes] = await Promise.all([
+        secondPromise.catch((e) => ({ ok: false, error: String(e), status: 502 })),
+        doGateway().catch((e) => ({ ok: false, error: String(e), status: 502 })),
+      ]);
+      secondRes = sRes; gatewayRes = gRes;
+      if (sRes?.ok) return { ...sRes, model: CHAT_FALLBACK, fallback: true, firstError: first.error };
+      if (gRes?.ok) return { ...gRes, model: gRes.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: sRes?.error, viaGateway: true };
+      return { ok: false, error: `${CHAT_PREFERRED} failed: ${first.error}; ${CHAT_FALLBACK} failed: ${sRes?.error}; gateway auto failed: ${gRes?.error}`, status: gRes?.status || sRes?.status || first.status };
+    }
+
+    const raced = await raceFirstOk();
+    if (raced.ok) {
+      const r = raced.res;
+      return { ...r, model: raced.model, fallback: raced.fallback, fallbackGateway: raced.fallbackGateway, firstError: raced.firstError, secondError: raced.secondError, viaGateway: raced.viaGateway };
+    }
+    if (!secondRes) {
+      try { secondRes = await secondPromise; } catch (e) { secondRes = { ok: false, error: String(e), status: 502 }; }
+    }
+    if (secondRes?.ok) return { ...secondRes, model: CHAT_FALLBACK, fallback: true, firstError: first.error };
+    if (!gatewayRes) {
+      try { gatewayRes = await (gatewayPromise || doGateway()); } catch (e) { gatewayRes = { ok: false, error: String(e), status: 502 }; }
+    }
+    if (gatewayRes?.ok) return { ...gatewayRes, model: gatewayRes.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: secondRes?.error, viaGateway: true };
+    return { ok: false, error: `${CHAT_PREFERRED} failed: ${first.error}; ${CHAT_FALLBACK} failed: ${secondRes?.error}; gateway auto failed: ${gatewayRes?.error}`, status: gatewayRes?.status || secondRes?.status || first.status };
+  }
+
+  async function summarizeHistory(messages) {
+    const prompt = [
+      { role: "system", content: "你是对话压缩助手，把以下历史对话压缩成 800 字以内的中文摘要，保留关键操作与结果、用户的偏好与待办、模型设置与群组操作及时间线，不要遗漏重要细节。" },
+      { role: "user", content: messages.map((m) => `${m.role}: ${m.content || JSON.stringify(m.tool_calls || "")}`).join("\n").slice(0, 90000) },
+    ];
+    const r = await chatWithFallback({ messages: prompt });
+    if (!r.ok) return null;
+    const txt = String(r.message?.content || "").trim();
+    return txt ? `【历史摘要】${txt}` : null;
+  }
+
+  // 兼容测试的额外覆盖参数
+  if (chatWithFallbackImpl) {
+    const orig = chatWithFallback;
+    // 允许测试覆盖 summarize 内部的 chatWithFallback
+    const wrapped = async (opts) => chatWithFallbackImpl(opts);
+    return { chatWithFallback: wrapped, summarizeHistory: async (msgs) => {
+      const prompt = [
+        { role: "system", content: "你是对话压缩助手，把以下历史对话压缩成 800 字以内的中文摘要，保留关键操作与结果、用户的偏好与待办、模型设置与群组操作及时间线，不要遗漏重要细节。" },
+        { role: "user", content: msgs.map((m) => `${m.role}: ${m.content || JSON.stringify(m.tool_calls || "")}`).join("\n").slice(0, 90000) },
+      ];
+      const r = await wrapped({ messages: prompt });
+      if (!r.ok) return null;
+      const txt = String(r.message?.content || "").trim();
+      return txt ? `【历史摘要】${txt}` : null;
+    } };
+  }
+
+  return { chatWithFallback, summarizeHistory };
+}

package/src/chat/sse.js

@@ -0,0 +1,69 @@
+/**
+ * SSE 聚合深模块：把网关可能返回的 text/event-stream 聚合为单次 JSON 形状
+ * 纯函数，便于单测；与 gateway.js 共享
+ */
+export function parseSse(text) {
+  const lines = String(text || "").split(/\r?\n/);
+  let content = "";
+  const toolCallsMap = new Map();
+  let model = "auto";
+  let usage = null;
+  let finishReason = "stop";
+  let sseOk = false;
+
+  for (const line of lines) {
+    const t = String(line).trim();
+    if (!t.startsWith("data:")) continue;
+    const payload = t.slice(5).trim();
+    if (!payload || payload === "[DONE]") continue;
+    try {
+      const obj = JSON.parse(payload);
+      sseOk = true;
+      const ch = obj.choices?.[0];
+      if (ch?.finish_reason) finishReason = ch.finish_reason;
+      if (ch?.delta?.content) content += ch.delta.content;
+      else if (ch?.delta?.reasoning_content) content += ch.delta.reasoning_content;
+      else if (ch?.message?.content) content += ch.message.content;
+      else if (ch?.message?.reasoning_content) content += ch.message.reasoning_content;
+      else if (typeof ch?.text === "string") content += ch.text;
+      else if (typeof obj.content === "string") content += obj.content;
+
+      if (ch?.delta?.tool_calls) {
+        for (const tc of ch.delta.tool_calls) {
+          const idx = tc.index ?? 0;
+          const cur = toolCallsMap.get(idx) || { id: tc.id || `chatcmpl-tool-${idx}`, type: tc.type || "function", function: { name: "", arguments: "" } };
+          if (tc.id) cur.id = tc.id;
+          if (tc.type) cur.type = tc.type;
+          if (tc.function?.name) cur.function.name = tc.function.name;
+          if (typeof tc.function?.arguments === "string") cur.function.arguments += tc.function.arguments;
+          toolCallsMap.set(idx, cur);
+        }
+      }
+      if (ch?.message?.tool_calls) {
+        for (const tc of ch.message.tool_calls) {
+          const idx = tc.index ?? toolCallsMap.size;
+          toolCallsMap.set(idx, tc);
+        }
+      }
+      if (obj.model) model = obj.model;
+      if (obj.usage) usage = obj.usage;
+      if (obj.choices?.[0]?.message?.content && !content) content = obj.choices[0].message.content;
+      if (obj.choices?.[0]?.message?.reasoning_content && !content) content = obj.choices[0].message.reasoning_content;
+      if (obj.choices?.[0]?.message?.tool_calls && toolCallsMap.size === 0) {
+        for (const tc of obj.choices[0].message.tool_calls) toolCallsMap.set(tc.index ?? 0, tc);
+      }
+    } catch {}
+  }
+
+  const toolCalls = [...toolCallsMap.values()].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+  return { content, toolCalls, model, usage, finishReason, sseOk };
+}
+
+export function sseToMessage(parsed, { hasContent, hasToolCalls } = {}) {
+  const hc = hasContent ?? !!parsed.content;
+  const ht = hasToolCalls ?? parsed.toolCalls.length > 0;
+  if (!parsed.sseOk || (!hc && !ht)) return null;
+  const msg = { role: "assistant", content: parsed.content || "" };
+  if (ht) msg.tool_calls = parsed.toolCalls;
+  return msg;
+}