mslxdff 0.1.87 → 0.1.89

package/src/runtime/bootstrap.js

@@ -316,6 +316,44 @@ export async function startDaemonMain(VERSION) {
 
   const broadbandGroups = () => loadGroupsJoined().filter((g) => g.kind === "broadband" && g.leaderUrl);
   if (broadbandGroups().length) {
+    const streamEnabled = (() => {
+      const v = process.env.MSLXDFF_BROADBAND_STREAM;
+      if (v === "0" || v === "false" || v === "off") return false;
+      return true;
+    })();
+    const execAndPost = async (g, reqId, body) => {
+          let result;
+      try {
+        const upRes = await upstream.chat(body);
+        const ct = upRes.headers.get("content-type") || "";
+        const isStream = Boolean(body?.stream) || ct.includes("text/event-stream");
+        if (isStream && upRes.body) {
+          let collected = "";
+          for await (const chunk of upRes.body) {
+            if (typeof chunk === "string") collected += chunk;
+            else if (Buffer.isBuffer(chunk)) collected += chunk.toString("utf8");
+            else if (chunk instanceof Uint8Array) collected += Buffer.from(chunk).toString("utf8");
+            else collected += String(chunk);
+          }
+          result = { status: upRes.status, headers: { "Content-Type": "text/event-stream" }, body: collected };
+        } else {
+          const txt = await upRes.text();
+          let parsed;
+          try { parsed = JSON.parse(txt); } catch { parsed = txt; }
+          result = { status: upRes.status, headers: { "Content-Type": upRes.headers.get("content-type") || "application/json" }, body: typeof parsed === "string" ? parsed : JSON.stringify(parsed) };
+        }
+      } catch (err) {
+        result = { status: 502, headers: { "Content-Type": "application/json" }, body: JSON.stringify({ error: errMsg(err) }) };
+      }
+      try {
+        await fetch(`${g.leaderUrl}/v1/groups/relay/result`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}` },
+          body: JSON.stringify({ name: g.name, group: g.name, reqId, result }),
+          signal: AbortSignal.timeout(5000),
+        });
+      } catch {}
+    };
     const doHeartbeat = async () => {
       for (const g of broadbandGroups()) {
         try {
@@ -348,44 +386,88 @@ export async function startDaemonMain(VERSION) {
           const items = data.data || [];
           for (const item of items) {
             const { reqId, body } = item;
-            let result;
-            try {
-              const upRes = await upstream.chat(body);
-              const ct = upRes.headers.get("content-type") || "";
-              const isStream = Boolean(body?.stream) || ct.includes("text/event-stream");
-              if (isStream && upRes.body) {
-                let collected = "";
-                for await (const chunk of upRes.body) {
-                  collected += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
-                }
-                result = { status: upRes.status, headers: { "Content-Type": "text/event-stream" }, body: collected };
-              } else {
-                const txt = await upRes.text();
-                let parsed;
-                try { parsed = JSON.parse(txt); } catch { parsed = txt; }
-                result = { status: upRes.status, headers: { "Content-Type": upRes.headers.get("content-type") || "application/json" }, body: typeof parsed === "string" ? parsed : JSON.stringify(parsed) };
-              }
-            } catch (err) {
-              result = { status: 502, headers: { "Content-Type": "application/json" }, body: JSON.stringify({ error: errMsg(err) }) };
-            }
-            try {
-              await fetch(`${g.leaderUrl}/v1/groups/relay/result`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}` },
-                body: JSON.stringify({ name: g.name, group: g.name, reqId, result }),
-                signal: AbortSignal.timeout(5000),
-              });
-            } catch {}
+            await execAndPost(g, reqId, body);
           }
         } catch {}
       }
     };
