mslxdff 0.1.155 → 0.1.158

package/src/providers/workbuddy/reshape.js

@@ -1,152 +1,152 @@
-// workbuddy 流式 reasoning_content 整形：上游思考模型（如 glm-5.3-flash）把思考过程一词一 chunk
-// 地放进 delta.reasoning_content，客户端会把每个增量渲染成独立 "- Thought" 条目。
-// 旧版：连续 reasoning 增量缓冲到首个 content/finish 才一次性 flush → 思考期 10~30s 界面完全无变化（用户看到 workbuddy 后台流量走但 opencode 界面卡住）
-// 新版：增量聚合 + 阈值分片：缓冲 reasoning，达到 REASONING_CHUNK_SIZE（默认 100 字符）即分片 flush，
-// 期间仅首个 role 帧透传保持 TTFB，其余纯 reasoning 空帧吞掉（之前会透传 800+ 空 role 帧）；
-// 尾段不足阈值的在 content/finish/流结束时兜底 flush。恒空 reasoning（deepseek-v4-flash）零改写。
-// 仅包 workbuddy 出口的 SSE 响应，不影响其他供应商与全局聚合器。
-
-const REASONING_CHUNK_SIZE = 150;
-
-export function reshapeWorkbuddySse(res) {
-  try {
-    const ct = res.headers?.get?.("content-type") || "";
-    if (res.status !== 200 || !ct.includes("text/event-stream") || !res.body) return res;
-  } catch { return res; }
-
-  const reader = res.body.getReader();
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  let buf = "";
-  let reasoningBuf = "";
-  let lastMeta = null;
-  let closed = false;
-  let hasSentRole = false;
-  let lastFlushAt = Date.now();
-
-  function flushReasoningInto(out) {
-    if (!reasoningBuf) return;
-    const meta = lastMeta || {};
-    out.push(`data: ${JSON.stringify({
-      id: meta.id || "chatcmpl-workbuddy-reshape",
-      object: meta.object || "chat.completion.chunk",
-      created: meta.created || Math.floor(Date.now() / 1000),
-      model: meta.model || "",
-      choices: [{ index: 0, delta: { reasoning_content: reasoningBuf }, finish_reason: null }],
-    })}\n\n`);
-    reasoningBuf = "";
-    lastFlushAt = Date.now();
-  }
-
-  let blankStreak = false;
-  // 处理一段完整行文本（以 \n 结尾），产出的行/帧推进 out（连续空行合并为单个事件分隔）
-  function processInto(text, out) {
-    for (const line of text.split("\n")) {
-      if (!line) { if (!blankStreak) out.push("\n"); blankStreak = true; continue; }
-      blankStreak = false;
-      if (!line.startsWith("data:")) { out.push(line + "\n"); continue; }
-      const payload = line.slice(5).trim();
-      if (!payload || payload === "[DONE]") { out.push(line + "\n"); continue; }
-      let obj;
-      try { obj = JSON.parse(payload); } catch { out.push(line + "\n"); continue; }
-      const ch = obj.choices?.[0];
-      if (ch && typeof ch === "object") {
-        if (obj.id) lastMeta = { id: obj.id, model: obj.model, object: obj.object, created: obj.created };
-        const d = ch.delta && typeof ch.delta === "object" ? ch.delta : null;
-        const rc = d ? d.reasoning_content : undefined;
-        if (typeof rc === "string" && rc) {
-          reasoningBuf += rc;
-          d.reasoning_content = "";
-          const isBoundary = (typeof d.content === "string" && d.content) || !!ch.finish_reason;
-          // 首个 reasoning 帧的 role 透传一次，保 TTFB；后续纯 reasoning 的 role 重复帧直接吞掉
-          if (!hasSentRole && d.role !== undefined) {
-            hasSentRole = true;
-            const rm = lastMeta || obj;
-            out.push(`data: ${JSON.stringify({
-              id: rm.id || obj.id || "chatcmpl-workbuddy-reshape",
-              object: rm.object || obj.object || "chat.completion.chunk",
-              created: rm.created || obj.created || Math.floor(Date.now() / 1000),
-              model: rm.model || obj.model || "",
-              choices: [{ index: 0, delta: { role: d.role }, finish_reason: null }],
-            })}\n\n`);
-          } else if (d.role !== undefined) {
-            // 后续重复 role 帧不再透传，避免 800+ 空帧洪泛
-            // 标记已发送过，避免后续非 reasoning 帧再误判为首次
-            hasSentRole = true;
-          }
-          // 阈值分片：攒够 100 字符即向前吐一块，期间界面可见增量而非全程静默
-          // 时间阈值：若距上次 flush 已超 700ms 且已攒 20+ 字符，也吐一块（避免小尾巴长时间不更新）
-          const now = Date.now();
-          const shouldChunk = reasoningBuf.length >= REASONING_CHUNK_SIZE
-            || (reasoningBuf.length >= 50 && now - lastFlushAt > 1500);
-          if (shouldChunk) flushReasoningInto(out);
-          if (isBoundary) {
-            // 兜底：content/finish 前把剩余思考一次性吐出，再透传本帧
-            flushReasoningInto(out);
-            const hasPassthrough = isBoundary || (Array.isArray(d.tool_calls) && d.tool_calls.length);
-            if (hasPassthrough) out.push(`data: ${JSON.stringify(obj)}\n\n`);
-            continue;
-          }
-          // 纯 reasoning 碎片帧已缓冲/或已分片吐出，原空帧吞掉
-          continue;
-        }
-        // 非 reasoning 帧：若有 content/finish 先兜底 flush
-        if ((typeof d?.content === "string" && d.content) || ch.finish_reason) flushReasoningInto(out);
-        if (!hasSentRole && d?.role !== undefined) {
-          hasSentRole = true;
-        } else if (hasSentRole && d?.role !== undefined) {
-          // 去重：首个 role 后续重复 role 去掉，避免下游每帧都带 role
-          try { const clone = JSON.parse(payload); delete clone.choices[0].delta.role; out.push(`data: ${JSON.stringify(clone)}\n\n`); continue; } catch { /* fallback透传 */ }
-        }
-      }
-      out.push(line + "\n");
-    }
-  }
-
-  const body = new ReadableStream({
-    async pull(controller) {
-      if (closed) { try { controller.close(); } catch {} return; }
-      try {
-        // 循环读源，直到"有输出 / 流结束 / 出错"才返回。
-        // WHATWG 流规范：pull 的 promise 解析后若未 enqueue，规范不会再自动调度 pull
-        // （仅当解析期间有新读请求触发 pullAgain 才重调）——消费者只挂一个待处理 read 时，
-        // 任何一次"只吞帧不出数据"的拉取都会让整流永久停摆。workbuddy 思考流按帧到达
-        // （role 帧后每个 reasoning 碎片都不足 150 字符阈值）时必现，即"首帧后卡死"根因。
-        for (;;) {
-          const { done, value } = await reader.read();
-          if (done) {
-            closed = true;
-            const out = [];
-            if (buf) { processInto(buf + "\n", out); buf = ""; }
-            flushReasoningInto(out);
-            if (out.length) controller.enqueue(encoder.encode(out.join("")));
-            controller.close();
-            return;
-          }
-          buf += decoder.decode(value, { stream: true });
-          const idx = buf.lastIndexOf("\n");
-          if (idx < 0) continue;
-          const complete = buf.slice(0, idx + 1);
-          buf = buf.slice(idx + 1);
-          const out = [];
-          processInto(complete, out);
-          if (out.length) { controller.enqueue(encoder.encode(out.join(""))); return; }
-        }
-      } catch {
-        closed = true;
-        try { controller.close(); } catch {}
-      }
-    },
-    cancel() {
-      closed = true;
-      try {
-        const p = reader.cancel();
-        if (p && typeof p.catch === "function") p.catch(() => {});
-      } catch {}
-    },
-  });
-
-  const out = new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
-  try { out._t = res._t; } catch {}
-  return out;
-}
+// workbuddy 流式 reasoning_content 整形：上游思考模型（如 glm-5.3-flash）把思考过程一词一 chunk
+// 地放进 delta.reasoning_content，客户端会把每个增量渲染成独立 "- Thought" 条目。
+// 旧版：连续 reasoning 增量缓冲到首个 content/finish 才一次性 flush → 思考期 10~30s 界面完全无变化（用户看到 workbuddy 后台流量走但 opencode 界面卡住）
+// 新版：增量聚合 + 阈值分片：缓冲 reasoning，达到 REASONING_CHUNK_SIZE（默认 100 字符）即分片 flush，
+// 期间仅首个 role 帧透传保持 TTFB，其余纯 reasoning 空帧吞掉（之前会透传 800+ 空 role 帧）；
+// 尾段不足阈值的在 content/finish/流结束时兜底 flush。恒空 reasoning（deepseek-v4-flash）零改写。
+// 仅包 workbuddy 出口的 SSE 响应，不影响其他供应商与全局聚合器。
+
+const REASONING_CHUNK_SIZE = 150;
+
+export function reshapeWorkbuddySse(res) {
+  try {
+    const ct = res.headers?.get?.("content-type") || "";
+    if (res.status !== 200 || !ct.includes("text/event-stream") || !res.body) return res;
+  } catch { return res; }
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let buf = "";
+  let reasoningBuf = "";
+  let lastMeta = null;
+  let closed = false;
+  let hasSentRole = false;
+  let lastFlushAt = Date.now();
+
+  function flushReasoningInto(out) {
+    if (!reasoningBuf) return;
+    const meta = lastMeta || {};
+    out.push(`data: ${JSON.stringify({
+      id: meta.id || "chatcmpl-workbuddy-reshape",
+      object: meta.object || "chat.completion.chunk",
+      created: meta.created || Math.floor(Date.now() / 1000),
+      model: meta.model || "",
+      choices: [{ index: 0, delta: { reasoning_content: reasoningBuf }, finish_reason: null }],
+    })}\n\n`);
+    reasoningBuf = "";
+    lastFlushAt = Date.now();
+  }
+
+  let blankStreak = false;
+  // 处理一段完整行文本（以 \n 结尾），产出的行/帧推进 out（连续空行合并为单个事件分隔）
+  function processInto(text, out) {
+    for (const line of text.split("\n")) {
+      if (!line) { if (!blankStreak) out.push("\n"); blankStreak = true; continue; }
+      blankStreak = false;
+      if (!line.startsWith("data:")) { out.push(line + "\n"); continue; }
+      const payload = line.slice(5).trim();
+      if (!payload || payload === "[DONE]") { out.push(line + "\n"); continue; }
+      let obj;
+      try { obj = JSON.parse(payload); } catch { out.push(line + "\n"); continue; }
+      const ch = obj.choices?.[0];
+      if (ch && typeof ch === "object") {
+        if (obj.id) lastMeta = { id: obj.id, model: obj.model, object: obj.object, created: obj.created };
+        const d = ch.delta && typeof ch.delta === "object" ? ch.delta : null;
+        const rc = d ? d.reasoning_content : undefined;
+        if (typeof rc === "string" && rc) {
+          reasoningBuf += rc;
+          d.reasoning_content = "";
+          const isBoundary = (typeof d.content === "string" && d.content) || !!ch.finish_reason;
+          // 首个 reasoning 帧的 role 透传一次，保 TTFB；后续纯 reasoning 的 role 重复帧直接吞掉
+          if (!hasSentRole && d.role !== undefined) {
+            hasSentRole = true;
+            const rm = lastMeta || obj;
+            out.push(`data: ${JSON.stringify({
+              id: rm.id || obj.id || "chatcmpl-workbuddy-reshape",
+              object: rm.object || obj.object || "chat.completion.chunk",
+              created: rm.created || obj.created || Math.floor(Date.now() / 1000),
+              model: rm.model || obj.model || "",
+              choices: [{ index: 0, delta: { role: d.role }, finish_reason: null }],
+            })}\n\n`);
+          } else if (d.role !== undefined) {
+            // 后续重复 role 帧不再透传，避免 800+ 空帧洪泛
+            // 标记已发送过，避免后续非 reasoning 帧再误判为首次
+            hasSentRole = true;
+          }
+          // 阈值分片：攒够 100 字符即向前吐一块，期间界面可见增量而非全程静默
+          // 时间阈值：若距上次 flush 已超 700ms 且已攒 20+ 字符，也吐一块（避免小尾巴长时间不更新）
+          const now = Date.now();
+          const shouldChunk = reasoningBuf.length >= REASONING_CHUNK_SIZE
+            || (reasoningBuf.length >= 50 && now - lastFlushAt > 1500);
+          if (shouldChunk) flushReasoningInto(out);
+          if (isBoundary) {
+            // 兜底：content/finish 前把剩余思考一次性吐出，再透传本帧
+            flushReasoningInto(out);
+            const hasPassthrough = isBoundary || (Array.isArray(d.tool_calls) && d.tool_calls.length);
+            if (hasPassthrough) out.push(`data: ${JSON.stringify(obj)}\n\n`);
+            continue;
+          }
+          // 纯 reasoning 碎片帧已缓冲/或已分片吐出，原空帧吞掉
+          continue;
+        }
+        // 非 reasoning 帧：若有 content/finish 先兜底 flush
+        if ((typeof d?.content === "string" && d.content) || ch.finish_reason) flushReasoningInto(out);
+        if (!hasSentRole && d?.role !== undefined) {
+          hasSentRole = true;
+        } else if (hasSentRole && d?.role !== undefined) {
+          // 去重：首个 role 后续重复 role 去掉，避免下游每帧都带 role
+          try { const clone = JSON.parse(payload); delete clone.choices[0].delta.role; out.push(`data: ${JSON.stringify(clone)}\n\n`); continue; } catch { /* fallback透传 */ }
+        }
+      }
+      out.push(line + "\n");
+    }
+  }
+
+  const body = new ReadableStream({
+    async pull(controller) {
+      if (closed) { try { controller.close(); } catch {} return; }
+      try {
+        // 循环读源，直到"有输出 / 流结束 / 出错"才返回。
+        // WHATWG 流规范：pull 的 promise 解析后若未 enqueue，规范不会再自动调度 pull
+        // （仅当解析期间有新读请求触发 pullAgain 才重调）——消费者只挂一个待处理 read 时，
+        // 任何一次"只吞帧不出数据"的拉取都会让整流永久停摆。workbuddy 思考流按帧到达
+        // （role 帧后每个 reasoning 碎片都不足 150 字符阈值）时必现，即"首帧后卡死"根因。
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) {
+            closed = true;
+            const out = [];
+            if (buf) { processInto(buf + "\n", out); buf = ""; }
+            flushReasoningInto(out);
+            if (out.length) controller.enqueue(encoder.encode(out.join("")));
+            controller.close();
+            return;
+          }
+          buf += decoder.decode(value, { stream: true });
+          const idx = buf.lastIndexOf("\n");
+          if (idx < 0) continue;
+          const complete = buf.slice(0, idx + 1);
+          buf = buf.slice(idx + 1);
+          const out = [];
+          processInto(complete, out);
+          if (out.length) { controller.enqueue(encoder.encode(out.join(""))); return; }
+        }
+      } catch {
+        closed = true;
+        try { controller.close(); } catch {}
+      }
+    },
+    cancel() {
+      closed = true;
+      try {
+        const p = reader.cancel();
+        if (p && typeof p.catch === "function") p.catch(() => {});
+      } catch {}
+    },
+  });
+
+  const out = new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
+  try { out._t = res._t; } catch {}
+  return out;
+}

