mslxdff 0.1.200 → 0.1.207

package/docs/cli_help_mini.md

@@ -78,7 +78,7 @@
 | zcode 接入 | `-provider zcode login [--bigmodel]` | ZCode（智谱官方编程工作台）免费额度授权：打印 chat.z.ai 授权链接→浏览器登录→CLI 轮询（`oauth/cli/init`→`poll`）拿 JWT，落盘 `auths/zcode-<uid>.json`+state 并把内置目录（`GLM-5.3`/`GLM-5.3-Flash`/`GLM-5.2`/`GLM-5-Turbo`）并入 allowlist；`zcode/<modelId>` 前缀路由（Anthropic 网关，恒上游 stream，**免验证码**）；`--bigmodel` 切 bigmodel.cn；恒 local-only 不借出 |
 | zcode 额度 | `-provider zcode quota [--json]` | 查 ZCode 套餐名/状态/有效期 + 各模型余量（`billing/balance` 分组表格）；空套餐给领取指引、401 给重登指引 |
 | raccoon 接入 | `-provider raccoon login` | Raccoon（商汤小浣熊）扫码登录：生成 `qrcode_code`→终端二维码 + `login/mp?code=` 链接→**用微信「扫一扫」扫**并确认（浏览器直接打开链接会 404，站点 SPA 无该路由）→轮询拿 token，落盘 `auths/raccoon-<uid>.json`+state（`keys` 一律以文档为准，续期后自愈）并把兜底 6 模型并入 allowlist；`raccoon/<modelId>` 前缀路由（**OpenAI 兼容网关**，**免验证码**）；多号自动轮换：请求内撞积分不足/限流就当场换下一个号，**暂不支持手动指定用哪个号**；积分不足长冷 1h、限流短冷 30s；恒 local-only 不借出 |
-| raccoon 密码登录 | `-provider raccoon login --password` | Raccoon **手机号+密码登录**（多号免扫码）：走 IAM 明文端点（`/api/iam/v1/auth/login/password/phone`，**不用**官方那条要加密手机号的 web 端点）；TTY 下密码**关回显**（逐键 `*`），非 TTY 须 `--password=<密码>`；默认 `--nation 86`；失败给人话（「手机号或密码不正确」），回执回显手机号但**打码**、**不回显密码**；落盘/确认/领奖与扫码登录完全同路 |
+| raccoon 密码登录 | `-provider raccoon login --password` | Raccoon **手机号+密码登录**（多号免扫码）：走官方同款 `POST /api/web/auth/v1/login_with_password`，**phone/password 须 AES-128-CFB 加密**（key 硬编码于前端，见 `crypto.js`；发明文会报「手机号或密码不正确」）；TTY 下密码**关回显**（逐键 `*`），非 TTY 须 `--password=<密码>`；默认 `--nation 86`；失败给人话（「手机号或密码不正确」），回执回显手机号但**打码**、**不回显密码**；落盘/确认/领奖与扫码登录完全同路 |
 | raccoon 积分 | `-provider raccoon quota [--json]` / `checkin` | 逐号查积分五分项 / 领「桌面端登录奖励」——**这家没有每日签到**：每日 300 与注册礼包 3000 由服务端自动发（无端点，每日 300 当天 23:59:59 清零），唯一要领的登录奖励 3000 是**每号一次性**且 `login` 时已自动领掉，`checkin` 只是补领兜底；判据只认账单、不认上游 `code:0`（重复领会虚回成功）；未登录给 login 指引；daemon 每日 09:00 兜底扫描未领过的号（`MSLXDFF_RACCOON_CHECKIN=0` 关，`_CHECKIN_HOUR` 改点） |
 | WorkBuddy 成长任务 | `-workbuddy growth [--json]` / `-wb growth` | 成长任务全自动（拉列表→参与→触发→领奖，串行 1.2s/1s，已领幂等跳过）；可自动 `chat_5`/`automation_1`/`skill_1`/`Model_chat_GLM5.2`，需客户端任务标 MANUAL 不发包；daemon 每日 09:30 自动（`MSLXDFF_WORKBUDDY_GROWTH=0` 关，`_GROWTH_HOUR`/`_GROWTH_MODEL` 可配） |
 | WorkBuddy 猫猫旅行 | `-workbuddy travel [--json]` / `-wb travel` | 无猫自动同意协议+领养（+300，门槛未达自动补一次对话解锁）；到站领奖 / 空闲派出（location 4）/ 旅行中跳过 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.200",
+  "version": "0.1.207",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/anthropic/canonical-json.js