-    doHeartbeat().catch(() => {});
-    const hbTimer = setInterval(doHeartbeat, 30_000);
-    hbTimer.unref();
-    const pollTimer = setInterval(doPoll, 1000);
-    pollTimer.unref();
-    console.log(`broadband relay: heartbeat 30s + poll 1s for ${broadbandGroups().length} group(s)`);
+    if (!streamEnabled) {
+      doHeartbeat().catch(() => {});
+      const hbTimer = setInterval(doHeartbeat, 30_000);
+      hbTimer.unref();
+      const pollTimer = setInterval(doPoll, 1000);
+      pollTimer.unref();
+      console.log(`broadband relay: heartbeat 30s + poll 1s for ${broadbandGroups().length} group(s) [poll mode]`);
+    } else {
+      const streamManagers = new Map();
+      const startStreamForGroup = (g) => {
+        if (streamManagers.has(g.name)) return;
+        let attempts = 0;
+        let abort = null;
+        let stopped = false;
+        const connect = async () => {
+          if (stopped) return;
+          const url = `${g.leaderUrl}/v1/groups/relay/stream?name=${encodeURIComponent(g.name)}`;
+          const controller = new AbortController();
+          abort = controller;
+          try {
+            const res = await fetch(url, {
+              headers: { Authorization: `Bearer ${token}`, Accept: "text/event-stream" },
+              signal: controller.signal,
+            });
+            if (!res.ok) throw new Error(`stream ${res.status}`);
+            if (!res.body) throw new Error("no body");
+            attempts = 0;
+            let buf = "";
+            const decodeChunk = (c) => {
+              if (typeof c === "string") return c;
+              if (Buffer.isBuffer(c)) return c.toString("utf8");
+              if (c instanceof Uint8Array) return Buffer.from(c).toString("utf8");
+              return String(c);
+            };
+            for await (const chunk of res.body) {
+              buf += decodeChunk(chunk);
+              let idx;
+              while ((idx = buf.indexOf("\n\n")) >= 0) {
+                const raw = buf.slice(0, idx);
+                buf = buf.slice(idx + 2);
+                if (!raw || raw.startsWith(":")) continue;
+                let event = "message";
+                let data = "";
+                for (const line of raw.split("\n")) {
+                  if (line.startsWith("event:")) event = line.slice(6).trim();
+                  else if (line.startsWith("data:")) data += line.slice(5).trim();
+                }
+                if (event === "relay" && data) {
+                  try {
+                    const parsed = JSON.parse(data);
+                    const { reqId, body } = parsed;
+                    if (reqId && body) execAndPost(g, reqId, body).catch(() => {});
+                  } catch {}
+                }
+              }
+            }
+            throw new Error("stream ended");
+          } catch (err) {
+            if (stopped) return;
+            const msg = errMsg(err);
+            if (!String(msg).includes("abort") && !String(msg).includes("Abort")) console.log(`broadband stream ${g.name}: ${msg} — reconnecting`);
+            attempts++;
+            const delay = Math.min(30_000, 1000 * Math.pow(2, attempts - 1) + Math.random() * 500);
+            await new Promise((r) => setTimeout(r, delay));
+            connect();
+          }
+        };
+        streamManagers.set(g.name, { stop: () => { stopped = true; abort?.abort(); } });
+        connect();
+      };
+      for (const g of broadbandGroups()) startStreamForGroup(g);
+      const ensureTimer = setInterval(() => {
+        for (const g of broadbandGroups()) if (!streamManagers.has(g.name)) startStreamForGroup(g);
+      }, 10_000);
+      ensureTimer.unref();
+      console.log(`broadband relay: stream (SSE) + ping 25s for ${broadbandGroups().length} group(s)`);
+    }
   }
 
   const { setupAutoUpdate } = await import("./auto-update.js");

package/src/transport/index.js

