mslxdff 0.1.104 → 0.1.106

package/src/cli/commands/provider/deepseek-login.js

@@ -1,89 +0,0 @@
-// -provider deepseek login：把 chat.deepseek.com 凭据落盘 providerConfigs.deepseek.keys
-// 三种用法：
-//   login --token <userToken>     浏览器贴 token（F12 → Application → Local Storage → userToken）
-//   login <email|mobile> <password>  账密登录换 token（Android 协议）
-//   login                          打印用法引导
-export async function handleDeepseekLogin(id, sub, rest) {
-  if (id !== "deepseek" && id !== "ds") return false;
-  if (sub !== "login" && sub !== "auth") return false;
-
-  const args = rest || [];
-  const tokenFlagIdx = args.findIndex((a) => a === "--token" || a === "-token" || a === "token");
-
-  if (tokenFlagIdx < 0 && args.filter((a) => !String(a).startsWith("-")).length < 2) {
-    printUsage();
-    process.exit(0);
-  }
-
-  const { loadProviderKeys, saveProviderConfig, loadProviderConfig } = await import("../../../state.js");
-
-  let token = null;
-  let label = "";
-
-  if (tokenFlagIdx >= 0) {
-    token = String(args[tokenFlagIdx + 1] || "").trim();
-    if (!token) {
-      console.error("❌ --token 后面要贴 userToken 值");
-      printUsage();
-      process.exit(1);
-    }
-    label = "userToken（浏览器）";
-  } else {
-    const [loginValue, password] = args.filter((a) => !String(a).startsWith("-"));
-    console.log("🚀 DeepSeek 账密登录中（Android 协议）...");
-    try {
-      const { loginDeepseek } = await import("../../../providers/deepseek/auth.js");
-      const out = await loginDeepseek({ loginValue, password });
-      token = out.token;
-      label = `账密（${String(loginValue).slice(0, 3)}***）`;
-      console.log(`✅ 登录成功，拿到 token`);
-    } catch (e) {
-      console.error(`❌ ${e.message}`);
-      console.error(`\n换浏览器贴 token 方式：chat.deepseek.com 登录后 F12 → Application → Local Storage → 复制 userToken →`);
-      console.error(`  mslxdff -provider deepseek login --token <userToken>`);
-      process.exit(1);
-    }
-  }
-
-  if (!token) {
-    console.error("❌ 未拿到 token");
-    process.exit(1);
-  }
-
-  const cur = loadProviderKeys("deepseek");
-  if (cur.includes(token)) {
-    console.log(`ℹ️ 该 token 已存在（现 ${cur.length} 个账号），跳过`);
-  } else {
-    const cfg = loadProviderConfig("deepseek") || {};
-    const nextKeys = [...new Set([...(cfg.keys || cur), token].filter(Boolean))];
-    saveProviderConfig("deepseek", { ...cfg, keys: nextKeys });
-    console.log(`✅ 已写入 deepseek（现 ${nextKeys.length} 个账号）· 来源: ${label}`);
-  }
-
-  console.log("=".repeat(60));
-  console.log("\n下一步：");
-  console.log("  mslxdff -provider deepseek allowAny on   放行模型（默认 allowlist 空=全 blocked）");
-  console.log("  mslxdff -provider deepseek models        查看支持的模型");
-  console.log("  mslxdff -restart                         重启网关生效");
-  console.log("\n用法：model 字段填 deepseek/deepseek-chat 或 deepseek/deepseek-reasoner");
-  console.log("      （-search 后缀开启联网搜索：deepseek/deepseek-chat-search）");
-  console.log("\n多账号：重复 login 追加，自动轮换 + 401/429/风控切号");
-  console.log("注意：单账号同时仅 1 路输出；触发验证码时换号或稍后再试");
-  process.exit(0);
-}
-
-function printUsage() {
-  console.log("DeepSeek 登录（两种方式任选）：");
-  console.log("");
-  console.log("  方式 1（推荐，免密码）：浏览器贴 token");
-  console.log("    1. 浏览器登录 https://chat.deepseek.com");
-  console.log("    2. F12 → Application → Local Storage → https://chat.deepseek.com");
-  console.log("    3. 找到 userToken，复制值");
-  console.log("    4. mslxdff -provider deepseek login --token <userToken>");
-  console.log("");
-  console.log("  方式 2：账号密码（邮箱或手机号）");
-  console.log("    mslxdff -provider deepseek login you@example.com yourpassword");
-  console.log("    mslxdff -provider deepseek login 13800138000 yourpassword");
-  console.log("");
-  console.log("  登录后：mslxdff -provider deepseek allowAny on && mslxdff -restart");
-}