@@ -0,0 +1,55 @@
+/**
+ * 键序规范化 JSON —— 出站请求体的「跨轮字节稳定」层。
+ *
+ * 1:1 照抄 cc-switch `src-tauri/src/proxy/json_canonical.rs`（v3.19 线）：
+ *  · `canonical_json_string`：对象键**按序**排列、紧凑输出（无空格换行）；数组保序；数字原样，
+ *    不做浮点规格化（Rust 侧 `Value::Number::to_string()`，本实现用 `String(n)`）。
+ *  · `canonicalize_value`：递归重建对象、按键序插入 —— 让后续 `JSON.stringify` 的字节序恒定。
+ *
+ * 为什么只在 /v1/messages 用：前缀缓存按「字节前缀」命中，同一逻辑 body 若键序漂移，
+ * 上游就会从头重算 prefill（实测 TTFT 与 prompt 长度成正比 = 每轮全量 prefill）。
+ * 客户端（Claude Code）回传历史里的 tool_use input 也可能由它自己重新序列化，
+ * 故 arguments 单独走 canonical（见 request-body.js）。
+ *
+ * 已知差异：Rust 的 `sort_by_key` 按字节序，JS `Array#sort` 按 UTF-16 码元序 ——
+ * 对 ASCII 键名（本协议全部字段名）两者等价；非 ASCII 键名理论上可能不同，本仓无此输入。
+ */
+
+/** 单值 JSON 字面量（字符串转义走 JSON.stringify，与 Rust `serde_json::to_string` 同形）。 */
+function literal(v) {
+  if (v === null) return "null";
+  const t = typeof v;
+  if (t === "string") return JSON.stringify(v);
+  if (t === "number") return Number.isFinite(v) ? String(v) : "null";
+  if (t === "boolean") return v ? "true" : "false";
+  return "null";
+}
+
+/**
+ * 规范 JSON 字符串：对象键序排列 + 紧凑输出。
+ * @param {unknown} value
+ * @returns {string}
+ */
+export function canonicalJson(value) {
+  if (value === null || typeof value !== "object") return literal(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((v) => canonicalJson(v === undefined ? null : v)).join(",")}]`;
+  }
+  const keys = Object.keys(value).filter((k) => value[k] !== undefined).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(value[k])}`).join(",")}}`;
+}
+
+/**
+ * 递归重建：对象按键序插入（数组保序）。出站 body 过一遍后，同一逻辑内容必然产出同一份字节。
+ * @param {unknown} value
+ * @returns {unknown}
+ */
+export function canonicalizeValue(value) {
+  if (Array.isArray(value)) return value.map(canonicalizeValue);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const k of Object.keys(value).sort()) out[k] = canonicalizeValue(value[k]);
+    return out;
+  }
+  return value;
+}

package/src/anthropic/request-body.js

@@ -3,30 +3,42 @@
 // 「出站响应/usage 翻译」本就是两向关注点，拆后 translate.js 单向 import 本文件，不回环。
 // 对外接口不变：调用方与测试仍从 anthropic/translate.js import（那边 re-export）。
 //
+// 形状对齐（1:1 照抄 cc-switch `src-tauri/src/proxy/providers/transform.rs:236-402`，只服务 /v1/messages）：
+//  * system 块间用 "\n" 拼成**一条**；逐块剥开头的 `x-anthropic-billing-header:` 行（#2350：
+//    该行带轮换 `cch=`，留在前缀位置会让上游前缀缓存每轮失效 → 每轮全量 prefill）；
+//  * `tool_use.arguments` 走 canonical JSON；出站体整体 canonicalize（键序恒定 = 字节前缀稳定）；
+//  * tool_result 里的媒体外移成一条 user 消息（改前是静默丢图）；
+//  * tools 过滤 `BatchTool`、description 缺省不写、`input_schema` 过 cleanToolSchema；
+//  * o 系列 `max_tokens` → `max_completion_tokens`；`stream_options` 改 merge 不覆盖。
+//
 // 纪律（别改回去）：
 //  * 思考档位**原样透传**（thinking/effort/reasoning_effort/reasoningEffort/extra_body），语义归一交给
 //    各 provider 与 src/thinking-effort.js —— 旧版在此丢掉，下游被迫补默认值（workbuddy 恒 high，ADR-0053）；
+//    此处刻意**不**照抄 cc-switch 的 thinking→reasoning_effort 本地映射表（transform.rs:100-190）；
 //  * 但**必须主动丢** output_config 原始对象 / context_management / 消息块内 thinking：Claude Code 对
-//    不认识的 model ID 照发全套字段，块内 thinking 无法签发 signature，回传必被上游拒（ADR-0047）。
+//    不认识的 model ID 照发全套字段，块内 thinking 无法签发 signature，回传必被上游拒（ADR-0047）；
+//  * 空会话抛错，绝不伪造一句 "hi" 打上游（会把假提问写进用户上下文并白烧一发额度）；
+//  * tool_result 重复 tool_use_id 保首个、丢后续（部分上游按 call_id 查重直接 400）；
+//    `is_error` 保留 `[tool_error]` 前缀（上游可见的错误信号，别照抄 cc-switch 丢掉）。
 import { isServerTool } from "./web-search.js";
 import { newToolUseId } from "./shared.js";
+import { canonicalJson, canonicalizeValue } from "./canonical-json.js";
+import { stripLeadingBillingHeader, cleanToolSchema, isOpenAiOSeries } from "./request-shape.js";
+import { imagePartOf, planToolResultMedia, queueToolMedia, flushToolMedia } from "./tool-media.js";
 
-// system 允许字符串或 text 块数组；块间空行连接（缓存语义不保留，上游是 OpenAI）
+// system 允许字符串或 text 块数组；块间用 "\n" 连接（照抄 cc-switch：跨轮字节稳定）。
+// 逐块剥开头的计费头：它每轮变一次，是前缀缓存失效的头号嫌疑人（cc-switch #2350）。
 function systemTextOf(system) {
-  if (typeof system === "string") return system;
+  const one = (t) => stripLeadingBillingHeader(typeof t === "string" ? t : "");
+  if (typeof system === "string") return one(system);
   if (!Array.isArray(system)) return "";
-  return system.map((b) => (b && typeof b.text === "string" ? b.text : "")).filter(Boolean).join("\n\n");
-}
-
-function imagePartOf(block) {
-  const src = block?.source || {};
-  if (src.type === "base64" && src.data) {
-    return { type: "image_url", image_url: { url: `data:${src.media_type || "image/png"};base64,${src.data}` } };
-  }
-  if (src.type === "url" && src.url) return { type: "image_url", image_url: { url: String(src.url) } };
-  return null;
+  return system
+    .map((b) => one(b && typeof b.text === "string" ? b.text : ""))
+    .filter(Boolean)
+    .join("\n");
 }
 
+/** tool_result 的 content → 纯文本（字符串原样；块数组取各 text；其余 String()）。 */
 export function toolResultTextOf(content) {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
@@ -49,61 +61,70 @@ export function messagesToChatBody(req = {}) {
   // 重复 tool_use_id 保首个、丢后续：客户端重试/重放历史会把同一工具结果存两份，
   // 部分上游按 call_id 查重直接 400（同 responses/translate.js:57-59 的实测教训）。
   const seenToolResult = new Set();
+  // 工具结果里的媒体暂存：同轮普通消息之前冲成一条 user 消息（Chat 的 tool 消息不能带图分片）
+  const pendingMedia = [];
 
   for (const m of Array.isArray(req.messages) ? req.messages : []) {
     if (!m || typeof m !== "object") continue;
     // role=system/developer 必须保留：Claude Code ≥2.1.286 的 mid-conversation system beta 就往 messages[] 里塞系统指令，
     const role = m.role === "assistant" ? "assistant" : m.role === "system" || m.role === "developer" ? "system" : "user";
-    const blocks = typeof m.content === "string" ? [{ type: "text", text: m.content }] : Array.isArray(m.content) ? m.content : [];
-    let text = "";
-    const imgs = [];
+    if (typeof m.content === "string") {
+      if (m.content) messages.push({ role, content: m.content });
+      continue;
+    }
+    const blocks = Array.isArray(m.content) ? m.content : null;
+    if (!blocks) {
+      if (m.content != null) messages.push({ role, content: m.content }); // 其它形状原样透传
+      continue;
+    }
+    const parts = []; // text / image 分片（照抄 cc-switch 的 content_parts）
     const toolCalls = [];
     for (const b of blocks) {
       if (!b || typeof b !== "object") continue;
-      if (b.type === "text") text += typeof b.text === "string" ? b.text : "";
-      else if (b.type === "image") { const p = imagePartOf(b); if (p) imgs.push(p); }
-      else if (b.type === "tool_use") {
-        let args = "{}";
-        try { args = JSON.stringify(b.input ?? {}); } catch { args = "{}"; }
-        toolCalls.push({ id: String(b.id || newToolUseId()), type: "function", function: { name: String(b.name || ""), arguments: args } });
+      if (b.type === "text") {
+        if (typeof b.text === "string" && b.text) parts.push({ type: "text", text: b.text });
+      } else if (b.type === "image") {
+        const p = imagePartOf(b);
+        if (p) parts.push(p);
+      } else if (b.type === "tool_use") {
+        toolCalls.push({
+          id: String(b.id || newToolUseId()),
+          type: "function",
+          function: { name: String(b.name || ""), arguments: canonicalJson(b.input ?? {}) },
+        });
       } else if (b.type === "tool_result") {
         // tool 消息必须先于同轮 user 文本进数组：OpenAI 侧要求 role:tool 紧跟其 assistant
         const key = String(b.tool_use_id || "");
         if (key) { if (seenToolResult.has(key)) continue; seenToolResult.add(key); }
-        const body = toolResultTextOf(b.content);
-        messages.push({ role: "tool", tool_call_id: key, content: b.is_error ? `[tool_error] ${body}` : body });
+        const plan = planToolResultMedia(b.content, canonicalJson);
+        let text;
+        if (plan) { queueToolMedia(pendingMedia, key, plan.media); text = plan.text; }
+        else text = toolResultTextOf(b.content);
+        messages.push({ role: "tool", tool_call_id: key, content: b.is_error ? `[tool_error] ${text}` : text });
       }
       // thinking / redacted_thinking 忽略：我们无法签发 signature，回传必被上游拒（ADR-0047）
     }
-    if (!text && !imgs.length && !toolCalls.length) continue;
-    const msg = { role, content: imgs.length ? [...(text ? [{ type: "text", text }] : []), ...imgs] : text };
+    // 媒体先给、再给同轮普通内容（照抄 cc-switch transform.rs:517 的顺序）
+    flushToolMedia(messages, pendingMedia);
+    if (!parts.length && !toolCalls.length) continue;
+    // 单 text 分片化简成纯字符串；无分片给 null（照抄 transform.rs:524-535）
+    const content = parts.length === 0 ? null
+      : parts.length === 1 && parts[0].type === "text" ? parts[0].text
+        : parts;
+    const msg = { role, content };
     if (toolCalls.length) msg.tool_calls = toolCalls;
     messages.push(msg);
   }
+  flushToolMedia(messages, pendingMedia); // 尾部残余（末条就是工具轮时）
   // 空会话直接 400：绝不伪造一句 "hi" 打上游（那会把假提问写进用户上下文并白烧一发额度）
   if (!messages.some((x) => x.role !== "system")) throw new Error("messages: 缺少用户消息");
 
   const body = { model, messages, stream: Boolean(req.stream) };
-  // 流式必须让上游把 usage 放进收尾帧，否则 message_delta.usage 恒 0（OpenAI 规范字段）。
-  // 个别上游不认 stream_options 会 400 → `MSLXDFF_ANTHROPIC_STREAM_USAGE=0` 关掉。
-  if (body.stream && process.env.MSLXDFF_ANTHROPIC_STREAM_USAGE !== "0") body.stream_options = { include_usage: true };
-  // Anthropic 的 server tool（web_search_*/web_fetch_*/…）没有 input_schema，折成假 function 会
-  // 让上游收到「空参数空描述」的工具（严格端点直接 422），本网关不实现的发前一律剥除（ADR-0049）。
-  const fnTools = (Array.isArray(req.tools) ? req.tools : []).filter((t) => !isServerTool(t));
-  if (fnTools.length) {
-    body.tools = fnTools.map((t) => ({
-      type: "function",
-      function: { name: String(t?.name || ""), description: String(t?.description || ""), parameters: t?.input_schema || {} },
-    }));
+  // o 系列必须用 max_completion_tokens（照抄 cc-switch transform.rs:278-286）
+  if (req.max_tokens != null && Number.isFinite(Number(req.max_tokens))) {
+    if (isOpenAiOSeries(model)) body.max_completion_tokens = Number(req.max_tokens);
+    else body.max_tokens = Number(req.max_tokens);
   }
-  const keptNames = new Set(fnTools.map((t) => String(t?.name || "")));
-  const tc = req.tool_choice;
-  if (tc === "auto" || (tc && typeof tc === "object" && tc.type === "auto")) body.tool_choice = "auto";
-  else if (tc && typeof tc === "object" && tc.type === "any") body.tool_choice = "required";
-  // 点名一个已被剥掉的工具时降为 auto：上游会按不存在的函数强制点名，那样一定拿不到有用回答
-  else if (tc && typeof tc === "object" && tc.type === "tool") body.tool_choice = keptNames.has(String(tc.name || "")) ? { type: "function", function: { name: String(tc.name || "") } } : "auto";
-  else if (tc && typeof tc === "object" && tc.type === "none") body.tool_choice = "none";
-  if (req.max_tokens != null && Number.isFinite(Number(req.max_tokens))) body.max_tokens = Number(req.max_tokens);
   if (req.temperature != null) body.temperature = req.temperature;
   if (req.top_p != null) body.top_p = req.top_p;
   if (Array.isArray(req.stop_sequences) && req.stop_sequences.length) body.stop = req.stop_sequences;
@@ -122,5 +143,41 @@ export function messagesToChatBody(req = {}) {
   if (ocEffort != null && body.reasoning_effort == null && body.reasoningEffort == null) {
     body.reasoning_effort = ocEffort;
   }
-  return body;
+  // 流式必须让上游把 usage 放进收尾帧，否则 message_delta.usage 恒 0（OpenAI 规范字段）。
+  // 照抄 cc-switch transform.rs:349-365：**merge** 客户端既有 stream_options，而不是整段覆盖。
+  // 个别上游不认 stream_options 会 400 → `MSLXDFF_ANTHROPIC_STREAM_USAGE=0` 关掉。
+  if (body.stream && process.env.MSLXDFF_ANTHROPIC_STREAM_USAGE !== "0") {
+    const opts = req.stream_options && typeof req.stream_options === "object" ? req.stream_options : {};
+    body.stream_options = { ...opts, include_usage: true };
+  }
+  // Anthropic 的 server tool（web_search_*/web_fetch_*/…）没有 input_schema，折成假 function 会
+  // 让上游收到「空参数空描述」的工具（严格端点直接 422），本网关不实现的发前一律剥除（ADR-0049）；
+  // 另外照抄 cc-switch 剥 `BatchTool`、description 缺省不写、schema 过 cleanToolSchema。
+  const fnTools = (Array.isArray(req.tools) ? req.tools : [])
+    .filter((t) => !isServerTool(t))
+    .filter((t) => String(t?.type || "") !== "BatchTool");
+  if (fnTools.length) {
+    body.tools = fnTools.map((t) => {
+      const fn = { name: String(t?.name || "") };
+      if (typeof t?.description === "string" && t.description) fn.description = t.description;
+      fn.parameters = cleanToolSchema(t?.input_schema ?? {});
+      return { type: "function", function: fn };
+    });
+  }
+  const keptNames = new Set(fnTools.map((t) => String(t?.name || "")));
+  const tc = req.tool_choice;
+  if (typeof tc === "string") {
+    // 字符串形态：Anthropic 的 "any" → OpenAI 的 "required"（照抄 transform.rs:381-386）
+    if (tc === "any") body.tool_choice = "required";
+    else if (tc) body.tool_choice = tc;
+  } else if (tc && typeof tc === "object") {
+    if (tc.type === "auto") body.tool_choice = "auto";
+    else if (tc.type === "any") body.tool_choice = "required";
+    // 点名一个已被剥掉的工具时降为 auto：上游会按不存在的函数强制点名，那样一定拿不到有用回答
+    else if (tc.type === "tool") body.tool_choice = keptNames.has(String(tc.name || "")) ? { type: "function", function: { name: String(tc.name || "") } } : "auto";
+    else if (tc.type === "none") body.tool_choice = "none";
+  }
+  // 出站体键序规范化：同一逻辑内容必然产出同一份字节 → 上游前缀缓存能稳定命中
+  // （照抄 cc-switch forwarder.rs prepare_upstream_request_body / json_canonical.rs）。
+  return canonicalizeValue(body);
 }

package/src/anthropic/request-shape.js

@@ -0,0 +1,60 @@
+/**
+ * /v1/messages 请求形状的「取稳与清洗」原语 —— 1:1 照抄 cc-switch。
+ *
+ * 三件套：
+ *  1. `stripLeadingBillingHeader` —— 剥 system 文本**开头**的 `x-anthropic-billing-header:` 行
+ *     （照抄 transform.rs:17-55，对应 cc-switch #2350）。Claude Code 会把含轮换 `cch=` 的
+ *     计费头塞在 system 最前面；它每轮变一次 → 整条前缀缓存失效 → 每轮全量 prefill。
+ *     只在开头剥，后文再出现同样的字符串一律保留（那是用户自己写的内容）。
+ *  2. `cleanToolSchema` —— 工具参数 schema 清洗（照抄 transform.rs:563-594）：根缺 `type` 时补
+ *     `"object"` 并顺带补 `properties: {}`，全树删 `format: "uri"`（严格上游会拒），嵌套递归。
+ *  3. `isOpenAiOSeries` —— o 系列（o1/o3/o4…）需 `max_completion_tokens` 而非 `max_tokens`
+ *     （照抄 transform.rs:57-63 的意图；本仓模型 id 带供应商前缀，故按末段判定）。
+ */
+
+const BILLING_HEADER_PREFIX = "x-anthropic-billing-header:";
+
+/**
+ * 剥 system 开头的计费头行（含紧随的一个空行）。
+ * 无换行（整段就是这一行）→ 返回空串，与 cc-switch 一致。
+ * @param {unknown} text
+ * @returns {string}
+ */
+export function stripLeadingBillingHeader(text) {
+  const s = typeof text === "string" ? text : "";
+  if (!s.startsWith(BILLING_HEADER_PREFIX)) return s;
+  const nl = s.search(/[\r\n]/);
+  if (nl < 0) return "";
+  let rest = s.slice(nl + 1);
+  if (s[nl] === "\r" && rest.startsWith("\n")) rest = rest.slice(1);
+  if (rest.startsWith("\r\n")) return rest.slice(2);
+  if (rest.startsWith("\n") || rest.startsWith("\r")) return rest.slice(1);
+  return rest;
+}
+
+/** 递归清洗一份 JSON schema（不修改入参：每层都产新对象）。 */
+export function cleanToolSchema(schema) {
+  return cleanSchemaInner(schema, true);
+}
+
+function cleanSchemaInner(schema, isRoot) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return schema;
+  const out = { ...schema };
+  const missingType = isRoot && !("type" in out);
+  if (missingType) out.type = "object";
+  if (missingType && !("properties" in out)) out.properties = {};
+  if (out.format === "uri") delete out.format;
+  if (out.properties && typeof out.properties === "object" && !Array.isArray(out.properties)) {
+    const props = {};
+    for (const k of Object.keys(out.properties)) props[k] = cleanSchemaInner(out.properties[k], false);
+    out.properties = props;
+  }
+  if (out.items !== undefined) out.items = cleanSchemaInner(out.items, false);
+  return out;
+}
+
+/** OpenAI o 系列（o1/o3/o4-mini…）：只看 id 末段，避免供应商前缀（如 `openai/o3`）干扰。 */
+export function isOpenAiOSeries(model) {
+  const id = String(model || "").split("/").pop() || "";
+  return /^o\d(?:$|[-.])/.test(id.toLowerCase());
+}

package/src/anthropic/session-id.js

@@ -0,0 +1,58 @@
+/**
+ * Claude 系会话身份提取 —— 1:1 照抄 cc-switch `src-tauri/src/proxy/session.rs:107-231`（Claude 分支）。
+ *
+ * 为什么需要：会话 id 用来给上游做「缓存亲和 / 粘性路由」（`prompt_cache_key`、会话头）。
+ * cc-switch #8236 的教训是：拿不到真实会话身份就每轮生成一个新 id ⇒ 每轮换缓存 key ⇒
+ * 前缀缓存永不命中。Claude Code 走 `/v1/messages` 时把会话身份放在**请求体 metadata**里
+ * （不是 header），所以只读 header 的实现会一路漏。
+ *
+ * 优先级（与 cc-switch 一致）：
+ *  1. header `x-claude-code-session-id`，再 `claude-code-session-id`（非空即用：**不 trim、无长度门槛**）
+ *  2. `metadata.user_id`：trim 后以 `{` 开头 → 当 JSON 解析取 `session_id`（trim 后非空才认）；
+ *     否则找字面量 `_session_`，取其后的整段（旧格式）
+ *  3. `metadata.session_id`（字符串，trim 后非空）
+ *  4. 都没有 → 返回 null（由调用方走既有兜底，绝不在这里凭空生成：生成值会每轮变）
+ *
+ * 明确不用（cc-switch 同款判断）：Responses 的 `previous_response_id` 之类「每轮变化的响应游标」
+ * 不是稳定会话身份，当成缓存 key 会导致每轮换 key。
+ */
+
+const CLAUDE_SESSION_HEADERS = ["x-claude-code-session-id", "claude-code-session-id"];
+const LEGACY_MARKER = "_session_";
+
+/** `metadata.user_id` → 会话 id（JSON 里的 session_id，或旧 `_session_` 后缀）。 */
+function sessionFromUserId(userId) {
+  const t = typeof userId === "string" ? userId.trim() : "";
+  if (!t) return null;
+  if (t.startsWith("{")) {
+    try {
+      const j = JSON.parse(t);
+      const s = typeof j?.session_id === "string" ? j.session_id.trim() : "";
+      return s || null;
+    } catch {
+      return null; // 坏 JSON：不猜，交下一档
+    }
+  }
+  const i = t.indexOf(LEGACY_MARKER);
+  if (i < 0) return null;
+  return t.slice(i + LEGACY_MARKER.length) || null;
+}
+
+/**
+ * @param {Record<string, unknown>} headers 入站头（Node 已小写化）
+ * @param {any} body 原始 Anthropic 请求体
+ * @returns {{sessionId: string, source: string} | null}
+ */
+export function claudeSessionId(headers = {}, body = null) {
+  for (const name of CLAUDE_SESSION_HEADERS) {
+    const v = headers?.[name];
+    if (typeof v === "string" && v) return { sessionId: v, source: "header" };
+  }
+  const meta = body && typeof body === "object" && body.metadata && typeof body.metadata === "object" ? body.metadata : null;
+  if (!meta) return null;
+  const fromUser = sessionFromUserId(meta.user_id);
+  if (fromUser) return { sessionId: fromUser, source: "metadata.user_id" };
+  const sid = typeof meta.session_id === "string" ? meta.session_id.trim() : "";
+  if (sid) return { sessionId: sid, source: "metadata.session_id" };
+  return null;
+}

package/src/anthropic/tool-media.js

@@ -0,0 +1,75 @@
+/**
+ * 工具结果里的媒体：抽取 → 排队 → 冲刷成一条 user 消息。
+ *
+ * 1:1 照抄 cc-switch `src-tauri/src/proxy/tool_media.rs:40-145`：
+ *  · 抽取：把 tool_result content 里的媒体块**原地换成一行文本标记**，媒体本体单独收起来；
+ *    原本是字符串的 content 抽完仍是字符串（给原始 data URL / 字符串化 JSON 再套一层引号
+ *    会改变模型看到的东西）；原本是结构化的则走 canonical JSON。
+ *  · 排队：把 `[media output of tool call <id>]` 文本 + 媒体挂在待冲刷表上。
+ *  · 冲刷：**在同轮的普通消息之前**插一条 `role:"user"` 消息承载全部媒体 ——
+ *    OpenAI Chat 的 `role:"tool"` 消息不能带图片分片，故媒体必须另开一条 user 轮。
+ *
+ * 为什么在 /v1/messages 做：改前这里是**静默丢图**（tool_result 里的截图/图片直接消失），
+ * 模型看不到用户给的图，只能靠文字猜。
+ */
+
+export const MEDIA_MOVED_MARKER = "[mslxdff: media moved to the following user turn]";
+
+/**
+ * Anthropic 图片块 → OpenAI Chat 图片分片（base64 / url 两种 source）。
+ * 本仓唯一的「块 → 分片」判据，request-body 的 user 消息图片也走它。
+ * @param {any} block
+ * @returns {{type: "image_url", image_url: {url: string}} | null}
+ */
+export function imagePartOf(block) {
+  const src = block?.source || {};
+  if (src.type === "base64" && src.data) {
+    return { type: "image_url", image_url: { url: `data:${src.media_type || "image/png"};base64,${src.data}` } };
+  }
+  if (src.type === "url" && src.url) return { type: "image_url", image_url: { url: String(src.url) } };
+  return null;
+}
+
+/** 递归把媒体块换成文本标记，媒体本体收进 out。返回替换个数。 */
+function stripMedia(value, out) {
+  if (Array.isArray(value)) return value.map((v) => stripMedia(v, out));
+  if (value && typeof value === "object") {
+    const part = imagePartOf(value);
+    if (part) {
+      out.push(part);
+      return { type: "text", text: MEDIA_MOVED_MARKER };
+    }
+    const o = {};
+    for (const k of Object.keys(value)) o[k] = stripMedia(value[k], out);
+    return o;
+  }
+  return value;
+}
+
+/**
+ * 规划一条 tool_result 的 content：抽出媒体并给出 tool 消息该放的文本。
+ * @param {unknown} content Anthropic tool_result 的 content（字符串或块数组）
+ * @param {(v: unknown) => string} canonicalJson 键序规范化序列化（避免本模块反向依赖）
+ * @returns {{text: string, media: any[]} | null} 无媒体返回 null（保持旧字节不变）
+ */
+export function planToolResultMedia(content, canonicalJson) {
+  const wasString = typeof content === "string";
+  const media = [];
+  const replaced = stripMedia(content, media);
+  if (!media.length) return null;
+  const text = wasString ? String(replaced) : canonicalJson(replaced);
+  return { text, media };
+}
+
+/** 把一条工具调用的媒体挂到待冲刷表（照抄 queue_chat_tool_output_media）。 */
+export function queueToolMedia(pending, toolUseId, media) {
+  if (!Array.isArray(media) || !media.length) return;
+  pending.push({ type: "text", text: `[mslxdff: media output of tool call ${toolUseId}]` });
+  pending.push(...media);
+}
+
+/** 冲刷成一条 user 消息（照抄 flush_pending_chat_tool_media：整批一起给，顺序不变）。 */
+export function flushToolMedia(messages, pending) {
+  if (!pending.length) return;
+  messages.push({ role: "user", content: pending.splice(0, pending.length) });
+}

package/src/anthropic/translate.js

@@ -17,6 +17,7 @@
 import { chunkToString } from "../responses/translate.js";
 import { createTokenCounter } from "../text-tokens.js";
 import { newMessageId, newToolUseId } from "./shared.js";
+import { cacheReadTokens, cacheWriteTokens } from "../usage/cache-fields.js";
 
 // re-export：拆档不改对外接口，调用方与测试仍从本文件取这些符号
 export { messagesToChatBody, toolResultTextOf } from "./request-body.js";
@@ -34,20 +35,21 @@ export { newMessageId, newToolUseId, anthropicError } from "./shared.js";
  */
 export function toAnthropicUsage(u = {}, fallback = null) {
   const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
+  // 缓存读数候选链的**单一来源**在 ../usage/cache-fields.js（metrics.js 的日志投影同源）：
+  // 命中＝「存在且 >0」才采信（显式 0 视为未报，防中转桩 0 掩蔽真命中）；写入＝字段存在即采信。
   const src = u && typeof u === "object" ? u : {};
   const prompt = num(src.prompt_tokens ?? src.input_tokens);
   const output = num(src.completion_tokens ?? src.output_tokens);
-  const cacheRead = num(src.cache_read_input_tokens ?? src.prompt_tokens_details?.cached_tokens ?? src.input_tokens_details?.cached_tokens);
-  const cacheWrite = num(src.cache_creation_input_tokens ?? src.prompt_tokens_details?.cache_creation_input_tokens);
+  const cacheRead = cacheReadTokens(src);
+  const cacheWrite = cacheWriteTokens(src) ?? 0;
   const usage = {
     input_tokens: Math.max(0, prompt - cacheRead - cacheWrite),
     output_tokens: output,
     cache_read_input_tokens: cacheRead,
     cache_creation_input_tokens: cacheWrite,
   };
-  // cache 非零也算「报了」：SDK 通道（upstream-engine/sdk/sse.js 的 usageToOpenAI）会输出
-  // `{prompt_tokens:0, …, prompt_tokens_details:{cached_tokens:N}}` 这种形状，若当未报整条覆盖，
-  // 客户端「input + cache_read」会把同一段前缀算两遍（正是上面扣减要防的事，评审 P2）。
+  // cache 非零也算「报了」：SDK 通道会输出 `{prompt_tokens:0, …, prompt_tokens_details:{cached_tokens:N}}`，
+  // 若当未报整条覆盖，客户端「input + cache_read」会把同一段前缀算两遍。
   if (fallback && !(prompt > 0 || output > 0 || cacheRead > 0 || cacheWrite > 0)) return { ...usage, ...(fallback() || {}) };
   return usage;
 }
@@ -88,14 +90,20 @@ export function textFromChatContent(c) {
 export function chatJsonToAnthropic(chatJson = {}, model = "", opts = {}) {
   const choice = chatJson.choices?.[0] || {};
   const message = choice.message || {};
+  const id = typeof chatJson.id === "string" && chatJson.id.startsWith("msg_") ? chatJson.id : newMessageId();
   const content = [];
+  // 思考块排在正文前：上游把思考放在 message.reasoning_content（DeepSeek/MiMo/聚合网关）；
+  // 照抄 cc-switch transform.rs:614-641 的前置顺序。signature 用本仓占位（ADR-0052：缺签名
+  // Claude Code 直接丢弃整块）；外发开关与流式同源（MSLXDFF_ANTHROPIC_THINKING=0 关）。
+  const rt = typeof message.reasoning_content === "string" ? message.reasoning_content : "";
+  if (opts.thinking === true && rt) content.push({ type: "thinking", thinking: rt, signature: thinkingSignature(id, 0) });
   const text = textFromChatContent(message.content);
   if (text) content.push({ type: "text", text });
   for (const tc of message.tool_calls || []) {
     content.push({ type: "tool_use", id: String(tc.id || newToolUseId()), name: String(tc.function?.name || ""), input: parseToolInput(tc.function?.arguments) });
   }
   return {
-    id: typeof chatJson.id === "string" && chatJson.id.startsWith("msg_") ? chatJson.id : newMessageId(),
+    id,
     type: "message",
     role: "assistant",
     model: model || chatJson.model || "",
@@ -112,6 +120,7 @@ function fallbackUsage(opts = {}, content = []) {
   for (const b of content) {
     if (b?.type === "text") counter.add(b.text || "");
     else if (b?.type === "tool_use") counter.add(JSON.stringify(b.input ?? {})); // 只计参数：与流式 pushTool 同口径（name 从不进 gen）
+    else if (b?.type === "thinking") counter.add(b.thinking || ""); // thinking 也按 output 计费（与流式 pushThinking 同口径）
   }
   const n = typeof opts.estInput === "function" ? Number(opts.estInput()) : 0;
   return { input_tokens: Number.isFinite(n) && n > 0 ? Math.floor(n) : 0, output_tokens: counter.tokens() };

package/src/chat-pipeline/index.js

@@ -13,22 +13,6 @@ import { apiKindOf } from "../api-kind.js";
  * 内部组合 Policy→Engine：解析 header/model → 产 order → 委托 engine 执行
  * gateway 仅薄适配：readBody + request:received hook + 调 execute
  */
-/**
- * 指定 free 模型时是否允许横向切同池兄弟（BUG-7）。
- * 缺省开：opencode 免费池的裸 id 模型（`mimo-v2.6-flash-free` 等）语义上就是"免费额度内随便用"，
- * 单个模型额度耗尽不该让整条链路失败。逃生阀 `MSLXDFF_FREE_POOL_FALLBACK=0` 回到"显式指定即锁死"。
- * 只在**非 lockModel**（即不经组内 model-lock 转发）时生效。
- */
-// 同池互备最多横向试几个（含首个指定的那个）：额度类失败常见于"整池都满"，
-// 扫全池只会把快速失败拖成分钟级，试前几个足够区分"这个模型满"与"这池满"。
-const FREE_POOL_MAX = 4;
-
-export function freePoolFallbackOn(env = process.env) {
-  const raw = env.MSLXDFF_FREE_POOL_FALLBACK;
-  if (raw === undefined || raw === null || raw === "") return true;
-  const s = String(raw).trim().toLowerCase();
-  return !(s === "0" || s === "false" || s === "off" || s === "no");
-}
 
 export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, token, plugins, maxHops } = {}) {
   const engine = createEngine();
@@ -91,11 +75,10 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
 
     // order 推导 + plugin model:select 可改
     // 语义：指定模型 = 死锁单模型（本机→组员同款，挂了就报挂，不兜其他 picks）；只有 auto 才轮 picks
-    // 例外：opencode 免费池的裸 id free 模型（mimo-v2.6-flash-free / deepseek-v4.1-flash-free…）
-    // 额度耗尽时允许**同池互备**——见 freePoolFallbackOn()（BUG-7 用户点名诉求）。
+    // 指定模型的额度耗尽时**不换模型**：横向只在同模型的组员/组长间接力（本机出口 IP 耗尽 → 换组员机器），
+    // 模型永不漂移。详见 serial-trial 的 order 单元素路径与 peer 接力。
     // x-mslxdff-auto-provider 头可把 auto 候选限定到单供应商（opencode=裸 id 免费池），-chat 默认带
     let order;
-    let poolFallback = false; // 指定 free 模型时的「同池互备」标记：只有额度类失败才允许继续换兄弟
     if (lockModel) order = [requested];
     else if (useAuto) {
       let cands = auto ? await auto.candidates() : [""];
@@ -108,28 +91,13 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
       }
       order = cands;
     } else {
-      // 指定模型的常态是死锁单模型。**唯一例外**：裸 id 的 free 模型（opencode 免费池），
-      // 且只在**额度类**失败（429 / 具名额度判决）时才横向切同池兄弟——参数错/5xx 照旧原样透传，
-      // 不把「客户端发错了」伪装成换模型成功，也不白烧别的模型额度（见 isPoolSwitchWorthy）。
-      // candidatesFor 的持久化副作用（把指定模型加入勾选集）在任何分支都必须保留。
-      const wantFreePool = Boolean(auto && requested && freePoolFallbackOn() && isFreeModel(requested) && !String(requested).includes("/"));
+      // 指定模型 = 死锁单模型：额度耗尽只换组员/组长（同模型换机器），**绝不换模型**。
+      // candidatesFor 的持久化副作用（把显式指定的模型加入勾选集，供日后 auto 用）必须保留——
+      // 见 auto.js:180「显式指定某模型 = 认可它，自动加入勾选集」，历史上删它会丢勾选记录。
       if (auto && requested) {
-        try {
-          const cands = await auto.candidatesFor(requested);
-          if (wantFreePool && Array.isArray(cands) && cands.length) {
-            // 上限截断：串行换人是"试一试"不是"扫全池"，太多候选会把额度类失败也拖成分钟级
-            const samePool = cands
-              .filter((m) => m === requested || (isFreeModel(m) && !String(m).includes("/")))
-              .slice(0, FREE_POOL_MAX);
-            if (samePool.length > 1) {
-              order = samePool;
-              poolFallback = true;
-              evt("free-pool-fallback", { reqId, model: requested, pool: samePool, size: samePool.length });
-            }
-          }
-        } catch {}
+        try { await auto.candidatesFor(requested); } catch {}
       }
-      if (!order) order = [requested];
+      order = [requested];
     }
     if (!order.length) order = [""];
     const canFallback = order.length > 1;
@@ -163,7 +131,7 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
     await engine.run({
       reqId, startedAt, req, res, body: req?.body, policy,
       useAuto, lockModel, requested, hops,
-      canFallback, canForwardPeers, poolFallback,
+      canFallback, canForwardPeers,
       perf0, stages, mark, evt, logCall, logError, done, handlerCtx,
       auto, upstream, peers, groups, bus, token, plugins, logs,
       order,