@@ -0,0 +1,248 @@
+import { performance } from "node:perf_hooks";
+import { resolveRetry, sleep, backoffDelay } from "./retry.js";
+import { createSseParser } from "./sse.js";
+import { createPool } from "./pool.js";
+
+let UndiciFetch = null;
+try {
+  const mod = await import("undici");
+  UndiciFetch = mod.fetch;
+} catch {}
+
+const DEFAULT_RETRY = {
+  network: { attempts: 2, delayMs: 300 },
+  429: { attempts: 1, delayMs: 100 },
+  502: { attempts: 1, delayMs: 100 },
+  503: { attempts: 1, delayMs: 100 },
+  504: { attempts: 1, delayMs: 100 },
+};
+
+export function createTransport({
+  baseUrl,
+  headers: baseHeaders = {},
+  keepAlive = true,
+  fetchImpl,
+  dispatcher: extDispatcher,
+  timeoutMs: defaultTimeoutMs = 30_000,
+  retry: defaultRetry = DEFAULT_RETRY,
+  hooks,
+} = {}) {
+  if (!fetchImpl) fetchImpl = UndiciFetch || globalThis.fetch;
+  const pool = keepAlive && !extDispatcher ? createPool({ keepAlive }) : null;
+  const getDispatcher = () => extDispatcher || pool?.dispatcher || null;
+
+  let closed = false;
+
+  function resolveUrl(url) {
+    if (!url) return baseUrl || "";
+    if (/^https?:\/\//i.test(url)) return url;
+    if (!baseUrl) return url;
+    return `${String(baseUrl).replace(/\/+$/, "")}/${String(url).replace(/^\/+/, "")}`;
+  }
+
+  async function applyHooks(name, ctx) {
+    if (!hooks) return null;
+    try { return await hooks(name, ctx); } catch { return null; }
+  }
+
+  async function request({
+    url,
+    method = "POST",
+    headers = {},
+    body,
+    stream,
+    timeoutMs,
+    retry,
+    dispatcher,
+  } = {}) {
+    const finalUrl = resolveUrl(url);
+    const retryCfg = retry ?? defaultRetry;
+    const timeout = Number(timeoutMs ?? defaultTimeoutMs) || 30_000;
+    const disp = dispatcher ?? getDispatcher();
+    const t0 = performance.now();
+    const attempts = [];
+    let waitMs = 0;
+
+    // 合并 headers
+    const finalHeaders = { ...baseHeaders, ...headers };
+    if (body != null && !finalHeaders["Content-Type"] && !finalHeaders["content-type"]) {
+      finalHeaders["Content-Type"] = "application/json";
+    }
+    if (stream && !finalHeaders["Accept"] && !finalHeaders["accept"]) {
+      finalHeaders["Accept"] = "text/event-stream";
+    }
+
+    const bodyStr = body != null && typeof body !== "string" ? JSON.stringify(body) : body;
+
+    for (let attempt = 0; ; attempt++) {
+      const tAttempt = performance.now();
+      let res;
+      let err = null;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(new Error(`upstream timed out after ${timeout}ms`)), timeout);
+      try {
+        let reqUrl = finalUrl;
+        let reqHeaders = { ...finalHeaders };
+        // hooks
+        const hh = await applyHooks("upstream:headers", { url: reqUrl, body, headers: reqHeaders });
+        if (hh?.changed && hh.value?.headers) reqHeaders = hh.value.headers;
+        const br = await applyHooks("upstream:before-request", { url: reqUrl, method, body, headers: reqHeaders });
+        if (br?.changed && br.value) {
+          if (typeof br.value.url === "string" && br.value.url) reqUrl = br.value.url;
+          if (br.value.headers && typeof br.value.headers === "object") reqHeaders = br.value.headers;
+        }
+        const opts = { method, headers: reqHeaders, body: bodyStr, signal: controller.signal };
+        if (disp) opts.dispatcher = disp;
+        res = await fetchImpl(reqUrl, opts);
+      } catch (e) {
+        err = e;
+      } finally {
+        clearTimeout(timer);
+      }
+      const ms = Math.round(performance.now() - tAttempt);
+
+      if (err) {
+        attempts.push({ type: "network", ms });
+        const { shouldRetry, delayMs } = resolveRetry("network", attempt, retryCfg);
+        if (shouldRetry) {
+          await sleep(delayMs);
+          waitMs += delayMs;
+          continue;
+        }
+        err._t = { attempts, waitMs, totalMs: Math.round(performance.now() - t0) };
+        throw err;
+      }
+
+      // http
+      attempts.push({ type: `http${res.status}`, ms });
+      const { shouldRetry, delayMs } = resolveRetry(res.status, attempt, retryCfg);
+      if (shouldRetry) {
+        // 消耗 body 以释放连接
+        try { if (res.body) await res.text().catch(() => {}); } catch {}
+        await sleep(delayMs);
+        waitMs += delayMs;
+        continue;
+      }
+
+      const ttfbMs = Math.round(performance.now() - t0);
+      const isStreamRequested = stream === true;
+      const contentType = res.headers.get("content-type") || "";
+      // 若请求为 stream 但上游返回的是 JSON（测试桩常见），则回退为非流式处理，避免 SSE 空聚合
+      const isStream = isStreamRequested && contentType.includes("text/event-stream");
+      if (!isStream) {
+        // 非流式：预读 body 以得 totalMs 与缓存（兼容 stream:true 但返回 JSON 的桩）
+        let cachedText = "";
+        let readMs = ttfbMs;
+        try {
+          cachedText = await res.text();
+          readMs = Math.round(performance.now() - t0);
+        } catch {
+          cachedText = "";
+          readMs = ttfbMs;
+        }
+        const totalMs = readMs;
+        const headers = res.headers;
+        return {
+          status: res.status,
+          headers,
+          ok: res.ok,
+          ttfbMs,
+          totalMs,
+          _t: { attempts, waitMs, totalMs },
+          async json() { try { return JSON.parse(cachedText); } catch { return cachedText; } },
+          async text() { return cachedText; },
+          stream() { throw new Error("not-streaming: call with stream:true"); },
+          get body() { return null; },
+        };
+      } else {
+        // 流式：保留原始 res 用于 stream()
+        const headers = res.headers;
+        let firstTtfb = ttfbMs; // 更新为首事件到达时刻（测得即所得）
+        let firstDone = false;
+        let lastRead = ttfbMs;
+        const markFirst = () => {
+          if (!firstDone) { firstTtfb = Math.round(performance.now() - t0); firstDone = true; }
+        };
+        let _t = { attempts, waitMs, totalMs: ttfbMs };
+        return {
+          status: res.status,
+          headers,
+          ok: res.ok,
+          get ttfbMs() { return firstDone ? firstTtfb : ttfbMs; },
+          get totalMs() { return lastRead; },
+          get _t() { return _t; },
+          set _t(v) { _t = v; },
+          async json() {
+            let acc = "";
+            for await (const chunk of this.stream()) acc += chunk;
+            try { return JSON.parse(acc); } catch { return acc; }
+          },
+          async text() {
+            let acc = "";
+            for await (const chunk of this.stream()) acc += chunk;
+            return acc;
+          },
+          get body() { return res.body; },
+          async *stream() {
+            const parser = createSseParser();
+            if (res.body && typeof res.body.getReader === "function") {
+              const reader = res.body.getReader();
+              const decoder = new TextDecoder();
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                lastRead = Math.round(performance.now() - t0);
+                try { _t.totalMs = lastRead; } catch {}
+                const text = decoder.decode(value, { stream: true });
+                const evs = parser.push(text);
+                for (const e of evs) {
+                  if (e === "[DONE]") return;
+                  if (e === "") continue;
+                  markFirst();
+                  yield e;
+                }
+              }
+            } else if (typeof res.text === "function") {
+              const txt = await res.text();
+              const evs = parser.push(txt);
+              for (const e of evs) {
+                if (e === "[DONE]") return;
+                if (e === "") continue;
+                markFirst();
+                yield e;
+              }
+            }
+          },
+        };
+      }
+    }
+  }
+
+  async function preheat(url) {
+    const target = url || (baseUrl ? `${String(baseUrl).replace(/\/+$/, "")}/zen/v1/models` : null);
+    if (!target) return { ok: false, skipped: true };
+    const t0 = performance.now();
+    try {
+      const res = await request({ url: target, method: "GET", stream: false, timeoutMs: 3000 });
+      try { if (res.text) await res.text().catch(() => {}); } catch {}
+      return { ok: res.ok, status: res.status, ms: Math.round(performance.now() - t0) };
+    } catch (e) {
+      return { ok: false, error: String(e?.message || e), ms: Math.round(performance.now() - t0) };
+    }
+  }
+
+  async function close() {
+    if (closed) return;
+    closed = true;
+    if (pool) await pool.close();
+  }
+
+  return {
+    request,
+    preheat,
+    close,
+    get dispatcher() { return getDispatcher(); },
+    get agent() { return pool?.agent || null; },
+    [Symbol.asyncDispose]: close,
+  };
+}