package/src/providers/deepseek/auth.js

@@ -1,194 +0,0 @@
-// DeepSeek 账号池 + 登录（Android 协议）
-// 上游协议参考 iidamie/deepseek2api（GPL-3.0，协议事实）
-// 并发闸门参考 Chat2API-WXS per-account guard：每 token 在途限 1，全忙 FIFO 排队，流结束释放
-import { compatFetch } from "../../compat.js";
-import { envInt } from "../base.js";
-import { androidHeaders } from "./pow.js";
-import { DEEPSEEK_DEFAULT_BASE, DEEPSEEK_API_PREFIX } from "./pow.js";
-import { dsDebug } from "./debug.js";
-
-export { androidHeaders };
-
-const DEFAULT_COOLDOWN_MS = 30_000;
-// 差异化冷却（防禁言体系）：频率前兆 60s（TQZHR 重试间隔同量级）、禁言 5min；防同号轰炸拖成禁言
-export const COOLDOWN_PRESETS = Object.freeze({ default: DEFAULT_COOLDOWN_MS, frequency: 60_000, muted: 300_000 });
-
-function isEmail(v) {
-  return String(v || "").includes("@");
-}
-
-export async function loginDeepseek({ loginValue, password, areaCode = "+86", fetchImpl, dispatcher, baseUrl = DEEPSEEK_DEFAULT_BASE, connectTimeoutMs = 30_000 } = {}) {
-  const doFetch = fetchImpl || compatFetch;
-  const email = isEmail(loginValue);
-  const payload = {
-    email: email ? String(loginValue).trim() : "",
-    mobile: email ? "" : String(loginValue).trim(),
-    area_code: email ? "" : areaCode,
-    password: String(password ?? ""),
-    device_id: "mslxdff",
-    os: "android",
-  };
-  const url = `${String(baseUrl).replace(/\/+$/, "")}${DEEPSEEK_API_PREFIX}/users/login`;
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(new Error("DeepSeek 登录超时")), connectTimeoutMs);
-  let res;
-  try {
-    res = await doFetch(url, {
-      method: "POST",
-      headers: androidHeaders(null),
-      body: JSON.stringify(payload),
-      ...(dispatcher ? { dispatcher } : {}),
-      signal: controller.signal,
-    });
-  } catch (err) {
-    throw new Error(`DeepSeek 登录失败: ${String(err?.message || err)}`);
-  } finally {
-    clearTimeout(timer);
-  }
-
-  let data = null;
-  try { data = await res.json(); } catch {}
-  const biz = data?.data;
-  const bizCode = biz?.biz_code ?? data?.code;
-  if (!res.ok || bizCode !== 0 || !biz?.biz_data?.user?.token) {
-    const msg = biz?.biz_msg || data?.msg || (biz?.biz_data?.user ? "响应缺少 token" : "登录响应格式错误");
-    throw new Error(`DeepSeek 登录失败: ${msg}${res.ok ? "" : ` (http ${res.status})`}`);
-  }
-  return { token: biz.biz_data.user.token, userId: biz.biz_data.user.id };
-}
-
-// 多账号轮换池：空闲最久优先 + 冷却 + onError；轮换语义对齐 NIyueeE/ds-free-api（选空闲最久者，最大化每次使用间隔）
-export function createAuthPool({ tokens = [], cooldownMs = DEFAULT_COOLDOWN_MS, clock = Date.now, maxConcurrentPerToken: maxConcParam } = {}) {
-  const list = [...new Set((tokens || []).map((t) => String(t).trim()).filter(Boolean))];
-  const until = new Map(); // token → 冷却到期时刻
-  const lastUsedAt = new Map(); // token → 最近一次被取用时刻（空闲最久排序依据）
-
-  function isCooling(token) {
-    const u = until.get(token);
-    return u != null && clock() < u;
-  }
-
-  // 空闲最久优先：平局按 list 顺序（与 round-robin 常规场景兼容，间隔拉开时倾向复用久未用号）
-  function next() {
-    if (!list.length) return null;
-    let best = null;
-    let bestIdle = -1;
-    for (const token of list) {
-      if (isCooling(token)) continue;
-      const idle = clock() - (lastUsedAt.get(token) || 0);
-      if (idle > bestIdle) {
-        bestIdle = idle;
-        best = token;
-      }
-    }
-    if (best) lastUsedAt.set(best, clock());
-    return best;
-  }
-
-  // cooldownMsOverride 可覆盖池默认（frequency/muted 走差异化冷却）
-  function onError(token, { cooldownMs: cooldownMsOverride } = {}) {
-    if (!list.includes(token)) return;
-    const ms = Number(cooldownMsOverride) > 0 ? Number(cooldownMsOverride) : cooldownMs;
-    until.set(token, clock() + ms);
-    dsDebug("auth", { event: "rotate", tokenTail: String(token).slice(-6), cooldownMs: ms, cooling: list.length - available(), total: list.length });
-  }
-
-  function available() {
-    return list.filter((t) => !isCooling(t)).length;
-  }
-
-  function requireToken() {
-    const token = next();
-    if (!token) {
-      const err = new Error(list.length
-        ? `DeepSeek: 所有账号都在冷却中（${list.length} 个），稍后再试或 -provider deepseek login 追加`
-        : "缺少 DeepSeek 凭据，请先 -provider deepseek login 或设置 providerConfigs.deepseek.keys");
-      err._deepseekNoAuth = true;
-      throw err;
-    }
-    return token;
-  }
-
-  // ---------------------------------------------------------------------------
-  // 并发闸门：每 token 最多 maxConcurrentPerToken 个在途请求（默认 1 = 禁止并发）
-  // acquireSlot → { token, release } | null(超时)；release 幂等，流式在 cleanup 链释放
-  // ---------------------------------------------------------------------------
-  const maxConcurrentPerToken = Math.max(1, Number(maxConcParam) > 0 ? Number(maxConcParam) : envInt("MSLXDFF_DEEPSEEK_MAX_CONCURRENT", 1));
-  const inFlight = new Map(); // token → 在途数
-  const waiters = []; // FIFO 等待队列：{ resolve, timer }
-
-  function inflightOf(token) {
-    return inFlight.get(token) || 0;
-  }
-
-  // 空闲（未冷却且在途未满）的号里选空闲最久者；无 → null
-  function nextIdle() {
-    let best = null;
-    let bestIdle = -1;
-    for (const token of list) {
-      if (isCooling(token) || inflightOf(token) >= maxConcurrentPerToken) continue;
-      const idle = clock() - (lastUsedAt.get(token) || 0);
-      if (idle > bestIdle) {
-        bestIdle = idle;
-        best = token;
-      }
-    }
-    return best;
-  }
-
-  function makeRelease(token) {
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      inFlight.set(token, Math.max(0, inflightOf(token) - 1));
-      dsDebug("gate", { event: "release", tokenTail: String(token).slice(-6), inFlight: inflightOf(token) });
-      wakeNext();
-    };
-  }
-
-  // 有槽位释放 → 唤醒队首等待者重新竞争（重新走 nextIdle，天然跳过冷却/满载号）
-  function wakeNext() {
-    while (waiters.length) {
-      const w = waiters.shift();
-      clearTimeout(w.timer);
-      const token = nextIdle();
-      if (!token) { waiters.unshift(w); break; } // 没有可用槽位，塞回队首等下次 release
-      lastUsedAt.set(token, clock());
-      inFlight.set(token, inflightOf(token) + 1);
-      dsDebug("gate", { event: "wakeup", tokenTail: String(token).slice(-6), queue: waiters.length });
-      w.resolve({ token, release: makeRelease(token) });
-    }
-  }
-
-  async function acquireSlot({ timeoutMs } = {}) {
-    const timeout = Number(timeoutMs) > 0 ? Number(timeoutMs) : envInt("MSLXDFF_DEEPSEEK_QUEUE_TIMEOUT_MS", 30_000);
-    const token = nextIdle();
-    if (token) {
-      lastUsedAt.set(token, clock());
-      inFlight.set(token, inflightOf(token) + 1);
-      dsDebug("gate", { event: "acquire-direct", tokenTail: String(token).slice(-6), inFlight: inflightOf(token) });
-      return { token, release: makeRelease(token) };
-    }
-    if (!list.length) {
-      const err = new Error("缺少 DeepSeek 凭据，请先 -provider deepseek login 或设置 providerConfigs.deepseek.keys");
-      err._deepseekNoAuth = true;
-      throw err;
-    }
-    // 全忙：入 FIFO 队列等待 release 唤醒；超时返回 null。
-    // 定时器不 unref：有请求在排队 = 有未完成工作，事件循环必须等它（unref 会让进程提前退出）
-    return new Promise((resolve) => {
-      const timer = setTimeout(() => {
-        const i = waiters.indexOf(w);
-        if (i >= 0) waiters.splice(i, 1);
-        dsDebug("gate", { event: "acquire-timeout", queue: waiters.length });
-        resolve(null);
-      }, timeout);
-      const w = { resolve, timer };
-      waiters.push(w);
-      dsDebug("gate", { event: "enqueue", queue: waiters.length, timeoutMs: timeout });
-    });
-  }
-
-  return { next, onError, available, requireToken, acquireSlot, maxConcurrentPerToken, size: list.length, cooldownMs, keys: [...list] };
-}