package/src/providers/workbuddy.js

@@ -1,2 +1,2 @@
-// Shim — 保持历史导入路径兼容，真实实现下沉至 ./workbuddy/ 深模块
-export * from "./workbuddy/index.js";
+// Shim — 保持历史导入路径兼容，真实实现下沉至 ./workbuddy/ 深模块
+export * from "./workbuddy/index.js";

package/src/providers/zcode/account-store.js

@@ -0,0 +1,129 @@
+// zcode 账号落盘单一源：auths/zcode-<uid>.json（0600 tmp+rename）+ state.json providerConfigs.zcode.keys 同步。
+// deviceMid（per-account 持久 UUID，对齐 zcode-switch 实证）随账号文档走，不进 providerConfigs，
+// 规避 providerConfig 重建路径静默丢字段的既有故障类。
+import { writeFileSync, mkdirSync, existsSync, renameSync, unlinkSync, readdirSync, readFileSync, chmodSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { uuid } from "../../compat.js";
+import { isTestEnv, defaultStateFile } from "../../state/store.js";
+
+export function zcodeAuthDir({ explicit = "", testEnv = false, stateFile } = {}) {
+  if (explicit) return explicit;
+  if (testEnv) return join(tmpdir(), "mslxdff-test-auths");
+  return join(dirname(stateFile), "auths");
+}
+
+export function resolveZcodeAuthDir() {
+  return zcodeAuthDir({
+    explicit: process.env.MSLXDFF_ZCODE_AUTH_DIR || "",
+    testEnv: isTestEnv(),
+    stateFile: defaultStateFile(),
+  });
+}
+
+export function resolveZcodeAuthDirs() {
+  const primary = resolveZcodeAuthDir();
+  const cwdDir = join(process.cwd(), "auths");
+  return primary === cwdDir ? [primary] : [primary, cwdDir];
+}
+
+export function listZcodeAccountDocs({ dirs } = {}) {
+  const out = [];
+  const seen = new Set();
+  for (const dir of dirs || resolveZcodeAuthDirs()) {
+    let files = [];
+    try {
+      if (!existsSync(dir)) continue;
+      files = readdirSync(dir).filter((f) => f.startsWith("zcode-") && f.endsWith(".json"));
+    } catch { continue; }
+    for (const f of files) {
+      try {
+        const doc = JSON.parse(readFileSync(join(dir, f), "utf8"));
+        const uid = doc?.account?.uid;
+        if (!uid || !doc?.auth?.jwt) continue;
+        if (seen.has(String(uid))) continue;
+        seen.add(String(uid));
+        out.push({
+          uid: String(uid),
+          jwt: String(doc.auth.jwt),
+          deviceMid: String(doc.auth.deviceMid || ""),
+          name: String(doc.account.name || ""),
+          email: String(doc.account.email || ""),
+          provider: String(doc.auth.provider || ""),
+          file: join(dir, f),
+          dir,
+          doc,
+        });
+      } catch {}
+    }
+  }
+  return out;
+}
+
+function accountFilePath(uid, dir) {
+  return join(dir, `zcode-${uid}.json`);
+}
+
+export function writeZcodeAccountFile({ uid, jwt, name = "", email = "", provider = "zai", deviceMid = "" }, { dir = resolveZcodeAuthDir() } = {}) {
+  mkdirSync(dir, { recursive: true });
+  const doc = { account: { uid, name, email }, auth: { jwt, provider, deviceMid } };
+  const fp = accountFilePath(uid, dir);
+  const tmp = `${fp}.tmp`;
+  writeFileSync(tmp, JSON.stringify(doc, null, 2), { mode: 0o600 });
+  try {
+    if (existsSync(fp)) { try { chmodSync(fp, 0o600); } catch {} unlinkSync(fp); }
+    renameSync(tmp, fp);
+  } catch {
+    writeFileSync(fp, JSON.stringify(doc, null, 2), { mode: 0o600 });
+    try { unlinkSync(tmp); } catch {}
+  }
+  try { chmodSync(fp, 0o600); } catch {}
+  return fp;
+}
+
+export function readZcodeAccountDoc(uid, { dir = resolveZcodeAuthDir() } = {}) {
+  try {
+    return JSON.parse(readFileSync(accountFilePath(uid, dir), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export async function saveZcodeAccount({ uid, jwt, name = "", email = "", provider = "zai", deviceMid = "", dir, file } = {}) {
+  if (!uid || !jwt) throw new Error("saveZcodeAccount: 缺少 uid/jwt");
+  const targetDir = dir || resolveZcodeAuthDir();
+  const existing = readZcodeAccountDoc(uid, { dir: targetDir });
+  const mid = deviceMid || existing?.auth?.deviceMid || uuid();
+  const fp = writeZcodeAccountFile({ uid, jwt, name, email, provider, deviceMid: mid }, { dir: targetDir });
+
+  const { loadProviderConfig, saveProviderConfig } = await import("../../state.js");
+  const cur = loadProviderConfig("zcode", file ? { file } : {}) || {};
+  const keys = [...new Set([...(Array.isArray(cur.keys) ? cur.keys : []), jwt])];
+  // spread cur：保留 allowlist/allowAnyModels/baseUrl 等既有字段，不做 `{keys}` 重建
+  saveProviderConfig("zcode", { ...cur, keys }, file ? { file } : {});
+  return { file: fp, keys: keys.length, updated: Boolean(existing) };
+}
+
+// deviceMid：账号文档内持久复用；缺失时生成 UUID 并写回（文档不存在或尚无 jwt 时只返回不落盘）。
+export function ensureZcodeDeviceMid({ uid, dir } = {}) {
+  if (!uid) return "";
+  const targetDir = dir || resolveZcodeAuthDir();
+  const doc = readZcodeAccountDoc(uid, { dir: targetDir });
+  const cur = String(doc?.auth?.deviceMid || "").trim();
+  if (cur) return cur;
+  const mid = uuid();
+  if (doc?.auth?.jwt) {
+    writeZcodeAccountFile(
+      {
+        uid,
+        jwt: doc.auth.jwt,
+        name: doc.account?.name || "",
+        email: doc.account?.email || "",
+        provider: doc.auth?.provider || "zai",
+        deviceMid: mid,
+      },
+      { dir: targetDir },
+    );
+  }
+  return mid;
+}

package/src/providers/zcode/auth.js

@@ -0,0 +1,28 @@
+// zcode JWT 工具：解析、过期判断、指纹（日志只准出指纹，全文绝不落日志）。
+export function decodeJwtPayload(token) {
+  const s = String(token || "");
+  const parts = s.split(".");
+  if (parts.length < 3) return null;
+  try {
+    const json = Buffer.from(parts[1].replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8");
+    const payload = JSON.parse(json);
+    return payload && typeof payload === "object" ? payload : null;
+  } catch {
+    return null;
+  }
+}
+
+export function jwtExpiresAt(token) {
+  const exp = Number(decodeJwtPayload(token)?.exp);
+  return Number.isFinite(exp) && exp > 0 ? exp * 1000 : null;
+}
+
+export function isJwtExpired(token, now = Date.now()) {
+  const at = jwtExpiresAt(token);
+  return at != null && at <= now;
+}
+
+export function tokenFingerprint(token) {
+  const s = String(token || "");
+  return s ? s.slice(0, 8) : "";
+}

package/src/providers/zcode/chat.js

@@ -0,0 +1,171 @@
+// zcode 模型转发：OpenAI 请求 → Anthropic messages（网关出站恒流式；非流式本地聚合回 OpenAI JSON）。
+// 失败响应带 x-mslxdff-zcode-kind 标记，供 provider 工厂决定冷却策略。
+import { timeoutSignal } from "../../compat.js";
+import { ZCODE_MESSAGES_URL, canonicalZcodeModel, zcodeErrorKind } from "./const.js";
+import { buildZcodeHeaders } from "./headers.js";
+import { aggregateAnthropicToOpenAi, anthropicToOpenAiStream } from "./sse.js";
+
+const DEFAULT_MAX_TOKENS = 4096;
+
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content.filter((p) => p?.type === "text").map((p) => p.text || "").join("");
+  return "";
+}
+
+function mapToolChoice(tc) {
+  if (!tc) return undefined;
+  if (tc === "auto") return { type: "auto" };
+  if (tc === "required") return { type: "any" };
+  if (tc === "none") return { type: "none" };
+  const name = tc?.function?.name;
+  return name ? { type: "tool", name: String(name) } : undefined;
+}
+
+export function toAnthropicRequest(body = {}) {
+  const messages = [];
+  let system = "";
+  for (const m of Array.isArray(body.messages) ? body.messages : []) {
+    const role = String(m?.role || "");
+    if (role === "system") {
+      const part = textOf(m.content);
+      if (part) system += (system ? "\n\n" : "") + part;
+      continue;
+    }
+    if (role === "tool") {
+      messages.push({
+        role: "user",
+        content: [{ type: "tool_result", tool_use_id: String(m.tool_call_id || ""), content: typeof m.content === "string" ? m.content : textOf(m.content) }],
+      });
+      continue;
+    }
+    if (role === "assistant") {
+      const blocks = [];
+      const text = textOf(m.content);
+      if (text) blocks.push({ type: "text", text });
+      for (const tc of Array.isArray(m.tool_calls) ? m.tool_calls : []) {
+        let input = {};
+        try {
+          input = JSON.parse(tc?.function?.arguments || "{}");
+        } catch {}
+        blocks.push({ type: "tool_use", id: String(tc?.id || ""), name: String(tc?.function?.name || ""), input });
+      }
+      if (blocks.length) messages.push({ role: "assistant", content: blocks });
+      continue;
+    }
+    messages.push({ role: "user", content: textOf(m.content) });
+  }
+
+  const req = {
+    model: canonicalZcodeModel(body.model),
+    max_tokens: Number(body.max_tokens ?? body.max_completion_tokens) || DEFAULT_MAX_TOKENS,
+    messages,
+    stream: true, // 上游恒流式；非流式在本地聚合
+  };
+  if (system) req.system = system;
+  if (Number.isFinite(Number(body.temperature))) req.temperature = Number(body.temperature);
+  if (Array.isArray(body.tools) && body.tools.length) {
+    req.tools = body.tools
+      .map((t) => ({
+        name: String(t?.function?.name || t?.name || ""),
+        description: String(t?.function?.description || t?.description || ""),
+        input_schema: t?.function?.parameters || t?.parameters || { type: "object", properties: {} },
+      }))
+      .filter((t) => t.name);
+  }
+  // tool_choice 独立映射（不依赖 tools 是否在场，客户端显式给定即按 Anthropic 形状透出）
+  const choice = mapToolChoice(body.tool_choice);
+  if (choice) req.tool_choice = choice;
+  if (body.stop !== undefined && body.stop !== null) {
+    req.stop_sequences = Array.isArray(body.stop) ? body.stop : [String(body.stop)];
+  }
+  return req;
+}
+
+export function classifyZcodeFailure(status, payload) {
+  const code = Number(payload?.code) || 0;
+  let kind = zcodeErrorKind(code);
+  if (kind === "unknown") {
+    if (status === 401) kind = "auth";
+    else if (status === 429) kind = "rate_limit";
+    else if (status >= 500) kind = "server";
+  }
+  return { kind, code, status, message: String(payload?.msg || payload?.message || "").trim() };
+}
+
+const ERROR_MAP = {
+  auth: { status: 401, type: "auth_error", text: (f) => `zcode: 登录已失效（code ${f.code || 1006}）。请运行 mslxdff -provider zcode login 重新登录` },
+  quota: { status: 429, type: "quota_exhausted", text: () => "zcode: 免费额度已用完（按日重置），请明日再试或添加账号" },
+  rate_limit: { status: 429, type: "all_cooling", text: () => "zcode: 上游限流（账号冷却中），请稍后重试" },
+  security: { status: 403, type: "security_reject", text: (f) => `zcode: 安全校验拒绝（code ${f.code || 3007}）${f.message ? `：${f.message}` : ""} · 该额度走 Start Plan 验证码通道（每条请求需一次性 x-aliyun-captcha-verify-param；未启用验证码农场时必现），见 docs/adr/0038` },
+  param: { status: 400, type: "invalid_request", text: (f) => `zcode: 请求参数被上游拒绝（code ${f.code}）${f.message ? `：${f.message}` : ""}` },
+  server: { status: 502, type: "upstream_error", text: (f) => `zcode: 上游服务异常${f.code ? `（code ${f.code}）` : ""}${f.message ? `：${f.message}` : ""}` },
+  network: { status: 502, type: "upstream_error", text: (f) => `zcode: 网络错误 ${f.message || ""}`.trim() },
+  unknown: { status: 502, type: "upstream_error", text: (f) => `zcode: 上游错误（HTTP ${f.status || "?"}${f.code ? ` code ${f.code}` : ""}）${f.message ? `：${f.message}` : ""}` },
+};
+
+export function zcodeErrorResponse(fail = {}) {
+  const kind = ERROR_MAP[fail.kind] ? fail.kind : "unknown";
+  const entry = ERROR_MAP[kind];
+  const headers = { "Content-Type": "application/json" };
+  if (fail.kind) headers["x-mslxdff-zcode-kind"] = fail.kind;
+  return new Response(JSON.stringify({ error: { message: entry.text(fail), type: entry.type, code: fail.code || 0 } }), {
+    status: entry.status,
+    headers,
+  });
+}
+
+export async function forwardZcodeChat({ body, token, deviceMid, fetchImpl, version, timeoutMs = 120_000 } = {}) {
+  const anthropicBody = toAnthropicRequest(body);
+  const modelId = anthropicBody.model;
+  const headers = {
+    ...buildZcodeHeaders({ token, deviceMid, version }),
+    "Content-Type": "application/json",
+    Accept: "text/event-stream",
+  };
+
+  let res;
+  try {
+    res = await fetchImpl(ZCODE_MESSAGES_URL, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(anthropicBody),
+      signal: timeoutSignal(timeoutMs),
+    });
+  } catch (e) {
+    return zcodeErrorResponse({ kind: "network", message: String(e?.message || e).slice(0, 160) });
+  }
+
+  if (!res.ok) {
+    const payload = await res.json().catch(() => null);
+    return zcodeErrorResponse({ ...classifyZcodeFailure(res.status, payload), model: modelId });
+  }
+
+  // 上游业务错误惯例：HTTP 200 + JSON body（code 非 0/200）→ 同样按错误分类
+  if (!String(res.headers.get("content-type") || "").includes("text/event-stream")) {
+    const payload = await res.json().catch(() => null);
+    const code = Number(payload?.code);
+    const bizOk = payload?.success !== false && (!Number.isFinite(code) || code === 0 || code === 200);
+    if (payload && !bizOk) {
+      return zcodeErrorResponse({ ...classifyZcodeFailure(res.status, payload), model: modelId });
+    }
+    if (payload && body?.stream === false) {
+      return new Response(JSON.stringify(payload), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+  }
+
+  if (body?.stream !== false) {
+    const stream = anthropicToOpenAiStream(res.body, { model: modelId });
+    return new Response(stream, {
+      status: 200,
+      headers: { "Content-Type": "text/event-stream; charset=utf-8", "Cache-Control": "no-cache" },
+    });
+  }
+
+  const text = await res.text();
+  const out = await aggregateAnthropicToOpenAi(text, { model: modelId });
+  if (out.error) {
+    return zcodeErrorResponse({ kind: out.error.kind || "server", code: out.error.code || 0, status: 200, message: out.error.message });
+  }
+  return new Response(JSON.stringify(out.openAi), { status: 200, headers: { "Content-Type": "application/json" } });
+}