package/src/transport/pool.js

@@ -0,0 +1,60 @@
+let UndiciAgent = null;
+try {
+  const mod = await import("undici");
+  UndiciAgent = mod.Agent;
+} catch {
+  UndiciAgent = null;
+}
+
+function envInt(name, fallback) {
+  const v = Number(process.env[name]);
+  return Number.isInteger(v) && v > 0 ? v : fallback;
+}
+
+export function createPool({
+  keepAlive = true,
+  keepAliveTimeout,
+  keepAliveMaxTimeout,
+  connections,
+} = {}) {
+  const keepAliveTimeoutMs = keepAliveTimeout ?? envInt("MSLXDFF_UPSTREAM_KEEPALIVE_TIMEOUT", 30_000);
+  const keepAliveMaxTimeoutMs = keepAliveMaxTimeout ?? envInt("MSLXDFF_UPSTREAM_KEEPALIVE_MAX_TIMEOUT", 60_000);
+  const keepAliveConnections = connections ?? envInt("MSLXDFF_UPSTREAM_KEEPALIVE_CONNECTIONS", 20);
+
+  let agent = null;
+  let dispatcher = null;
+  let closed = false;
+
+  if (keepAlive && UndiciAgent) {
+    try {
+      agent = new UndiciAgent({
+        keepAliveTimeout: keepAliveTimeoutMs,
+        keepAliveMaxTimeout: keepAliveMaxTimeoutMs,
+        connections: keepAliveConnections,
+        pipelining: 1,
+      });
+      dispatcher = agent;
+    } catch {
+      agent = null;
+      dispatcher = null;
+    }
+  }
+
+  async function close() {
+    if (closed) return;
+    closed = true;
+    if (agent && typeof agent.close === "function") {
+      try { await agent.close(); } catch {}
+    } else if (dispatcher && typeof dispatcher.close === "function" && dispatcher !== agent) {
+      try { await dispatcher.close(); } catch {}
+    }
+  }
+
+  return {
+    get dispatcher() { return dispatcher; },
+    get agent() { return agent; },
+    get closed() { return closed; },
+    close,
+    [Symbol.asyncDispose]: close,
+  };
+}