package/src/providers/deepseek/bridge.js

@@ -1,158 +0,0 @@
-// DeepSeek bridge：OpenAI messages ↔ DeepSeek web 协议互转
-// prompt 构造参考 iidamie/deepseek2api messages_prepare（协议事实）
-// SSE 事件层（event/data 分块 + 流尾 flush）+ 调 sse-decoder.js 纯解码
-import { createDeepseekDeltaParser } from "./sse-decoder.js";
-
-const USER_TAG = "<｜User｜>";
-const ASSISTANT_OPEN = "<｜Assistant｜>";
-const ASSISTANT_CLOSE = "<｜end▁of▁sentence｜>";
-
-export function buildPrompt(messages) {
-  const list = (messages || []).map((m) => {
-    let text = "";
-    if (Array.isArray(m?.content)) {
-      text = m.content
-        .filter((p) => p?.type === "text" && typeof p.text === "string")
-        .map((p) => p.text)
-        .join("\n");
-    } else if (m?.content != null) {
-      text = String(m.content);
-    }
-    return { role: String(m?.role || ""), text };
-  });
-  if (!list.length) return "";
-
-  const merged = [list[0]];
-  for (const msg of list.slice(1)) {
-    if (msg.role && msg.role === merged[merged.length - 1].role) {
-      merged[merged.length - 1].text += `\n\n${msg.text}`;
-    } else {
-      merged.push(msg);
-    }
-  }
-
-  const parts = [];
-  for (let idx = 0; idx < merged.length; idx++) {
-    const { role, text } = merged[idx];
-    if (role === "assistant") {
-      parts.push(`${ASSISTANT_OPEN}${text}${ASSISTANT_CLOSE}`);
-    } else if (role === "user" || role === "system") {
-      parts.push(idx > 0 ? `${USER_TAG}${text}` : text);
-    } else {
-      parts.push(text);
-    }
-  }
-  return parts.join("");
-}
-
-// 输入字符上限（ds-free-api 实测标定：default/vision≈1M tokens；expert≈64K tokens 与官方 API 一致）
-// 超限时上游 HTTP 200 + event:hint(input_exceeds_limit) + 立即 close；阈值取上限 75% 留余量
-const INPUT_CHAR_LIMITS = { expert: 163_840, default: 2_621_440, vision: 2_621_440 };
-
-export function promptThresholdFor(flags = {}) {
-  const limit = flags?.expert ? INPUT_CHAR_LIMITS.expert : INPUT_CHAR_LIMITS.default;
-  return Math.floor(limit * 0.75);
-}
-
-// 硬切（对齐 ds-free-api split_prompt_chunks：不感知标签边界，按字符数）
-export function splitPromptChunks(prompt, chunkSize) {
-  const s = String(prompt ?? "");
-  if (!chunkSize || chunkSize <= 0) return s ? [s] : [];
-  const chunks = [];
-  for (let i = 0; i < s.length; i += chunkSize) chunks.push(s.slice(i, i + chunkSize));
-  return chunks;
-}
-
-export function mapModelToFlags(modelId) {
-  const id = String(modelId || "");
-  // 官网「专家模式」：completion body 显式 model_type:"expert"（真机抓包，model_type 取值 default/chat/reasoner/vision/expert）
-  return {
-    thinking: id.includes("reasoner"),
-    search: id.includes("search"),
-    expert: id.includes("expert"),
-  };
-}
-
-export function buildUpstreamBody({ sessionId, prompt, thinking, search, expert, parentMessageId = null }) {
-  const body = {
-    chat_session_id: sessionId,
-    parent_message_id: parentMessageId ?? null,
-    prompt: String(prompt ?? ""),
-    ref_file_ids: [],
-    thinking_enabled: !!thinking,
-    search_enabled: !!search,
-  };
-  // 非 expert 不传 model_type（v2.0.0 实测缺省走 session 的 default；expert 模式显式声明）
-  if (expert) body.model_type = "expert";
-  return body;
-}
-
-// SSE 事件层：喂入文本（可跨块断行），产出标准 delta 事件数组。
-// 上游形态（Android x-client-version 2.0.0 真机抓包）：
-//   event: ready / update_session / title / close
-//   data: {"v":{"response":{fragments:[{type,content}]}}}   → 快照（decoder 做 unseen 后缀去重）
-//   data: {"p":"response/fragments/-1/content","o":"APPEND","v":"字"} → 定向增量
-//   data: {"v":"字"}                                        → 裸值：沿用 currentKind
-//   data: {"p":"response/status","o":"SET","v":"FINISHED"}  → 结束
-// startKind：thinking 请求首个 THINK fragment 可能以空对象 {} 下发（无 type），靠请求方兜底
-export function createDeepseekSseParser({ startKind = "content" } = {}) {
-  let buffer = "";
-  let closeSeen = false;
-  const decoder = createDeepseekDeltaParser({ startKind });
-
-  function processEventBlock(rawEvent, out) {
-    let eventName = "";
-    const dataLines = [];
-    for (const line of rawEvent.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      if (trimmed.startsWith("event:")) { eventName = trimmed.slice(6).trim(); continue; }
-      if (trimmed.startsWith("data:")) dataLines.push(trimmed.slice(5).trim());
-    }
-    if (eventName === "close" && !closeSeen && !decoder._state.finished) {
-      closeSeen = true;
-      out.push({ finish: "stop" });
-      return;
-    }
-    // 上游拒绝信号（真机抓包）：event: hint + {"type":"error","content":"内容超长，请删减后再试","finish_reason":"input_exceeds_limit"}
-    // 后跟 event: close，HTTP 仍是 200 —— 不透传就是"成功但空回复"
-    if (eventName === "hint") {
-      for (const dataStr of dataLines) {
-        let d = null;
-        try { d = JSON.parse(dataStr); } catch {}
-        if (d?.type === "error") {
-          out.push({ error: String(d.content || "上游拒绝"), finishReason: d.finish_reason || null, clearResponse: d.clear_response === true });
-          return;
-        }
-      }
-      return;
-    }
-    for (const dataStr of dataLines) {
-      if (!dataStr || dataStr === "[DONE]") continue;
-      for (const delta of decoder.consume(dataStr)) {
-        if (delta.kind === "finish") out.push({ finish: "stop" });
-        else if (delta.kind === "reasoning") out.push({ reasoning: delta.text });
-        else out.push({ content: delta.text });
-      }
-    }
-  }
-
-  return function parse(chunk) {
-    buffer += String(chunk ?? "");
-    const out = [];
-    let idx;
-    while ((idx = buffer.indexOf("\n\n")) >= 0) {
-      const rawEvent = buffer.slice(0, idx);
-      buffer = buffer.slice(idx + 2);
-      processEventBlock(rawEvent, out);
-    }
-    // 流尾 flush：仅当剩余 buffer 以换行结尾（data 行已完整终止）才处理，
-    // 半截 JSON 保持缓冲等待下一块；否则 FINISHED/close 等尾部事件会永久卡在 buffer
-    if (buffer.endsWith("\n") && buffer.trim()) {
-      const rest = buffer;
-      buffer = "";
-      processEventBlock(rest, out);
-    }
-    return out;
-  };
-}

