@wwkit/llmproxy 1.0.3 → 1.0.5

package/src/providers/deepseek-web/pow.js

@@ -0,0 +1,279 @@
+// providers/deepseek/pow.js — DeepSeek Web PoW (DeepSeekHashV1) 计算
+//
+// 算法（逆向自 DeepSeek web 前端 worker，见 docs/6608.8f2a9fa413.js）：
+//   1. POST /api/v0/chat/create_pow_challenge { target_path } → 获取 challenge
+//   2. prefix = salt + "_" + expire_at + "_"
+//   3. 遍历 nonce = 0..difficulty，DeepSeekHashV1(prefix + nonce) == challenge 时命中
+//   4. 构建 X-DS-PoW-Response header = base64(JSON({algorithm, challenge, salt, answer, signature, target_path}))
+//
+// 注意：DeepSeekHashV1 是基于 Keccak-f[1600] 的自定义海绵函数，字节序与 NIST SHA3-256
+// 不同（既非 sha3-256 也非 Ethereum keccak256），必须用下方的独立实现，不能用 crypto。
+//
+// 参考: docs/pow-analysis.md
+
+// 端点（固定值，无需用户配置）
+// 2026-09: DeepSeek 将端点从 /api/v0/users/create_guest_challenge 改为 /api/v0/chat/create_pow_challenge
+export const POW_ENDPOINT = "/api/v0/chat/create_pow_challenge";
+
+// ---- DeepSeekHashV1（Keccak-f[1600] 自定义变体）----
+// 以下为 worker 88387 模块的逐行移植。
+
+const RHO = [10, 7, 11, 17, 18, 3, 5, 16, 8, 21, 24, 4, 15, 23, 19, 13, 12, 2, 20, 14, 22, 9, 6, 1];
+const PI = [1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 2, 14, 27, 41, 56, 8, 25, 43, 62, 18, 39, 61, 20, 44];
+const RC = new Uint32Array([
+  0, 1, 0, 32898, 0x80000000, 32906, 0x80000000, 0x80008000, 0, 32907, 0, 0x80000001,
+  0x80000000, 0x80008081, 0x80000000, 32777, 0, 138, 0, 136, 0, 0x80008009, 0, 0x8000000a,
+  0, 0x8000808b, 0x80000000, 139, 0x80000000, 32905, 0x80000000, 32771, 0x80000000, 32770,
+  0x80000000, 128, 0, 32778, 0x80000000, 0x8000000a, 0x80000000, 0x80008081, 0x80000000, 32896,
+  0, 0x80000001, 0x80000000, 0x80008008,
+]);
+
+// 复制一个 64-bit lane（两字）：dst[2n]=src[2e], dst[2n+1]=src[2e+1]
+function laneCopy(src, e) {
+  return (dst, n) => {
+    dst[2 * n] = src[2 * e];
+    dst[2 * n + 1] = src[2 * e + 1];
+  };
+}
+
+// θ (theta)
+function theta(A, C, D, W) {
+  for (let t = 0; t < 5; t++) {
+    const n = 2 * t, i = (t + 5) * 2, o = (t + 10) * 2, f = (t + 15) * 2, s = (t + 20) * 2;
+    C[n] = A[n] ^ A[i] ^ A[o] ^ A[f] ^ A[s];
+    C[n + 1] = A[n + 1] ^ A[i + 1] ^ A[o + 1] ^ A[f + 1] ^ A[s + 1];
+  }
+  for (let t = 0; t < 5; t++) {
+    laneCopy(C, (t + 1) % 5)(W, 0);
+    const o = W[0], f = W[1];
+    W[0] = (o << 1) | (f >>> 31);
+    W[1] = (f << 1) | (o >>> 31);
+    D[2 * t] = C[(t + 4) % 5 * 2] ^ W[0];
+    D[2 * t + 1] = C[(t + 4) % 5 * 2 + 1] ^ W[1];
+    for (let r = 0; r < 25; r += 5) {
+      A[(r + t) * 2] ^= D[2 * t];
+      A[(r + t) * 2 + 1] ^= D[2 * t + 1];
+    }
+  }
+}
+
+// ρ (rho) + π (pi)
+function rhoPi(A, C, W) {
+  const n = new Uint32Array(2); // n[0]=高字, n[1]=低字
+  laneCopy(A, 1)(n, 0);
+  for (let i = 0; i < 24; i++) {
+    const t = RHO[i], a = PI[i];
+    laneCopy(A, t)(C, 0);
+    const o = n[0], f = n[1];
+    const s = a < 32 ? 0 : 1;
+    const u = 32 - a;
+    n[s] = (o << a) | (f >>> u);
+    n[(s + 1) % 2] = (f << a) | (o >>> u);
+    laneCopy(n, 0)(A, t);
+    laneCopy(C, 0)(n, 0);
+  }
+}
+
+// χ (chi)
+function chi(A, C) {
+  for (let t = 0; t < 25; t += 5) {
+    for (let n = 0; n < 5; n++) laneCopy(A, t + n)(C, n);
+    for (let n = 0; n < 5; n++) {
+      const i = (t + n) * 2, o = (n + 1) % 5 * 2, f = (n + 2) % 5 * 2;
+      A[i] ^= ~C[o] & C[f];
+      A[i + 1] ^= ~C[o + 1] & C[f + 1];
+    }
+  }
+}
+
+// ι (iota)
+function iota(A, rnd) {
+  const n = 2 * rnd;
+  A[0] ^= RC[n];
+  A[1] ^= RC[n + 1];
+}
+
+// Keccak-f[1600]：24 轮
+function keccakF(A) {
+  const C = new Uint32Array(10), D = new Uint32Array(10), W = new Uint32Array(2);
+  for (let i = 1; i < 24; i++) {
+    theta(A, C, D, W);
+    rhoPi(A, C, W);
+    chi(A, C);
+    iota(A, i);
+  }
+}
+
+// 吸收 queue 字节到 state（DeepSeek 的字节序）
+function absorbInto(queue, state) {
+  for (let r = 0; r < queue.length; r += 8) {
+    const n = r / 4;
+    state[n] ^= (queue[r + 7] << 24) | (queue[r + 6] << 16) | (queue[r + 5] << 8) | queue[r + 4];
+    state[n + 1] ^= (queue[r + 3] << 24) | (queue[r + 2] << 16) | (queue[r + 1] << 8) | queue[r];
+  }
+}
+
+// 从 state 挤出字节到 buffer（DeepSeek 的字节序）
+function squeezeOut(state, buffer) {
+  for (let r = 0; r < buffer.length; r += 8) {
+    const n = r / 4;
+    buffer[r] = state[n + 1];
+    buffer[r + 1] = state[n + 1] >>> 8;
+    buffer[r + 2] = state[n + 1] >>> 16;
+    buffer[r + 3] = state[n + 1] >>> 24;
+    buffer[r + 4] = state[n];
+    buffer[r + 5] = state[n] >>> 8;
+    buffer[r + 6] = state[n] >>> 16;
+    buffer[r + 7] = state[n] >>> 24;
+  }
+}
+
+const RATE = 136;
+const OUT_BYTES = 32;
+
+// DeepSeekHashV1：对输入字节计算 32 字节哈希，返回 hex
+export function dsHash(inputBytes) {
+  const state = new Uint32Array(50);
+  const queue = new Uint8Array(RATE);
+  let off = 0;
+  for (let e = 0; e < inputBytes.length; e++) {
+    queue[off] = inputBytes[e];
+    off++;
+    if (off >= RATE) {
+      absorbInto(queue, state);
+      keccakF(state);
+      off = 0;
+    }
+  }
+  // SHA3 padding：0x06 在消息末尾，0x80 在 rate 块最后字节
+  queue.fill(0, off);
+  queue[off] |= 0x06;
+  queue[RATE - 1] |= 0x80;
+  absorbInto(queue, state);
+  const buffer = new Uint8Array(OUT_BYTES);
+  for (let t = 0; t < OUT_BYTES; t += RATE) {
+    keccakF(state);
+    squeezeOut(state, buffer.subarray(t, t + RATE));
+  }
+  return Buffer.from(buffer).toString("hex");
+}
+
+/**
+ * 从服务器获取 PoW challenge
+ * @param {object} opts
+ * @param {object} opts.cred          auth 凭证 { headers: { Authorization, Cookie } }
+ * @param {string} opts.targetPath    目标接口路径，如 "/api/v0/chat/completion"
+ * @returns {Promise<object>}         challenge 对象（含 algorithm/challenge/salt/difficulty/signature/expire_at）
+ */
+export async function fetchChallenge(cred, targetPath) {
+  const res = await fetch(`https://chat.deepseek.com${POW_ENDPOINT}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(cred.headers || {}),
+    },
+    body: JSON.stringify({ target_path: targetPath }),
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`获取 PoW challenge 失败 ${res.status}: ${text.slice(0, 200)}`);
+  }
+  const data = await res.json();
+  const biz = data?.data?.biz_data || {};
+  // 2026-09: 字段名从 guest_challenge 改为 challenge，且 target_path 现在由服务端返回
+  const ch = biz.challenge || biz.guest_challenge;
+  if (!ch) {
+    throw new Error(`challenge not found: ${JSON.stringify(data).slice(0, 500)}`);
+  }
+  return {
+    algorithm: ch.algorithm,
+    challenge: ch.challenge,
+    salt: ch.salt,
+    difficulty: ch.difficulty,
+    signature: ch.signature,
+    // expire_at 可能是秒或毫秒，统一转为毫秒
+    expireAt: ch.expire_at > 1e12 ? ch.expire_at : ch.expire_at * 1000,
+    // target_path 优先用请求传入的，否则用服务端返回的
+    targetPath: targetPath || ch.target_path,
+  };
+}
+
+/**
+ * 求解 PoW：找到 nonce 使 DeepSeekHashV1(salt_"_"expireAt_"_"nonce) == challenge
+ * @param {object} challenge  fetchChallenge 返回的 challenge
+ * @returns {Promise<{answer: number, durationMs: number}>}
+ */
+export async function solvePow(challenge) {
+  const prefix = `${challenge.salt}_${challenge.expireAt}_`;
+  const target = challenge.challenge.toLowerCase();
+  const t0 = Date.now();
+
+  const encoder = new TextEncoder();
+  for (let nonce = 0; nonce < challenge.difficulty; nonce++) {
+    if (dsHash(encoder.encode(prefix + String(nonce))) === target) {
+      return { answer: nonce, durationMs: Date.now() - t0 };
+    }
+  }
+  throw new Error(
+    `PoW 无解: algorithm=${challenge.algorithm} difficulty=${challenge.difficulty} prefix=${prefix}`
+  );
+}
+
+/**
+ * 完整求解：fetch challenge + solve PoW，返回可注入 header 的值
+ * @param {object} opts
+ * @param {object} opts.cred          auth 凭证 { headers }
+ * @param {string} opts.targetPath    目标路径
+ * @param {object} [opts.state]       可选的缓存状态 { challenge, answer, expireAt }
+ * @returns {Promise<{ headerValue: string, challenge: object, answer: number }>}
+ */
+export async function getPowHeader(cred, targetPath, state) {
+  // 缓存：若 challenge 未过期且 targetPath 相同，复用已计算好的 answer
+  if (state?.challenge && state?.answer !== undefined) {
+    const ch = state.challenge;
+    if (ch.targetPath === targetPath && isNotExpired(ch.expireAt)) {
+      return {
+        headerValue: buildPowHeader(ch, state.answer, targetPath),
+        challenge: ch,
+        answer: state.answer,
+      };
+    }
+  }
+
+  const challenge = await fetchChallenge(cred, targetPath);
+  const { answer } = await solvePow(challenge);
+
+  // 更新缓存
+  if (state) {
+    state.challenge = challenge;
+    state.answer = answer;
+    state.targetPath = targetPath;
+  }
+
+  return { headerValue: buildPowHeader(challenge, answer, targetPath), challenge, answer };
+}
+
+// expireAt 兼容 epoch 秒 / 毫秒，且余量 60s
+function isNotExpired(expireAt) {
+  const ts = expireAt > 1e12 ? expireAt : expireAt * 1000;
+  return ts - 60_000 > Date.now();
+}
+
+/**
+ * 构建 X-DS-PoW-Response header 值（base64(JSON)）
+ * @param {object} challenge challenge 对象
+ * @param {number} answer     PoW 答案
+ * @param {string} targetPath 目标路径
+ * @returns {string}
+ */
+export function buildPowHeader(challenge, answer, targetPath) {
+  const payload = {
+    algorithm: challenge.algorithm,
+    challenge: challenge.challenge,
+    salt: challenge.salt,
+    answer,
+    signature: challenge.signature,
+    target_path: targetPath,
+  };
+  return Buffer.from(JSON.stringify(payload)).toString("base64");
+}

package/src/providers/deepseek-web/sign.js

@@ -0,0 +1,10 @@
+// providers/deepseek/sign.js — DeepSeek Web 签名
+//
+// DeepSeek web 的"签名"是 PoW（DeepSeekHashV1），由 client 内部完成
+// （需要异步 fetch challenge + auth 凭证，不符合本接口的同步 sign）。
+// 这里直接使用 NoopSigner。
+
+import { NoopSigner } from "../../core/sign.js";
+
+export { SIGN_CONFIG } from "./config.js";
+export default NoopSigner;

package/src/providers/deepseek-web/sse.js

@@ -0,0 +1,202 @@
+// providers/deepseek/sse.js — DeepSeek 自定义 SSE → OpenAI SSE 转换
+//
+// DeepSeek web 的 /api/v0/chat/completion 返回自定义 SSE：
+//   - 命名事件: ready / update_session / title / close
+//   - 完整 response 对象: { v: { response: { fragments: [{type:"THINK",content:"H"},...] } } }
+//   - fragment 追加:     { p:"response/fragments", o:"APPEND", v:[{type:"RESPONSE",content:"Hello"}] }
+//   - content 增量:      { p:"response/fragments/-1/content", (o:"APPEND"), v:"text" }
+//   - 裸文本增量:        { v:"text" }
+//   - 状态:              { p:"response/status", o:"SET", v:"FINISHED" }
+//   - 收尾:              event: close
+//
+// 转换为 OpenAI SSE:
+//   - THINK 内容 → choices[0].delta.reasoning_content
+//   - RESPONSE 内容 → choices[0].delta.content
+//   - FINISHED → finish_reason:"stop"
+//   - close → data: [DONE]
+//
+// 流式转换：输入 upstream.body (ReadableStream)，输出 OpenAI SSE (ReadableStream)。
+
+import crypto from "node:crypto";
+
+class SseTransformer {
+  constructor(model) {
+    this.model = model;
+    this.sentStart = false;
+    this.sentStop = false;
+    this.thinking = false;         // 当前写入的是 THINK 还是 RESPONSE fragment
+    this.fragmentId = null;        // 当前 fragment id（避免重复发送完整内容）
+    this.sentDone = false;         // 是否已发送 [DONE]
+    this.buffer = "";              // 跨 chunk 的 SSE 行缓冲
+  }
+
+  /** 输入 Uint8Array chunk，返回 Uint8Array[] */
+  transform(byteChunk) {
+    this.buffer += new TextDecoder().decode(byteChunk, { stream: true });
+    const outputs = [];
+    let idx;
+    while ((idx = this.buffer.indexOf("\n\n")) >= 0) {
+      const raw = this.buffer.slice(0, idx);
+      this.buffer = this.buffer.slice(idx + 2);
+      const out = this.handleEvent(raw);
+      if (out) outputs.push(out);
+    }
+    return outputs;
+  }
+
+  handleEvent(raw) {
+    let event = "message";
+    const dataLines = [];
+    for (const line of raw.split("\n")) {
+      if (line.startsWith("event:")) event = line.slice(6).trim();
+      else if (line.startsWith("data:")) dataLines.push(line.slice(5).trim());
+    }
+    if (dataLines.length === 0) return null;
+    if (event === "close") {
+      if (this.sentDone) return null;
+      this.sentDone = true;
+      return this.emitData("[DONE]");
+    }
+
+    for (const line of dataLines) {
+      let obj;
+      try { obj = JSON.parse(line) } catch { continue }
+      const out = this.handleData(obj);
+      if (out) return out;
+    }
+    return null;
+  }
+
+  handleData(obj) {
+    if (!obj || typeof obj !== "object") return null;
+
+    // 1) 完整 response 状态（含当前 fragment 初始内容）
+    if (obj.v?.response) return this.handleFullResponse(obj.v.response);
+
+    // 2) fragment 追加（新 fragment 及其初始内容）
+    if (obj.p === "response/fragments" && obj.o === "APPEND" && Array.isArray(obj.v) && obj.v.length) {
+      const last = obj.v[obj.v.length - 1];
+      if (last && typeof last.type === "string") {
+        this.thinking = last.type === "THINK";
+        // 新 fragment：发送初始内容（排除重复同步）
+        if (last.id !== this.fragmentId) {
+          this.fragmentId = last.id ?? null;
+          if (typeof last.content === "string" && last.content.length) {
+            return this.emitDelta(last.content);
+          }
+          return null;
+        }
+      }
+      return null;
+    }
+
+    // 3) content 增量补丁：p 以 /content 结尾、v 为字符串 → 追加到当前 fragment
+    if (typeof obj.p === "string" && obj.p.endsWith("/content") && typeof obj.v === "string") {
+      return this.emitDelta(obj.v);
+    }
+
+    // 3b) 状态（须在裸文本 case 之前判断，避免把状态值当内容发出）
+    if (obj.p === "response/status" && obj.o === "SET" && typeof obj.v === "string") {
+      return this.handleStatus(obj.v);
+    }
+
+    // 4) 裸文本增量 { v:"text" } → 追加到当前 fragment
+    if (typeof obj.v === "string") {
+      return this.emitDelta(obj.v);
+    }
+
+    return null;
+  }
+
+  // 完整 response 对象：设置模式，只在 fragment 变化时发送其内容
+  handleFullResponse(resp) {
+    if (Array.isArray(resp.fragments) && resp.fragments.length) {
+      const last = resp.fragments[resp.fragments.length - 1];
+      if (last && typeof last.type === "string" && last.id !== this.fragmentId) {
+        this.thinking = last.type === "THINK";
+        this.fragmentId = last.id ?? null;
+        if (typeof last.content === "string" && last.content.length) {
+          return this.emitDelta(last.content);
+        }
+        return null;
+      }
+    }
+    if (typeof resp.status === "string") {
+      return this.handleStatus(resp.status);
+    }
+    return null;
+  }
+
+  handleStatus(status) {
+    if (status === "FINISHED" && !this.sentStop) {
+      this.sentStop = true;
+      return this.emitChunk({}, "stop");
+    }
+    if (status !== "FINISHED" && !this.sentStart) {
+      this.sentStart = true;
+      return this.emitChunk({ role: "assistant" });
+    }
+    return null;
+  }
+
+  emitDelta(text) {
+    const key = this.thinking ? "reasoning_content" : "content";
+    if (!this.sentStart) this.sentStart = true;
+    return this.emitChunk({ role: "assistant", [key]: text });
+  }
+
+  emitChunk(delta, finishReason) {
+    const chunk = {
+      id: `chatcmpl-${crypto.randomUUID().slice(0, 8)}`,
+      object: "chat.completion.chunk",
+      created: Math.floor(Date.now() / 1000),
+      model: this.model,
+      choices: [{ index: 0, delta, finish_reason: finishReason ?? null }],
+    };
+    return this.emitData(JSON.stringify(chunk));
+  }
+
+  emitData(data) {
+    return new TextEncoder().encode(`data: ${data}\n\n`);
+  }
+}
+
+/**
+ * 把 DeepSeek upstream.body 包装成 OpenAI SSE ReadableStream
+ * @param {ReadableStream} upstreamBody  upstream.body
+ * @param {string} model                 模型名
+ * @returns {ReadableStream}             OpenAI SSE 流
+ */
+export function createSseTransformStream(upstreamBody, model) {
+  const tr = new SseTransformer(model);
+  const reader = upstreamBody.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        // 循环读取上游，直到产出至少一个 chunk 或流结束
+        // （某些上游 chunk 如 event:ready 不产出，需继续读避免 stall）
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            if (!tr.sentDone) controller.enqueue(tr.emitData("[DONE]"));
+            controller.close();
+            return;
+          }
+          const outputs = tr.transform(value);
+          if (outputs.length > 0) {
+            for (const c of outputs) controller.enqueue(c);
+            return;
+          }
+        }
+      } catch (e) {
+        controller.error(e);
+      }
+    },
+    cancel() {
+      reader.releaseLock();
+      upstreamBody.cancel().catch(() => {});
+    },
+  });
+}
+
+export { SseTransformer }

package/src/providers/deepseek-web/tools.js

@@ -0,0 +1,53 @@
+// providers/deepseek-web/tools.js — DeepSeek Web 消息格式化
+//
+// 将 OpenAI 消息数组转为 DeepSeek web prompt 文本（拼接原生调优标签）。
+// Tool 注入/解析由 openai-tool-bridge 通用层处理，Provider 只负责消息格式化。
+//
+// DeepSeek web 模型在 <｜System｜> / <｜end▁of▁sentence｜><｜User｜> /
+// <｜Assistant｜> 这些"调优标签"下训练，自定义的 [System]/[User]/[Tool result]
+// 格式不被识别，多轮工具历史会失效。本模块用原生标签组装 prompt。
+
+import crypto from "node:crypto";
+
+// ---- DeepSeek 原生调优标签 ----
+export const DS_TAGS = {
+  system: "<｜System｜>",
+  user: "<｜end▁of▁sentence｜><｜User｜>",
+  assistant: "<｜Assistant｜>",
+  toolBegin: "<｜tool▁output▁begin｜>",
+  toolEnd: "<｜tool▁output▁end｜>",
+};
+
+/**
+ * 构建 prompt：把全部消息（含 system + 多轮历史）拼接为单个 prompt 文本。
+ * openai-tool-bridge 会把 tools 注入到 system 消息的 content 里，
+ * Provider 只需用原生角色标签包裹每条消息即可。
+ */
+export function buildSimplePrompt(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return "";
+  return messages.map((msg) => formatMessage(msg)).join("\n");
+}
+
+/**
+ * 格式化单条消息为 DeepSeek prompt 片段
+ */
+function formatMessage(msg) {
+  const role = msg.role || "user";
+  const content = extractContent(msg.content);
+  const { system, user, assistant } = DS_TAGS;
+
+  if (role === "system") return `${system}${content}`;
+  if (role === "user") return `${user}${content}`;
+  if (role === "assistant") return `${assistant}${content}`;
+  return `${assistant}${content}`;
+}
+
+function extractContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((p) => (typeof p === "string" ? p : p?.text || ""))
+      .join("\n");
+  }
+  return "";
+}