package/src/transport/retry.js

@@ -0,0 +1,24 @@
+export function backoffDelay(baseMs, attempt) {
+  // attempt 0 => base, 1 => base*2, 2 => base*4
+  return baseMs * (1 << attempt);
+}
+
+export function resolveRetry(status, attempt, config) {
+  const key = status === "network" ? "network" : String(status);
+  const entry = config?.[key];
+  if (!entry) return { shouldRetry: false, delayMs: 0 };
+  const attempts = Number(entry.attempts) || 0;
+  const base = Number(entry.delayMs) || 0;
+  if (attempt < attempts) {
+    return { shouldRetry: true, delayMs: backoffDelay(base, attempt) };
+  }
+  return { shouldRetry: false, delayMs: 0 };
+}
+
+export function shouldRetry(status, attempt, config) {
+  return resolveRetry(status, attempt, config).shouldRetry;
+}
+
+export function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}

package/src/transport/sse.js

@@ -0,0 +1,93 @@
+/**
+ * SSE 行协议深模块 — 纯函数 + 流式
+ * 负责 `data: / : / event: / [DONE]` 的解析与粘包 remain 处理
+ */
+
+export function parseSseChunk(buf) {
+  const events = [];
+  let remain = String(buf || "");
+  // 按 \n\n 分帧，\r\n 也兼容
+  // 保留最后一帧若不以 \n\n 结尾则为 remain
+  const normalized = remain.replace(/\r\n/g, "\n");
+  const parts = normalized.split("\n\n");
+  // 最后一部分若原串不以 \n\n 结尾则为 remain
+  const endsWithDelim = normalized.endsWith("\n\n") || normalized.endsWith("\n\r\n");
+  // parts 最后一项在非结尾时为未完成帧
+  const complete = endsWithDelim ? parts : parts.slice(0, -1);
+  remain = endsWithDelim ? "" : parts[parts.length - 1] || "";
+  for (const frame of complete) {
+    if (!frame) continue; // 空帧
+    const lines = frame.split("\n");
+    const dataLines = [];
+    for (const line of lines) {
+      if (!line) continue;
+      if (line.startsWith(":")) continue; // 注释/keepalive
+      if (line.startsWith("event:")) continue; // 事件类型忽略
+      if (line.startsWith("data:")) {
+        let v = line.slice(5);
+        if (v.startsWith(" ")) v = v.slice(1);
+        dataLines.push(v);
+      }
+    }
+    if (dataLines.length === 0) continue;
+    // 多行 data 按 \n 拼接（SSE 规范）
+    const payload = dataLines.join("\n");
+    // 空 data: 仍产生事件，由上层过滤；此处保留以便测试可见
+    events.push(payload);
+  }
+  return { events, remain };
+}
+
+export function createSseParser() {
+  let buf = "";
+  return {
+    push(chunk) {
+      buf += String(chunk || "");
+      const { events, remain } = parseSseChunk(buf);
+      buf = remain;
+      return events;
+    },
+    flush() {
+      // 未形成完整帧的不发（避免半包误触发）
+      if (!buf.trim()) { buf = ""; return []; }
+      // 若残留包含完整 data: 行但缺结尾，不强行发
+      return [];
+    },
+    getRemain() { return buf; },
+  };
+}
+
+export async function* streamFromResponse(res) {
+  if (!res || !res.body) return;
+  const parser = createSseParser();
+  const reader = res.body.getReader ? res.body.getReader() : null;
+  const decoder = new TextDecoder();
+  if (reader) {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const text = decoder.decode(value, { stream: true });
+      const evs = parser.push(text);
+      for (const e of evs) {
+        if (e === "[DONE]") return;
+        if (e === "") continue;
+        yield e;
+      }
+    }
+    // flush 残留
+    const rest = parser.flush();
+    for (const e of rest) {
+      if (e === "[DONE]") return;
+      if (e) yield e;
+    }
+  } else if (typeof res.text === "function") {
+    // 回退：一次性 text
+    const txt = await res.text();
+    const evs = parser.push(txt);
+    for (const e of evs) {
+      if (e === "[DONE]") return;
+      if (e === "") continue;
+      yield e;
+    }
+  }
+}