package/src/providers/deepseek/chat.js

@@ -1,233 +0,0 @@
-// DeepSeek completion 编排：token→session→pow→completion→(流|聚合)→delete
-// 超限分流：expert > 阈值 → 分块喂养 session（对齐 NIyueeE/ds-free-api 方案 B）；其余超限人话报错
-// 风控语义参考 TQZHR/deepseek2api classifyProtocolResponse（MIT）
-import { androidHeaders, solveChallenge, netRetry, DEEPSEEK_DEFAULT_BASE, DEEPSEEK_API_PREFIX } from "./pow.js";
-import { COOLDOWN_PRESETS } from "./auth.js";
-import { buildPrompt, mapModelToFlags, createDeepseekSseParser, buildUpstreamBody, promptThresholdFor, splitPromptChunks } from "./bridge.js";
-import { createChatSession, deleteChatSession, feedChunkToSession } from "./session.js";
-import { dsDebug, dsDump, dsError } from "./debug.js";
-
-const CAPTCHA_PATTERN = /captcha|shumei|数美|验证码|风控|verification/i;
-// user is muted：账号被禁言/风控（上游对 completion 直接拒），切账号冷却，禁言期间不再打上游
-const MUTED_PATTERN = /user is muted|account is muted|\bmuted\b|禁言/i;
-// 「消息发送过于频繁」= 禁言前兆（TQZHR/deepseek2api 同款识别），命中即冷却换号，避免小病拖成禁言
-const FREQUENCY_PATTERN = /消息发送过于频繁[\s，,、:：]*请稍后重试/;
-
-function classifyProtocolFailure(text, status) {
-  const t = String(text || "");
-  if (FREQUENCY_PATTERN.test(t)) {
-    return upstreamError("DeepSeek 上游提示「消息发送过于频繁」：该账号触发频率风控（禁言前兆），已自动冷却并切换账号", { status, rotateAuth: true, cooldownMs: COOLDOWN_PRESETS.frequency });
-  }
-  if (MUTED_PATTERN.test(t)) {
-    return upstreamError("DeepSeek 账号被禁言/风控（user is muted）：已自动冷却该账号，请等待解除或 -provider deepseek login 追加账号", { status, rotateAuth: true, cooldownMs: COOLDOWN_PRESETS.muted });
-  }
-  return null;
-}
-
-function fmt(n) { return Number(n).toLocaleString("en-US"); }
-
-function upstreamError(message, { status, rotateAuth, cooldownMs } = {}) {
-  const err = new Error(message);
-  err.status = status;
-  if (rotateAuth) err._rotateAuth = true;
-  if (cooldownMs) err._cooldownMs = cooldownMs;
-  return err;
-}
-
-function classifyFailure(status, bodyText) {
-  const text = String(bodyText || "");
-  const muted = classifyProtocolFailure(text, status);
-  if (muted) return muted;
-  if (CAPTCHA_PATTERN.test(text)) {
-    return upstreamError("DeepSeek 触发上游风控/验证码，请稍后再试或换账号（-provider deepseek login 追加）", { status, rotateAuth: true });
-  }
-  if (status === 401 || status === 403) {
-    return upstreamError(`DeepSeek 凭据被拒 (http ${status})，自动切换下一个账号或重新 login`, { status, rotateAuth: true });
-  }
-  if (status === 429) {
-    return upstreamError("DeepSeek 请求过于频繁 (429)，账号已冷却，稍后再试", { status, rotateAuth: true });
-  }
-  return upstreamError(`DeepSeek completion 失败 (http ${status}): ${text.slice(0, 300)}`, { status });
-}
-
-async function readBodyText(res) {
-  try { return await res.text(); } catch { return ""; }
-}
-
-// 公共 completion 请求：netRetry + 非 SSE 检查 + INVALID_POW 一次重试（重解 challenge）
-async function fetchCompletionWithPow({ token, base, body, pow, fetchImpl, dispatcher, connectTimeoutMs }) {
-  const url = `${base}${DEEPSEEK_API_PREFIX}/chat/completion`;
-  for (let powAttempt = 0; ; powAttempt++) {
-    let res;
-    try {
-      res = await netRetry(() => fetchImpl(url, {
-        method: "POST",
-        headers: androidHeaders(token, { "x-ds-pow-response": pow.header }),
-        body: JSON.stringify(body),
-        ...(dispatcher ? { dispatcher } : {}),
-      }), { attempts: 2, delayMs: 400 });
-    } catch (err) {
-      dsError("completion", err);
-      throw upstreamError(`DeepSeek completion 网络失败: ${String(err?.message || err)}`, { rotateAuth: false });
-    }
-    dsDebug("completion", { event: "response", status: res.status, contentType: res.headers.get("content-type"), powAttempt, promptLen: body.prompt.length });
-
-    if (res.ok) {
-      const contentType = res.headers.get("content-type") || "";
-      if (!contentType.includes("text/event-stream")) {
-        const text = await readBodyText(res);
-        const muted = classifyProtocolFailure(text, res.status);
-        if (muted) { dsDump("completion", "muted", text, 400); throw muted; }
-        let payload = null;
-        try { payload = JSON.parse(text); } catch {}
-        const bizMsg = payload?.data?.biz_msg || payload?.msg || text.slice(0, 200);
-        dsDump("completion", "non-sse body", text, 1200);
-        throw upstreamError(`DeepSeek completion 返回非 SSE: ${bizMsg}`, { status: res.status });
-      }
-      return res;
-    }
-
-    const text = await readBodyText(res);
-    dsDump("completion", `error body http=${res.status}`, text, 1200);
-    if (/INVALID_POW_RESPONSE/i.test(text) && powAttempt < 1) {
-      const retryPow = await solveChallenge({ token, fetchImpl, dispatcher, baseUrl: base, connectTimeoutMs });
-      pow.header = retryPow.header;
-      continue;
-    }
-    throw classifyFailure(res.status, text);
-  }
-}
-
-// 单发路径（不超阈值）
-async function runOnce({ token, flags, prompt, isStream, fetchImpl, dispatcher, baseUrl, connectTimeoutMs }) {
-  const base = String(baseUrl || DEEPSEEK_DEFAULT_BASE).replace(/\/+$/, "");
-  const sessionId = await createChatSession({ token, fetchImpl, dispatcher, baseUrl: base, connectTimeoutMs });
-  const pow = await solveChallenge({ token, fetchImpl, dispatcher, baseUrl: base, connectTimeoutMs });
-  const completionBody = buildUpstreamBody({ sessionId, prompt, thinking: flags.thinking, search: flags.search, expert: flags.expert });
-  dsDebug("completion", { event: "request", sessionId, thinking: flags.thinking, search: flags.search, expert: flags.expert, promptLen: prompt.length, promptHead: prompt.slice(0, 120), body: JSON.stringify(completionBody) });
-  const res = await fetchCompletionWithPow({ token, base, body: completionBody, pow, fetchImpl, dispatcher, connectTimeoutMs });
-  return { kind: isStream ? "stream" : "aggregate", res, sessionId, token };
-}
-
-// 分块喂养路径（expert 超阈值）：共享 session，非末块只喂历史（ready→stop_stream→drain），末块正常生成
-async function runChunked({ token, flags, prompt, isStream, fetchImpl, dispatcher, baseUrl, connectTimeoutMs, threshold }) {
-  const base = String(baseUrl || DEEPSEEK_DEFAULT_BASE).replace(/\/+$/, "");
-  const chunks = splitPromptChunks(prompt, threshold);
-  const sessionId = await createChatSession({ token, fetchImpl, dispatcher, baseUrl: base, connectTimeoutMs });
-  dsDebug("chunked", { event: "start", sessionId, totalChunks: chunks.length, promptLen: prompt.length, threshold });
-  let parentId = null;
-  try {
-    for (const chunk of chunks.slice(0, -1)) {
-      const pow = await solveChallenge({ token, fetchImpl, dispatcher, baseUrl: base, connectTimeoutMs });
-      const feedBody = buildUpstreamBody({ sessionId, prompt: chunk, thinking: false, search: false, expert: flags.expert, parentMessageId: parentId });
-      dsDebug("chunked", { event: "feed", chunkLen: chunk.length, parentMessageId: parentId });
-      const res = await fetchCompletionWithPow({ token, base, body: feedBody, pow, fetchImpl, dispatcher, connectTimeoutMs });
-      parentId = await feedChunkToSession({ res, token, sessionId, fetchImpl, dispatcher, baseUrl, connectTimeoutMs });
-      dsDebug("chunked", { event: "fed", parentMessageId: parentId });
-    }
-    const lastChunk = chunks[chunks.length - 1];
-    const pow = await solveChallenge({ token, fetchImpl, dispatcher, baseUrl: base, connectTimeoutMs });
-    const body = buildUpstreamBody({ sessionId, prompt: lastChunk, thinking: flags.thinking, search: flags.search, expert: flags.expert, parentMessageId: parentId });
-    dsDebug("chunked", { event: "final", chunkLen: lastChunk.length, parentMessageId: parentId, thinking: flags.thinking, search: flags.search });
-    const res = await fetchCompletionWithPow({ token, base, body, pow, fetchImpl, dispatcher, connectTimeoutMs });
-    return { kind: isStream ? "stream" : "aggregate", res, sessionId, token };
-  } catch (err) {
-    dsError("chunked", err);
-    await deleteChatSession({ token, sessionId, fetchImpl, dispatcher, baseUrl });
-    throw err;
-  }
-}
-
-export function aggregateFromText(sseText, model, { thinking = false } = {}) {
-  const parse = createDeepseekSseParser({ startKind: thinking ? "reasoning" : "content" });
-  let content = "";
-  let reasoning = "";
-  let finish = "stop";
-  for (const ev of parse(String(sseText ?? ""))) {
-    // 上游拒绝（hint error）：人话抛出，绝不返回空 200；频率风控/禁言命中时冷却换号
-    if (ev.error) {
-      const rotate = FREQUENCY_PATTERN.test(String(ev.error)) || MUTED_PATTERN.test(String(ev.error));
-      throw upstreamError(`DeepSeek 上游拒绝: ${ev.error}${ev.finishReason ? ` (${ev.finishReason})` : ""}`, { status: 502, rotateAuth: rotate });
-    }
-    if (ev.content) content += ev.content;
-    if (ev.reasoning) reasoning += ev.reasoning;
-    if (ev.finish) finish = ev.finish;
-  }
-  const message = { role: "assistant", content };
-  if (reasoning) message.reasoning_content = reasoning;
-  return {
-    id: `chatcmpl-deepseek-${Date.now()}`,
-    object: "chat.completion",
-    created: Math.floor(Date.now() / 1000),
-    model,
-    choices: [{ index: 0, message, finish_reason: finish }],
-    usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
-  };
-}
-
-export async function runDeepseekChat({ body, authPool, fetchImpl, dispatcher, baseUrl, connectTimeoutMs = 30_000, maxAuthRetries } = {}) {
-  const model = body?.model || "deepseek/chat";
-  const rawId = String(model).includes("/") ? String(model).split("/").pop() : String(model);
-  const flags = mapModelToFlags(rawId);
-  const prompt = buildPrompt(body?.messages || []);
-  const isStream = body?.stream === true;
-  const threshold = promptThresholdFor(flags);
-
-  // 超限分流（ds-free-api 实测标定：default/vision 2,621,440 / expert 163,840，阈值取 75%）
-  if (prompt.length > threshold) {
-    if (!flags.expert) {
-      throw upstreamError(`DeepSeek ${model} 输入超长：${fmt(prompt.length)} 字符，超过 ${fmt(threshold)} 上限（网页通道 default 模型上限 2,621,440 字符）。请压缩对话历史（opencode /compact）或改用 deepseek-*-expert-free（自动分块）`, { status: 413 });
-    }
-    dsDebug("oversize", { event: "chunked-mode", model, promptLen: prompt.length, threshold });
-  }
-
-  const maxAttempts = maxAuthRetries ?? Math.max(1, authPool.size);
-  for (let attempt = 0; attempt <= maxAttempts; attempt++) {
-    // 并发闸门：每 token 在途限 1（MSLXDFF_DEEPSEEK_MAX_CONCURRENT），全忙排队，超时人话 429
-    const slot = await authPool.acquireSlot({});
-    if (!slot) {
-      throw upstreamError("DeepSeek: 所有账号都在忙（并发闸门排队超时），稍后重试或调大 MSLXDFF_DEEPSEEK_QUEUE_TIMEOUT_MS / MSLXDFF_DEEPSEEK_MAX_CONCURRENT", { status: 429 });
-    }
-    const { token, release } = slot;
-    try {
-      const out = prompt.length > threshold
-        ? await runChunked({ token, flags, prompt, isStream, fetchImpl, dispatcher, baseUrl, connectTimeoutMs, threshold })
-        : await runOnce({ token, flags, prompt, isStream, fetchImpl, dispatcher, baseUrl, connectTimeoutMs });
-      if (out.kind === "stream") {
-        // 流式：槽位由 cleanup 链释放（buildOpenAiSseStream 的 done/error/cancel），此处不放
-        const prevCleanup = out.cleanup;
-        return {
-          kind: "stream",
-          res: out.res,
-          token,
-          cleanup: async () => {
-            try { await prevCleanup?.(); } finally { release(); }
-          },
-        };
-      }
-      const sseText = await readBodyText(out.res);
-      let data;
-      try {
-        data = aggregateFromText(sseText, model, { thinking: flags.thinking });
-      } catch (err) {
-        await deleteChatSession({ token: out.token, sessionId: out.sessionId, fetchImpl, dispatcher, baseUrl });
-        throw err;
-      }
-      dsDump("aggregate", `sseText model=${model}`, sseText, 4000);
-      if (!data.choices[0].message.content && !data.choices[0].message.reasoning_content) {
-        dsDump("aggregate", "EMPTY aggregate content! full sseText", sseText, 8000);
-      }
-      await deleteChatSession({ token: out.token, sessionId: out.sessionId, fetchImpl, dispatcher, baseUrl });
-      release(); // 聚合成功：槽位随会话删除一并释放
-      return { kind: "json", data };
-    } catch (err) {
-      release(); // 失败（含 rotateAuth 重试）：立即释放，避免槽位泄漏
-      dsError(`chat attempt=${attempt}`, err);
-      if (err?._rotateAuth) authPool.onError(token, { cooldownMs: err._cooldownMs });
-      // 会话创建/删除阶段的 401/403 也属凭据被拒（session.js 带 status），与 completion 阶段对齐
-      else if (err?.status === 401 || err?.status === 403) authPool.onError(token, { cooldownMs: COOLDOWN_PRESETS.default });
-      if (!(err?._rotateAuth || err?.status === 401 || err?.status === 403) || attempt >= maxAttempts - 1) throw err;
-    }
-  }
-  throw upstreamError("DeepSeek: 所有账号均不可用", {});
-}