@wwkit/llmproxy 1.0.3 → 1.0.5

package/src/providers/qianwen-web/auth.js

@@ -0,0 +1,258 @@
+// providers/qianwen-web/auth.js — 千问 Web 浏览器登录（CDP 捕获）
+//
+// 登录流程（手动，需手机验证码）：
+//   1. 用 Chrome 带 --remote-debugging-port 打开 www.qianwen.com
+//   2. 用户在浏览器里完成登录
+//   3. 通过 CDP Network 拦截，捕获 Cookie + 签名 token
+//   4. 凭证存入 ~/.config/llmproxy/.creds.json
+
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { getXdgConfigDir } from "@wwkit/shared";
+import { status as cftStatus } from "@wwkit/cft";
+import { AuthProvider } from "../../core/auth.js";
+import { log, sleep } from "../../util.js";
+
+const CREDS_FILE = path.join(getXdgConfigDir("llmproxy"), ".creds.json");
+const LOGIN_URL = "https://www.qianwen.com";
+const CAPTURE_REGEX = /qianwen\.com\/api\/v2\//;
+const CAPTURE_TIMEOUT_MS = 5 * 60 * 1000;
+
+function getChromePath() {
+  try {
+    const info = cftStatus();
+    if (info?.chrome_path && fs.existsSync(info.chrome_path)) return info.chrome_path;
+  } catch {}
+  return null;
+}
+
+export default class QianwenAuth extends AuthProvider {
+  constructor(opts) {
+    super(opts);
+    this._profileDir = path.join(
+      getXdgConfigDir("llmproxy"),
+      "chrome-profiles",
+      this.id.replace(/\//g, "-"),
+    );
+  }
+
+  async getCredentials(opts = {}) {
+    const autoLogin = opts.autoLogin !== false;
+    if (this._cred && this._cred.expiresAt > Date.now()) {
+      return this._cred;
+    }
+    if (!this._cred) await this._loadFromFile();
+    if (this._cred) return this._cred;
+    if (!autoLogin) {
+      throw new Error(`auth:${this.id} 无凭证，请先执行 llmproxy login --provider ${this.id}`);
+    }
+    await this.login();
+    return this._cred;
+  }
+
+  async login() {
+    log(`[auth:${this.id}] 启动浏览器手动登录千问...`);
+    const chromePath = getChromePath();
+    if (!chromePath) {
+      throw new Error("未找到 Chrome（可先执行 pnpm --filter cft install）");
+    }
+    const cdp = await this._launchChrome(chromePath);
+    try {
+      const cred = await this._captureCredentials(cdp);
+      this._cred = { ...cred, expiresAt: Date.now() + 7 * 24 * 3600 * 1000 };
+      await this._saveToFile();
+      log(`[auth:${this.id}] 登录成功，凭证已保存`);
+    } finally {
+      try { cdp.close(); } catch {}
+    }
+  }
+
+  async _launchChrome(chromePath) {
+    fs.mkdirSync(this._profileDir, { recursive: true });
+    const port = 9400 + Math.floor(Math.random() * 200);
+    const child = spawn(
+      chromePath,
+      [
+        `--remote-debugging-port=${port}`,
+        `--user-data-dir=${this._profileDir}`,
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-background-networking",
+        "about:blank",
+      ],
+      { stdio: "ignore", detached: true },
+    );
+    child.unref();
+
+    const versionUrl = `http://127.0.0.1:${port}/json/version`;
+    for (let i = 0; i < 60; i++) {
+      try {
+        const res = await fetch(versionUrl);
+        if (res.ok) break;
+      } catch {}
+      await sleep(200);
+      if (i === 59) throw new Error("Chrome CDP 启动超时");
+    }
+    this._chromePort = port;
+    log(`[auth:${this.id}] Chrome 已启动 (cdp=:${port})，请在浏览器中登录`);
+
+    const targets = await (await fetch(`http://127.0.0.1:${port}/json/list`)).json();
+    const page = targets.find((t) => t.type === "page");
+    if (!page) throw new Error("未找到 Chrome page target");
+
+    const ws = new WebSocket(page.webSocketDebuggerUrl);
+    await new Promise((resolve, reject) => {
+      ws.onopen = resolve;
+      ws.onerror = reject;
+    });
+    return new CdpClient(ws, port);
+  }
+
+  async _captureCredentials(cdp) {
+    await cdp.send("Network.enable");
+    await cdp.send("Page.enable");
+
+    // 捕获 Cookie + 签名 token
+    const captured = {};
+    const capturedPromise = new Promise((resolve) => {
+      const tryResolve = () => {
+        if (captured.cookie && captured.dvidn && captured.actkn) {
+          resolve(captured);
+        }
+      };
+
+      // 捕获请求头中的签名信息
+      cdp.on("Network.requestWillBeSent", (p) => {
+        const url = p?.request?.url;
+        if (!url || !CAPTURE_REGEX.test(url)) return;
+        const h = p?.request?.headers || {};
+        if (h["eo-clt-dvidn"]) captured.dvidn = h["eo-clt-dvidn"];
+        if (h["eo-clt-actkn"]) captured.actkn = h["eo-clt-actkn"];
+        if (h["eo-clt-snver"]) captured.snver = h["eo-clt-snver"];
+        if (h["eo-clt-sacsft"]) {
+          if (!captured.sacsftList) captured.sacsftList = [];
+          captured.sacsftList.push(h["eo-clt-sacsft"]);
+        }
+        if (h["eo-clt-acs-kp"]) captured.kp = h["eo-clt-acs-kp"];
+        tryResolve();
+      });
+
+      // 捕获 Cookie
+      cdp.on("Network.requestWillBeSentExtraInfo", (p) => {
+        const h = p?.headers || {};
+        if (h.Cookie || h.cookie) {
+          captured.cookie = h.Cookie || h.cookie;
+          tryResolve();
+        }
+      });
+    });
+
+    log(`[auth:${this.id}] 打开 ${LOGIN_URL}，请完成登录...`);
+    await cdp.send("Page.navigate", { url: LOGIN_URL });
+
+    const cred = await Promise.race([
+      capturedPromise,
+      new Promise((_, reject) =>
+        setTimeout(() => reject(new Error("捕获超时，请确认已完成登录")), CAPTURE_TIMEOUT_MS)
+      ),
+    ]);
+
+    log(`[auth:${this.id}] 已捕获凭证 dvidn=${cred.dvidn?.slice(0, 8)}... sacsft count=${cred.sacsftList?.length || 0}`);
+    return {
+      cookie: cred.cookie,
+      dvidn: cred.dvidn,
+      actkn: cred.actkn,
+      snver: cred.snver,
+      sacsftList: cred.sacsftList || [],
+      kp: cred.kp || "",
+    };
+  }
+
+  async _saveToFile() {
+    let all = {};
+    if (fs.existsSync(CREDS_FILE)) {
+      try { all = JSON.parse(fs.readFileSync(CREDS_FILE, "utf8")); } catch {}
+    }
+    if (!all.providers) all.providers = {};
+    all.providers[this.id] = {
+      cookie: this._cred.cookie,
+      dvidn: this._cred.dvidn,
+      actkn: this._cred.actkn,
+      snver: this._cred.snver,
+      sacsftList: this._cred.sacsftList,
+      kp: this._cred.kp,
+      expiresAt: this._cred.expiresAt,
+      loginAt: Date.now(),
+    };
+    fs.writeFileSync(CREDS_FILE, JSON.stringify(all, null, 2), { mode: 0o600 });
+  }
+
+  async _loadFromFile() {
+    if (!fs.existsSync(CREDS_FILE)) return;
+    try {
+      const all = JSON.parse(fs.readFileSync(CREDS_FILE, "utf8"));
+      const data = all.providers?.[this.id];
+      if (!data) return;
+      this._cred = {
+        cookie: data.cookie,
+        dvidn: data.dvidn,
+        actkn: data.actkn,
+        snver: data.snver,
+        sacsftList: data.sacsftList || [],
+        kp: data.kp || "",
+        expiresAt: data.expiresAt || 0,
+      };
+      if (!this._cred.cookie || !this._cred.dvidn || !this._cred.actkn) {
+        log(`[auth:${this.id}] 凭证文件缺少关键字段，请重新登录`);
+        this._cred = null;
+        return;
+      }
+      log(`[auth:${this.id}] 从 .creds.json 加载凭证 dvidn=${this._cred.dvidn?.slice(0, 8)}...`);
+    } catch (e) {
+      log(`[auth:${this.id}] 加载 .creds.json 失败: ${e.message}`);
+    }
+  }
+}
+
+// ---- 最小 CDP 客户端 ----
+class CdpClient {
+  constructor(ws, port) {
+    this.ws = ws;
+    this.port = port;
+    this.seq = 0;
+    this.pending = new Map();
+    this.eventHandlers = new Map();
+    ws.onmessage = (ev) => {
+      const msg = JSON.parse(ev.data);
+      if (msg.id) {
+        const p = this.pending.get(msg.id);
+        if (!p) return;
+        this.pending.delete(msg.id);
+        if (msg.error) p.reject(new Error(msg.error.message));
+        else p.resolve(msg.result || {});
+      } else if (msg.method) {
+        const cbs = this.eventHandlers.get(msg.method);
+        if (cbs) for (const cb of cbs) cb(msg.params || {});
+      }
+    };
+  }
+
+  send(method, params = {}) {
+    return new Promise((resolve, reject) => {
+      const id = ++this.seq;
+      this.pending.set(id, { resolve, reject });
+      this.ws.send(JSON.stringify({ id, method, params }));
+    });
+  }
+
+  on(method, cb) {
+    const arr = this.eventHandlers.get(method) || [];
+    arr.push(cb);
+    this.eventHandlers.set(method, arr);
+  }
+
+  close() {
+    try { this.ws.close(); } catch {}
+  }
+}

package/src/providers/qianwen-web/client.js

@@ -0,0 +1,159 @@
+// providers/qianwen-web/client.js — 千问 Web 推理客户端
+//
+// 完整管线：
+//   ① auth.getCredentials() 拿 cookie + 签名 token
+//   ② 构建请求体（OpenAI messages → 千问 messages 格式）
+//   ③ 用签名算法计算 clt-acs-sign 等头
+//   ④ POST /api/v2/chat?biz_id=ai_qwen&...
+//   ⑤ 千问 SSE → OpenAI SSE（createSseTransformStream）
+//
+// 会话策略：无状态 —— 每次请求新建 session_id。
+
+import crypto from "node:crypto";
+import { fetch } from "undici";
+import { log } from "../../util.js";
+import { SIGN_CONFIG, MODEL_MAP } from "./config.js";
+import { QianwenSigner } from "./sign.js";
+import { createSseTransformStream } from "./sse.js";
+import { buildMessages } from "./tools.js";
+
+const CHAT_PATH = "/chat";
+const CHAT_PARAMS = "biz_id=ai_qwen&fe_version=1.0.0&chat_client=h5&device=pc&fr=pc&pr=qwen&la=zh-CN&tz=Asia%2FShanghai&wv=4.6.2&ve=4.6.2";
+const USER_AGENT =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15";
+
+export default class QianwenClient {
+  constructor({ id, signProvider, authProvider, host, basePath }) {
+    this.id = id;
+    this.authProvider = authProvider;
+    this.host = host || SIGN_CONFIG.host;
+    this.basePath = basePath || SIGN_CONFIG.basePath;
+  }
+
+  /**
+   * POST /chat（返回 OpenAI 风格 Response）
+   */
+  async chatCompletions(body, opts = {}) {
+    const cred = await this.authProvider.getCredentials({ autoLogin: false });
+
+    // 构建签名器
+    const signer = new QianwenSigner({
+      dvidn: cred.dvidn,
+      actkn: cred.actkn,
+      snver: cred.snver,
+      sacsftList: cred.sacsftList,
+      kp: cred.kp,
+    });
+
+    // 生成随机 session_id 和 req_id
+    const sessionId = crypto.randomUUID().replace(/-/g, "").slice(0, 32);
+    const reqId = crypto.randomUUID().replace(/-/g, "").slice(0, 32);
+
+    // ① 构建请求体
+    const dsBody = this._convertRequest(body, sessionId, reqId);
+    const bodyStr = JSON.stringify(dsBody);
+
+    // ② 获取服务器时间戳（简化：用本地时间 + 偏移）
+    const timestamp = Date.now();
+
+    // ③ 签名
+    const paramNames = Object.keys(dsBody).filter((k) => dsBody[k] !== undefined && dsBody[k] !== null);
+    const signHeaders = signer.buildHeaders(bodyStr, timestamp, paramNames);
+
+    // ④ 发请求
+    const nonce = Math.random().toString(36).slice(2, 14);
+    // 从 cookie 提取 cna 值作为 ut 参数（千问 API 必需）
+    const cna = cred.cookie.split(";").map((s) => s.trim()).find((s) => s.startsWith("cna="))?.split("=")?.[1] || "";
+    const url = `https://${this.host}${this.basePath}${CHAT_PATH}?${CHAT_PARAMS}&ut=${cna}&nonce=${nonce}&timestamp=${timestamp}`;
+    log(`[qw:${this.id}] POST ${url.slice(0, 80)}... session=${sessionId.slice(0, 8)} model=${body.model} stream=${body.stream === true}`);
+
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json, text/event-stream, text/plain, */*",
+      "Accept-Language": "en-US,en;q=0.9",
+      "Origin": "https://www.qianwen.com",
+      "Referer": "https://www.qianwen.com/",
+      "User-Agent": USER_AGENT,
+      "Cookie": cred.cookie,
+      "x-chat-biz": JSON.stringify({ chatId: sessionId, agentId: "", enableWebp: "", runtimeEnabled: true, debugEnabled: false }),
+      "x-chat-id": sessionId,
+      "x-device-id": cred.dvidn,
+      "x-platform": "pc_tongyi",
+      "x-user-id": cred.dvidn,
+      "prod_id": "tongyi",
+      ...signHeaders,
+    };
+
+    const upstream = await fetch(url, {
+      method: "POST",
+      headers,
+      body: bodyStr,
+      signal: opts.signal || undefined,
+    });
+
+    if (!upstream.ok) {
+      const text = await upstream.text();
+      log(`[qw:${this.id}] 上游错误 ${upstream.status}: ${text.slice(0, 300)}`);
+      return new Response(
+        JSON.stringify({ error: { message: text.slice(0, 500), type: "upstream_error", code: upstream.status } }),
+        { status: upstream.status, headers: { "Content-Type": "application/json" } },
+      );
+    }
+
+    // ⑤ 响应处理：千问 API 始终返回 SSE 格式（即使 stream=false）
+    const contentType = upstream.headers.get("content-type") || "";
+    if (contentType.includes("text/event-stream")) {
+      // SSE 格式：转换为 OpenAI SSE
+      const converted = createSseTransformStream(upstream.body, body.model);
+      return new Response(converted, {
+        status: 200,
+        headers: { "Content-Type": "text/event-stream; charset=utf-8" },
+      });
+    } else {
+      // JSON 格式：直接返回
+      return new Response(upstream.body, {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+  }
+
+  /**
+   * OpenAI 请求体 → 千问 web 请求体
+   */
+  _convertRequest(body, sessionId, reqId) {
+    const model = body.model || "qwen";
+    const mapping = MODEL_MAP[model] || MODEL_MAP["qwen"];
+
+    const messages = buildMessages(body.messages || []);
+    const lastMsg = messages[messages.length - 1];
+    const query = lastMsg?.content || "";
+
+    log(`[qw:${this.id}] msgs=${messages.length} query=${JSON.stringify(query.slice(0, 40))}`);
+
+    return {
+      req_id: reqId,
+      parent_req_id: "",
+      messages,
+      scene: "chat",
+      sub_scene: "",
+      scene_param: "continue_chat",
+      session_id: sessionId,
+      biz_id: "ai_qwen",
+      model: mapping.model,
+      from: "default",
+      protocol_version: "v2",
+      messages_merge: false,
+      chat_client: "h5",
+      deep_search: null,
+      temporary: false,
+      chat_mode: "quick",
+      cms_test_data_ids: "",
+      bucket: {},
+    };
+  }
+
+  models() {
+    return Object.keys(MODEL_MAP);
+  }
+}

package/src/providers/qianwen-web/config.js

@@ -0,0 +1,22 @@
+// providers/qianwen-web/config.js — 千问 Web Provider 固定配置
+
+export const SIGN_CONFIG = {
+  host: "chat2.qianwen.com",
+  basePath: "/api/v2",
+};
+
+// OpenAI 模型名 → 千问 web 请求参数映射
+export const MODEL_MAP = {
+  "qwen": { model: "Qwen" },
+  "qwen3.8-max": { model: "Qwen3.8-Max" },
+  "qwen3.7-max": { model: "Qwen3.7-Max" },
+};
+
+export const MODELS = ["qwen", "qwen3.8-max", "qwen3.7-max"];
+
+// 签名相关端点（sec.qianwen.com）
+export const SEC_CONFIG = {
+  host: "sec.qianwen.com",
+  registerPath: "/security/external/access/register",
+  refreshPath: "/security/external/access/refresh",
+};

package/src/providers/qianwen-web/error.js

@@ -0,0 +1,10 @@
+// providers/qianwen-web/error.js — 千问 Web 错误模式
+
+import { ErrorPatterns } from "../../core/error.js";
+
+export default class QianwenErrorPatterns extends ErrorPatterns {
+  isSessionLimit(status, bodyText) {
+    // 千问无明显并发限制标识，暂不实现
+    return false;
+  }
+}

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

@@ -0,0 +1,86 @@
+// providers/qianwen-web/sign.js — 千问 Web 请求签名
+//
+// 签名算法（从千问前端 JS 逆向）：
+//   1. 获取服务器时间戳 timestamp
+//   2. salt = sacsft + ":" + timestamp
+//   3. bodySign = HMAC-SHA256(body, salt) → Base64
+//   4. signInput = dvidn + ve + kp + sacsft + bodySign
+//   5. sign = HMAC-SHA256(signInput, salt) → Base64
+//
+// 必须字段：
+//   eo-clt-dvidn   — 设备 ID（注册时获取）
+//   eo-clt-actkn   — Access Token（注册时获取）
+//   eo-clt-sacsft  — Baxia 安全令牌（每次请求从列表弹出）
+//   eo-clt-snver   — 签名版本号
+
+import { createHmac } from "node:crypto";
+
+export { SIGN_CONFIG } from "./config.js";
+
+// NoopSigner：千问的签名在 client 层完成，sign provider 不需要做任何事
+export default class NoopSigner {
+  constructor() {}
+  sign() { return {}; }
+}
+
+export class QianwenSigner {
+  constructor({ dvidn, actkn, snver, sacsftList = [], ve = "1.0.0", kp = "" }) {
+    this.dvidn = dvidn;
+    this.actkn = actkn;
+    this.snver = snver;
+    this.sacsftList = [...sacsftList];
+    this.ve = ve;
+    this.kp = kp;
+  }
+
+  /**
+   * 弹出一个 sacsft（Baxia 安全令牌），用后即弃
+   */
+  popSacsft() {
+    return this.sacsftList.pop() || "";
+  }
+
+  /**
+   * 计算签名
+   * @param {string} body  请求体 JSON 字符串
+   * @param {number} timestamp  服务器时间戳（毫秒）
+   * @param {string} sacsft  当前使用的 Baxia 令牌
+   * @returns {{ sign: string, bodySign: string }}
+   */
+  calculateSignature(body, timestamp, sacsft) {
+    const salt = `${sacsft}:${timestamp}`;
+    const bodySign = this._hmacSha256Base64(body, salt);
+    const signInput = `${this.dvidn}${this.ve}${this.kp}${sacsft}${bodySign}`;
+    const sign = this._hmacSha256Base64(signInput, salt);
+    return { sign, bodySign };
+  }
+
+  /**
+   * 构建请求头
+   * @param {string} body  请求体 JSON
+   * @param {number} timestamp  服务器时间戳
+   * @param {string[]} paramNames  请求参数名列表
+   * @returns {object} 需要注入的 headers
+   */
+  buildHeaders(body, timestamp, paramNames = []) {
+    const sacsft = this.popSacsft();
+    const { sign } = this.calculateSignature(body, timestamp, sacsft);
+
+    return {
+      "clt-acs-sign": sign,
+      "clt-acs-reqt": String(timestamp),
+      "clt-acs-request-params": paramNames.join(","),
+      "clt-acs-caer": "vrad",
+      "eo-clt-dvidn": this.dvidn,
+      "eo-clt-acs-ve": this.ve,
+      "eo-clt-sacsft": sacsft,
+      "eo-clt-snver": this.snver,
+      "eo-clt-actkn": this.actkn,
+      "eo-clt-acs-kp": this.kp,
+    };
+  }
+
+  _hmacSha256Base64(data, key) {
+    return createHmac("sha256", key).update(data).digest("base64");
+  }
+}

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

@@ -0,0 +1,157 @@
+// providers/qianwen-web/sse.js — 千问 Web SSE → OpenAI SSE 转换
+//
+// 千问 SSE 格式：
+//   data:{"error_msg":"","data":{"messages":[{"mime_type":"multi_load/iframe","content":"文本","status":"processing"}]}}
+//   data:{"error_msg":"","data":{"messages":[{"mime_type":"multi_load/iframe","content":"完整文本","status":"complete"}]}}
+//   event:complete
+//   data:{"error_msg":"","data":{...},"error_code":0}
+//
+// 转换为 OpenAI SSE：
+//   content 增量 → choices[0].delta.content
+//   status=complete + event:complete → finish_reason:"stop"
+//   data: [DONE]
+
+import crypto from "node:crypto";
+
+class QianwenSseTransformer {
+  constructor(model) {
+    this.model = model;
+    this.sentStart = false;
+    this.sentStop = false;
+    this.sentDone = false;
+    this.buffer = "";
+    this.lastContent = "";
+  }
+
+  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 === "complete") {
+      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;
+    const messages = obj.data?.messages;
+    if (!Array.isArray(messages)) return null;
+
+    const outputs = [];
+    let done = false;
+
+    for (const msg of messages) {
+      const mime = msg.mime_type || "";
+      const content = msg.content || "";
+      const status = msg.status || "";
+
+      // 跳过非内容消息
+      if (!content && mime !== "signal/post") continue;
+
+      // 内容增量：只发送新增部分
+      if (content && content.length > this.lastContent.length) {
+        const delta = content.slice(this.lastContent.length);
+        this.lastContent = content;
+        outputs.push(this.emitDelta(delta));
+      }
+
+      // 完成信号
+      if (status === "complete" && !this.sentStop) {
+        this.sentStop = true;
+        outputs.push(this.emitChunk({}, "stop"));
+      }
+    }
+
+    // 把所有输出合并成一个 chunk
+    if (outputs.length === 0) return null;
+    return new Uint8Array(
+      outputs.reduce((acc, chunk) => {
+        const arr = chunk instanceof Uint8Array ? chunk : new TextEncoder().encode(chunk);
+        return [...acc, ...arr];
+      }, []),
+    );
+  }
+
+  emitDelta(text) {
+    if (!this.sentStart) this.sentStart = true;
+    return this.emitChunk({ role: "assistant", content: 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`);
+  }
+}
+
+/**
+ * 把千问 upstream.body 包装成 OpenAI SSE ReadableStream
+ */
+export function createSseTransformStream(upstreamBody, model) {
+  const tr = new QianwenSseTransformer(model);
+  const reader = upstreamBody.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        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 { QianwenSseTransformer };