mslxdff 0.1.172 → 0.1.173

package/package.json

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

package/src/anthropic/count-tokens.js

@@ -1,39 +1,54 @@
-// /v1/messages/count_tokens 的字符估算（从 translate.js 拆出，控单文件体积 ≤20KB 硬门）。
+// /v1/messages/count_tokens 的 token 估算（从 translate.js 拆出，控单文件体积 ≤20KB 硬门）。
 // 精度非目标：Anthropic 官方说明该端点缺失时客户端本来就退回字符估算。
+// 权重口径的单一来源在 ../text-tokens.js（ADR-0055）：旧版整段 `chars/4` 把中文低报约 4 倍，而客户端
+// 正是拿这个读数决定何时压实上下文 —— 读数偏低就一路不压实，撞上游「上下文超限」才炸。
 import { toolResultTextOf } from "./translate.js";
+import { estimateTextTokens, createTokenCounter } from "../text-tokens.js";
 
-// 图片不吃字符但占真实上下文，按固定面值计；总长设硬上限防极端请求把除法推到 Infinity
+// 图片不吃字符但占真实上下文，按固定面值计；总长设硬上限防极端请求把估算推到天文数字
 const IMAGE_TOKENS = 2000;
-const CHARS_PER_TOKEN = 4;
 const CHAR_CAP = 32_000_000;
 
+// 请求侧按「一条消息」聚成一段再套一次公式：粒度对齐参照实现 wb_proxy.py:14267-14278
+// （每条消息 content 整段一次 + 每个 tool_call 一次）。逐块各套会把「非空至少 1」下限乘上块数
+// —— 几十个 1 字符 text 块能被高报几十倍（评审 P3：方向虽偏高安全，但与生成侧口径分叉就是第二个真相源）。
+function add(acc, text) {
+  if (acc.chars > CHAR_CAP) return; // 超限后停止累计，只保留已计部分与图片面值
+  const s = text == null ? "" : String(text);
+  const c = createTokenCounter();
+  c.add(s);
+  acc.chars += s.length;
+  acc.tokens += c.tokens();
+}
+
 function countMessage(m, acc) {
   if (!m || typeof m !== "object") return;
   const blocks = typeof m.content === "string" ? [{ type: "text", text: m.content }] : Array.isArray(m.content) ? m.content : null;
-  if (!blocks) { acc.chars += JSON.stringify(m.content ?? "").length; return; }
+  if (!blocks) { add(acc, JSON.stringify(m.content ?? "")); return; }
+  const c = createTokenCounter();
+  let chars = 0;
+  const put = (s) => { c.add(s); chars += s.length; };
   for (const b of blocks) {
     if (!b || typeof b !== "object") continue;
-    if (typeof b.text === "string") acc.chars += b.text.length;
-    else if (b.type === "tool_use") acc.chars += String(b.name || "").length + JSON.stringify(b.input ?? {}).length;
-    else if (b.type === "tool_result") acc.chars += toolResultTextOf(b.content).length; // 工具结果是大头，必须算（grill Q7）
-    else if (b.type === "thinking") acc.chars += String(b.thinking || "").length;
+    if (typeof b.text === "string") put(b.text);
+    else if (b.type === "tool_use") put(String(b.name || "") + JSON.stringify(b.input ?? {}));
+    else if (b.type === "tool_result") put(toolResultTextOf(b.content)); // 工具结果是大头，必须算
+    else if (b.type === "thinking") put(String(b.thinking || ""));
     else if (b.type === "image") acc.images += 1;
   }
+  if (acc.chars <= CHAR_CAP) acc.chars += chars;
+  acc.tokens += c.tokens();
 }
 
 /** 字符估算版 token 计数（Anthropic 官方：端点缺失时客户端本来就退回字符估算，精度非目标）。 */
 export function estimateTokens(req = {}) {
-  let chars = 0;
-  let images = 0;
-  const acc = { chars: 0, images: 0 };
+  const acc = { chars: 0, tokens: 0, images: 0 };
   const sys = typeof req.system === "string" ? [{ type: "text", text: req.system }] : Array.isArray(req.system) ? req.system : [];
-  for (const b of sys) acc.chars += b && typeof b.text === "string" ? b.text.length : 0;
+  for (const b of sys) add(acc, b && typeof b.text === "string" ? b.text : "");
   for (const m of Array.isArray(req.messages) ? req.messages : []) countMessage(m, acc);
-  if (Array.isArray(req.tools)) acc.chars += JSON.stringify(req.tools).length;
-  chars = Math.min(acc.chars, CHAR_CAP);
-  images = acc.images;
+  if (Array.isArray(req.tools)) add(acc, JSON.stringify(req.tools));
   // 字段名以 Anthropic 线上为准：`POST /v1/messages/count_tokens` 回 `{"input_tokens": N}`；
   // 额外带一份 count_tokens 仅作人读兼容（Claude Code 读的是 input_tokens）。
-  const n = Math.max(1, Math.ceil(chars / CHARS_PER_TOKEN) + images * IMAGE_TOKENS);
+  const n = Math.max(1, acc.tokens) + acc.images * IMAGE_TOKENS;
   return { input_tokens: n, count_tokens: n };
 }

package/src/anthropic/request-body.js

@@ -0,0 +1,126 @@
+// 请求侧翻译：Anthropic Messages 请求体 → OpenAI chat 请求体（/v1/messages 外壳，ADR-0047）。
+// 从 translate.js 拆出（ADR-0055）：translate.js 贴 20KB 体积硬门，且「入站请求形状」与
+// 「出站响应/usage 翻译」本就是两向关注点，拆后 translate.js 单向 import 本文件，不回环。
+// 对外接口不变：调用方与测试仍从 anthropic/translate.js import（那边 re-export）。
+//
+// 纪律（别改回去）：
+//  * 思考档位**原样透传**（thinking/effort/reasoning_effort/reasoningEffort/extra_body），语义归一交给
+//    各 provider 与 src/thinking-effort.js —— 旧版在此丢掉，下游被迫补默认值（workbuddy 恒 high，ADR-0053）；
+//  * 但**必须主动丢** output_config 原始对象 / context_management / 消息块内 thinking：Claude Code 对
+//    不认识的 model ID 照发全套字段，块内 thinking 无法签发 signature，回传必被上游拒（ADR-0047）。
+import { isServerTool } from "./web-search.js";
+import { newToolUseId } from "./shared.js";
+
+// system 允许字符串或 text 块数组；块间空行连接（缓存语义不保留，上游是 OpenAI）
+function systemTextOf(system) {
+  if (typeof system === "string") return 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;
+}
+
+export function toolResultTextOf(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((p) => (typeof p === "string" ? p : p && typeof p.text === "string" ? p.text : ""))
+      .filter(Boolean)
+      .join("\n");
+  }
+  return content == null ? "" : String(content);
+}
+
+/** Anthropic Messages 请求体 → OpenAI chat 请求体（直接喂既有 ChatPipeline）。 */
+export function messagesToChatBody(req = {}) {
+  const model = String(req.model || "").trim();
+  if (!model) throw new Error("messages: 缺少 model");
+  const messages = [];
+  const sys = systemTextOf(req.system);
+  if (sys) messages.push({ role: "system", content: sys });
+
+  // 重复 tool_use_id 保首个、丢后续：客户端重试/重放历史会把同一工具结果存两份，
+  // 部分上游按 call_id 查重直接 400（同 responses/translate.js:57-59 的实测教训）。
+  const seenToolResult = new Set();
+
+  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 = [];
+    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 } });
+      } 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 });
+      }
+      // 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 };
+    if (toolCalls.length) msg.tool_calls = toolCalls;
+    messages.push(msg);
+  }
+  // 空会话直接 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 || {} },
+    }));
+  }
+  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;
+  // 思考档位原样透传（不解释语义，语义归一交给各 provider / src/thinking-effort.js）：
+  // 客户端显式声明必须一路带到上游，旧版在此丢掉 → 下游被迫补默认值（workbuddy 恒 high）。
+  if (req.thinking != null) body.thinking = req.thinking;
+  // 档位载体只收「非空 trimmed 字符串」：空串声明不算声明，不该发出去顶掉下游默认值。
+  for (const k of ["effort", "reasoning_effort", "reasoningEffort"]) {
+    const v = typeof req[k] === "string" ? req[k].trim() : "";
+    if (v) body[k] = v;
+  }
+  if (req.extra_body != null) body.extra_body = req.extra_body;
+  // output_config.effort 是 Claude Code 的另一档位载体（beta），原始对象上游不认故不外发，
+  // 但档位本身不能丢 → 归一到 reasoning_effort（客户端已显式声明时以声明为准）。
+  const ocEffort = req.output_config && typeof req.output_config === "object" ? req.output_config.effort : undefined;
+  if (ocEffort != null && body.reasoning_effort == null && body.reasoningEffort == null) {
+    body.reasoning_effort = ocEffort;
+  }
+  return body;
+}

package/src/anthropic/shared.js

@@ -0,0 +1,18 @@
+// /v1/messages 外壳的公共原语：消息/工具 id 与 Anthropic 协议错误体。
+// ADR-0055 把请求侧拆去 request-body.js 时独立成档，让 request-body.js 与 translate.js 单向依赖它，
+// 避免两文件互相 import 成环（函数提升虽能跑，顶层常量会 TDZ，属定时炸弹）。
+// 共用面：src/anthropic/request-body.js（newToolUseId）、src/anthropic/translate.js（newMessageId/
+// newToolUseId，并对外 re-export 三个符号，调用方与测试的 import 路径不变）。
+
+let seq = 0;
+export function newMessageId() {
+  return `msg_${Date.now().toString(36)}${(seq++).toString(36)}`;
+}
+export function newToolUseId() {
+  return `toolu_${Date.now().toString(36)}${(seq++).toString(36)}`;
+}
+
+/** Anthropic 协议错误体形状（非流式 JSON 与流式 in-band error 帧共用）。 */
+export function anthropicError(type, message) {
+  return { type: "error", error: { type: String(type || "api_error"), message: String(message || "error").slice(0, 500) } };
+}

package/src/anthropic/sse-aggregate.js

@@ -0,0 +1,56 @@
+// 上游只会流式、客户端要非流式时的 SSE 聚合（ADR-0055）。
+// 从 `src/routes/messages-route.js` 抽出：该文件贴着 20KB 体积硬门（20306/20480），本单要加的
+// usage 兜底接线必须先进一段，故沿用 ADR-0053 把 count_tokens 估算器拆成独立文件的同类先例。
+// 共用面：唯一调用方 `src/routes/messages-route.js`（体积门驱动的等价搬移，非新抽象）。
+//
+// 逐行吃 `data:` 帧聚成 chat.completion JSON（与 qoder/aggregate.js、zcode 非流式聚合同构），
+// 出口复用 `chatJsonToAnthropic`；一帧都没有或夹带 in-band 错误帧时返回 null，落回原有 502 + errorText
+// 路径 —— 错误绝不聚合成正文。
+
+/**
+ * @param text collector 收到的原始响应体（SSE 帧序列）
+ * @param model 回显给客户端的模型名
+ * @returns chat.completion 形状对象，或 null（无有效帧 / 夹带错误帧）
+ */
+export function sseToChatJson(text, model) {
+  let content = "";
+  let finish = "";
+  let usage = null;
+  let sawChunk = false;
+  const toolSlots = new Map();
+  for (const raw of String(text || "").split("\n")) {
+    const line = raw.trim();
+    if (!line.startsWith("data:")) continue; // 注释帧/keepalive/事件名行全跳过
+    const payload = line.slice(5).trim();
+    if (!payload || payload === "[DONE]") continue;
+    let chunk;
+    try { chunk = JSON.parse(payload); } catch { continue; }
+    if (chunk?.error) return null;
+    sawChunk = true;
+    const choice = chunk.choices?.[0] || {};
+    const delta = choice.delta || {};
+    if (choice.finish_reason) finish = choice.finish_reason;
+    if (chunk.usage) usage = chunk.usage;
+    if (typeof delta.content === "string" && delta.content) content += delta.content;
+    for (const tc of delta.tool_calls || []) {
+      const slot = Number(tc?.index ?? 0);
+      let t = toolSlots.get(slot);
+      if (!t) { t = { id: "", name: "", args: "" }; toolSlots.set(slot, t); }
+      if (tc?.id) t.id = String(tc.id);
+      if (tc?.function?.name) t.name += String(tc.function.name);
+      if (tc?.function?.arguments) t.args += String(tc.function.arguments);
+    }
+  }
+  if (!sawChunk) return null;
+  const toolCalls = [...toolSlots.values()].map((t, i) => ({ id: t.id || `call_${i}`, type: "function", function: { name: t.name, arguments: t.args || "{}" } }));
+  const message = { role: "assistant", content: content || (toolCalls.length ? null : "") };
+  if (toolCalls.length) message.tool_calls = toolCalls;
+  const out = {
+    id: "", object: "chat.completion", created: Math.floor(Date.now() / 1000), model,
+    choices: [{ index: 0, message, finish_reason: finish || (toolCalls.length ? "tool_calls" : "stop") }],
+  };
+  // 上游真报过 usage 才带这个字段：旧版合成 `{prompt_tokens:0,…}` 会把「未报」伪装成「报了 0」，
+  // 让翻译层的兜底判据永远看不到真实形状（ADR-0055 决策 3）。
+  if (usage) out.usage = usage;
+  return out;
+}

package/src/anthropic/translate.js

@@ -1,148 +1,26 @@
 /**
- * Anthropic Messages ⇄ OpenAI chat 翻译层（/v1/messages 外壳，ADR-0047）。
+ * Anthropic Messages 出站翻译层：chat → Anthropic message / SSE 具名事件（/v1/messages 外壳，ADR-0047）。
  * 纯函数，无网络、无副作用；出站形状依据 code.claude.com/docs/en/llm-gateway-protocol
  * 与参考实现 lamdt1/ms-copilot365-2api/app/formatters/anthropic_sse.py。
+ * 分档（ADR-0055，为守本文件 ≤20KB 体积硬门；对外 import 路径全走本文件、调用方零改动）：
+ *  · 请求侧 Anthropic → chat 在 ./request-body.js；
+ *  · 消息/工具 id 与协议错误体在 ./shared.js；
+ *  · token 估算的单一来源在 ../text-tokens.js（上游未报 usage 时由它兜底）。
  *
  * 与 src/responses/translate.js 的三点关键差异：
  *  1) Anthropic 的 content block **只封口不复用**（Responses 侧 ensureTextItem 会复用已开项）；
  *  2) 事件是具名的（`event: <type>` + `data:`），且**没有 `data: [DONE]`**，收场只有
  *     `message_delta`+`message_stop`（成功）或一帧 `error`（失败）——见 grill-decisions.md Q2；
- *  3) 请求侧**保留思考档位**（thinking/effort/reasoning_effort/reasoningEffort/extra_body 原样透传给
- *     pipeline，语义归一交给各 provider 与 src/thinking-effort.js），但**必须主动丢** output_config/
- *     context_management 与消息块内的 thinking：Claude Code 对不认识的 model ID 照发全套字段，而块内
- *     thinking 我们无法签发 signature，回传必被上游拒（ADR-0047）。
+ *  3) 请求侧**保留思考档位**、**必须主动丢** output_config/context_management 与消息块内 thinking
+ *     （块内 thinking 我们无法签发 signature，回传必被上游拒）——细则见 ./request-body.js 头（ADR-0047）。
  */
 import { chunkToString } from "../responses/translate.js";
-import { isServerTool } from "./web-search.js";
+import { createTokenCounter } from "../text-tokens.js";
+import { newMessageId, newToolUseId } from "./shared.js";
 
-let seq = 0;
-export function newMessageId() {
-  return `msg_${Date.now().toString(36)}${(seq++).toString(36)}`;
-}
-export function newToolUseId() {
-  return `toolu_${Date.now().toString(36)}${(seq++).toString(36)}`;
-}
-
-/** Anthropic 协议错误体形状（非流式 JSON 与流式 in-band error 帧共用）。 */
-export function anthropicError(type, message) {
-  return { type: "error", error: { type: String(type || "api_error"), message: String(message || "error").slice(0, 500) } };
-}
-
-// ---------- 请求：Anthropic → chat ----------
-
-// system 允许字符串或 text 块数组；块间空行连接（缓存语义不保留，上游是 OpenAI）
-function systemTextOf(system) {
-  if (typeof system === "string") return 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;
-}
-
-export function toolResultTextOf(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content
-      .map((p) => (typeof p === "string" ? p : p && typeof p.text === "string" ? p.text : ""))
-      .filter(Boolean)
-      .join("\n");
-  }
-  return content == null ? "" : String(content);
-}
-
-/** Anthropic Messages 请求体 → OpenAI chat 请求体（直接喂既有 ChatPipeline）。 */
-export function messagesToChatBody(req = {}) {
-  const model = String(req.model || "").trim();
-  if (!model) throw new Error("messages: 缺少 model");
-  const messages = [];
-  const sys = systemTextOf(req.system);
-  if (sys) messages.push({ role: "system", content: sys });
-
-  // 重复 tool_use_id 保首个、丢后续：客户端重试/重放历史会把同一工具结果存两份，
-  // 部分上游按 call_id 查重直接 400（同 responses/translate.js:57-59 的实测教训）。
-  const seenToolResult = new Set();
-
-  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 = [];
-    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 } });
-      } 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 });
-      }
-      // 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 };
-    if (toolCalls.length) msg.tool_calls = toolCalls;
-    messages.push(msg);
-  }
-  // 空会话直接 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 || {} },
-    }));
-  }
-  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;
-  // 思考档位原样透传（不解释语义，语义归一交给各 provider / src/thinking-effort.js）：
-  // 客户端显式声明必须一路带到上游，旧版在此丢掉 → 下游被迫补默认值（workbuddy 恒 high）。
-  if (req.thinking != null) body.thinking = req.thinking;
-  // 档位载体只收「非空 trimmed 字符串」：空串声明不算声明，不该发出去顶掉下游默认值。
-  for (const k of ["effort", "reasoning_effort", "reasoningEffort"]) {
-    const v = typeof req[k] === "string" ? req[k].trim() : "";
-    if (v) body[k] = v;
-  }
-  if (req.extra_body != null) body.extra_body = req.extra_body;
-  // output_config.effort 是 Claude Code 的另一档位载体（beta），原始对象上游不认故不外发，
-  // 但档位本身不能丢 → 归一到 reasoning_effort（客户端已显式声明时以声明为准）。
-  const ocEffort = req.output_config && typeof req.output_config === "object" ? req.output_config.effort : undefined;
-  if (ocEffort != null && body.reasoning_effort == null && body.reasoningEffort == null) {
-    body.reasoning_effort = ocEffort;
-  }
-  return body;
-}
+// re-export：拆档不改对外接口，调用方与测试仍从本文件取这些符号
+export { messagesToChatBody, toolResultTextOf } from "./request-body.js";
+export { newMessageId, newToolUseId, anthropicError } from "./shared.js";
 
 // ---------- usage / stop_reason ----------
 
@@ -151,20 +29,27 @@ export function messagesToChatBody(req = {}) {
  * Anthropic 的 `input_tokens` **不含**缓存读命中的部分（两者分开计费），而上游
  * `prompt_tokens` 是含缓存的总输入 —— 故命中数要从 input 里扣掉，否则客户端把同一段
  * 前缀算两遍（读数虚高）。
+ * `fallback()` 只在**上游整条未报**（缺字段，或 prompt/output/cache_read/cache_creation 四项全为 0）时才用：
+ * 真实模型对非空 prompt 不可能报 0，照抄 0 会让客户端的上下文计度停在原地、永不压实（ADR-0055 决策 3）。
  */
-export function toAnthropicUsage(u = {}) {
+export function toAnthropicUsage(u = {}, fallback = null) {
   const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 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);
-  return {
+  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）。
+  if (fallback && !(prompt > 0 || output > 0 || cacheRead > 0 || cacheWrite > 0)) return { ...usage, ...(fallback() || {}) };
+  return usage;
 }
 
 function toStopReason(finish, hasToolUse) {
@@ -200,7 +85,7 @@ export function textFromChatContent(c) {
   return t;
 }
 
-export function chatJsonToAnthropic(chatJson = {}, model = "") {
+export function chatJsonToAnthropic(chatJson = {}, model = "", opts = {}) {
   const choice = chatJson.choices?.[0] || {};
   const message = choice.message || {};
   const content = [];
@@ -217,10 +102,21 @@ export function chatJsonToAnthropic(chatJson = {}, model = "") {
     content: content.length ? content : [{ type: "text", text: "" }],
     stop_reason: toStopReason(choice.finish_reason, content.some((b) => b.type === "tool_use")),
     stop_sequence: null,
-    usage: toAnthropicUsage(chatJson.usage),
+    usage: toAnthropicUsage(chatJson.usage, () => fallbackUsage(opts, content)),
   };
 }
 
+// 上游整条未报 usage 时的兜底（ADR-0055 决策 3）：请求侧用注入的 estInput，生成侧按已产出的块估。
+function fallbackUsage(opts = {}, content = []) {
+  const counter = createTokenCounter();
+  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）
+  }
+  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() };
+}
+
 // ---------- 流式响应：chat SSE chunk → Anthropic 具名事件 ----------
 
 // thinking 块必须在 content_block_stop **之前**交一帧 signature_delta，缺它 Claude Code 把整块静默丢弃
@@ -240,6 +136,18 @@ export function createAnthropicChunkTranslator(model = "", opts = {}) {
   const created = Math.floor(Date.now() / 1000);
   const ev = (type, extra = {}) => ({ type, ...extra });
 
+  // 请求侧 token 估算（ADR-0055 决策 3/5）：路由注入 `opts.estInput()`，memoize —— `message_start` 必须在
+  // 首块前就带 input_tokens，全文只能扫一遍；上游后报实测 usage 时估算只留在首帧，不进 message_delta。
+  let estCached = null;
+  const estInput = () => {
+    if (estCached == null) {
+      const n = typeof opts.estInput === "function" ? Number(opts.estInput()) : 0;
+      estCached = Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+    }
+    return estCached;
+  };
+  const gen = createTokenCounter(); // 生成侧累计（text + thinking + tool 参数增量）
+
   let buf = "";
   let nextIndex = 0;
   let open = null; // 当前未封口块：{ index, kind: "text"|"thinking"|"tool_use", text? }
@@ -266,6 +174,7 @@ export function createAnthropicChunkTranslator(model = "", opts = {}) {
     const out = [];
     if (!open || open.kind !== "text") openBlock("text", { type: "text", text: "" }, out);
     open.text += delta;
+    gen.add(delta); // 生成侧只累计字数、末帧一次套公式：逐帧套会把参照实现的 +1 下限乘上帧数
     out.push(ev("content_block_delta", { index: open.index, delta: { type: "text_delta", text: delta } }));
     return out;
   }
@@ -273,6 +182,7 @@ export function createAnthropicChunkTranslator(model = "", opts = {}) {
     const out = [];
     if (!open || open.kind !== "thinking") openBlock("thinking", { type: "thinking", thinking: "", signature: "" }, out);
     open.text += delta;
+    gen.add(delta); // thinking 也按 output 计费（ADR-0055 grill Q6）
     out.push(ev("content_block_delta", { index: open.index, delta: { type: "thinking_delta", thinking: delta } }));
     return out;
   }
@@ -293,15 +203,15 @@ export function createAnthropicChunkTranslator(model = "", opts = {}) {
     if (tc?.id) t.id = String(tc.id);
     if (tc?.function?.name) t.name += String(tc.function.name);
     const frag = tc?.function?.arguments ? String(tc.function.arguments) : "";
-    if (frag) { dbg.toolDeltas++; t.args += frag; }
+    if (frag) { dbg.toolDeltas++; t.args += frag; gen.add(frag); }
     if (!t.announced && t.id && t.name) announceTool(t, out);
     else if (t.announced && frag && open && open.index === t.index) out.push(ev("content_block_delta", { index: t.index, delta: { type: "input_json_delta", partial_json: frag } }));
-    else if (t.announced && frag) dbg.lateToolDeltas++; // 块已封口后才来的参数增量：发出即违规帧，丢弃并留读数
+    else if (t.announced && frag) dbg.lateToolDeltas++; // 块已封口后才来的参数增量：发出即违规帧，丢弃但上面已计入 gen（output_tokens 取计费口径：模型确实生成了这些字节）
     return out;
   }
 
   function begin() {
-    return [ev("message_start", { message: { id, type: "message", role: "assistant", model, content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 } } })];
+    return [ev("message_start", { message: { id, type: "message", role: "assistant", model, content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: estInput(), output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 } } })];
   }
 
   function push(data) {
@@ -329,6 +239,7 @@ export function createAnthropicChunkTranslator(model = "", opts = {}) {
       if (rc) {
         dbg.thinkingChars += rc.length;
         if (emitThinking) out.push(...pushThinking(rc)); // 只发 thinking_delta，无 signature 可发
+        else gen.add(rc); // `MSLXDFF_ANTHROPIC_THINKING=0` 时思考字节仍是真实生成，兜底 output 照计（在此加、不在 pushThinking 内加，避免双计）
       }
     }
     return out;
@@ -341,7 +252,7 @@ export function createAnthropicChunkTranslator(model = "", opts = {}) {
       if (!t.announced && (t.id || t.name || t.args)) announceTool(t, out); // 只有 arguments 无 name 的退化收尾
     }
     closeOpen(out);
-    out.push(ev("message_delta", { delta: { stop_reason: toStopReason(fr, sawToolUse), stop_sequence: null }, usage: toAnthropicUsage(usage || lastUsage) }));
+    out.push(ev("message_delta", { delta: { stop_reason: toStopReason(fr, sawToolUse), stop_sequence: null }, usage: toAnthropicUsage(usage || lastUsage, () => ({ input_tokens: estInput(), output_tokens: gen.tokens() })) }));
     out.push(ev("message_stop"));
     return out;
   }

package/src/routes/messages-route.js

@@ -22,6 +22,7 @@ import {
   anthropicError,
 } from "../anthropic/translate.js";
 import { estimateTokens } from "../anthropic/count-tokens.js";
+import { sseToChatJson } from "../anthropic/sse-aggregate.js";
 import {
   detectSearchRequest,
   runWebSearch,
@@ -100,47 +101,6 @@ function tryAggregate(text) {
     return null;
   }
 }
-// 客户端要非流式而上游只会流式（workbuddy 在 provider 层写死 stream:true，SSE 硬吃回来）：
-// collector 收到的 text 是 SSE 帧序列而非 JSON，JSON.parse 必炸 → 此前恒 502。逐行吃 data: 帧
-// 聚成 chat.completion JSON（与 qoder/aggregate.js、zcode 非流式聚合同构），出口复用 chatJsonToAnthropic；
-// 一帧都没有或夹带 in-band 错误帧时返回 null，落回原有 502 + errorText 路径（错误绝不聚合成正文）。
-function sseToChatJson(text, model) {
-  let content = "";
-  let finish = "";
-  let usage = null;
-  let sawChunk = false;
-  const toolSlots = new Map();
-  for (const raw of String(text || "").split("\n")) {
-    const line = raw.trim();
-    if (!line.startsWith("data:")) continue; // 注释帧/keepalive/事件名行全跳过
-    const payload = line.slice(5).trim();
-    if (!payload || payload === "[DONE]") continue;
-    let chunk;
-    try { chunk = JSON.parse(payload); } catch { continue; }
-    if (chunk?.error) return null;
-    sawChunk = true;
-    const choice = chunk.choices?.[0] || {};
-    const delta = choice.delta || {};
-    if (choice.finish_reason) finish = choice.finish_reason;
-    if (chunk.usage) usage = chunk.usage;
-    if (typeof delta.content === "string" && delta.content) content += delta.content;
-    for (const tc of delta.tool_calls || []) {
-      const slot = Number(tc?.index ?? 0);
-      let t = toolSlots.get(slot);
-      if (!t) { t = { id: "", name: "", args: "" }; toolSlots.set(slot, t); }
-      if (tc?.id) t.id = String(tc.id);
-      if (tc?.function?.name) t.name += String(tc.function.name);
-      if (tc?.function?.arguments) t.args += String(tc.function.arguments);
-    }
-  }
-  if (!sawChunk) return null;
-  const toolCalls = [...toolSlots.values()].map((t, i) => ({ id: t.id || `call_${i}`, type: "function", function: { name: t.name, arguments: t.args || "{}" } }));
-  const message = { role: "assistant", content: content || (toolCalls.length ? null : "") };
-  if (toolCalls.length) message.tool_calls = toolCalls;
-  return { id: "", object: "chat.completion", created: Math.floor(Date.now() / 1000), model,
-    choices: [{ index: 0, message, finish_reason: finish || (toolCalls.length ? "tool_calls" : "stop") }],
-    usage: usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 } };
-}
 
 
 /**
@@ -348,10 +308,14 @@ export async function messagesHandler(ctx) {
   }));
   const pipeline = createChatPipeline(ctx);
   const fakeReq = withBody(req, chatBody);
+  // ADR-0055：请求侧 token 估算 thunk（路由层也 memoize，与决策 4「每请求至多算一次」对齐；
+  // translator 内部还有一层 memoize，双保险）。
+  let estCache;
+  const estInput = () => (estCache ??= estimateTokens(body).input_tokens);
   const forwardClose = (shim) => { try { req.on?.("close", () => shim.emit("close")); } catch { /* ignore */ } };
   try {
     if (chatBody.stream) {
-      const translator = createAnthropicChunkTranslator(chatBody.model, { thinking: emitThinking() });
+      const translator = createAnthropicChunkTranslator(chatBody.model, { thinking: emitThinking(), estInput });
       const live = createAnthropicForwarder(res, translator);
       forwardClose(live);
       await pipeline.execute({ req: fakeReq, res: live });
@@ -372,11 +336,11 @@ export async function messagesHandler(ctx) {
       }
       // 上游偶发非 chat 形状（无 choices）：包成单 text 块，绝不 500（照 responses-route.js 先例）
       if (!Array.isArray(chatJson.choices)) {
-        const r = chatJsonToAnthropic({ choices: [{ message: { content: String(text).slice(0, 8000) } }] }, chatBody.model);
+        const r = chatJsonToAnthropic({ choices: [{ message: { content: String(text).slice(0, 8000) } }] }, chatBody.model, { estInput });
         alog("done-nonchat", JSON.stringify({ ms: Date.now() - t0, bytes: text.length }));
         return json(res, 200, r);
       }
-      const out = chatJsonToAnthropic(chatJson, chatBody.model);
+      const out = chatJsonToAnthropic(chatJson, chatBody.model, { estInput });
       alog("done-json", JSON.stringify({ ms: Date.now() - t0, status, blocks: out.content.length, stop: out.stop_reason, usage: out.usage }));
       return json(res, 200, out);
     }

package/src/text-tokens.js

@@ -0,0 +1,52 @@
+// `/v1/messages` 面 token 估算的单一来源（ADR-0055）：`count_tokens` 读数与响应 `usage` 兜底共用一个公式。
+// 共用面：`src/anthropic/count-tokens.js`（请求侧逐段累加，走 `estimateTextTokens`）、
+// `src/anthropic/translate.js`（上游未报 usage 时的兜底与流式生成侧累计，走 `createTokenCounter`）。
+// 两处必须同源，否则 `count_tokens` 与响应 `usage` 会各说一套读数
+// —— 同 ADR-0053 把 effort 词表收成单一来源的理由。
+//
+// 公式照抄参照实现 `wb_proxy.py:12841-12848`：`cjk + max(1, int(other / 3.6))`（空文本 0），
+// CJK 区间 = \u4e00-\u9fff 主区 + \u3400-\u4dbf 扩展 A。自造系数＝造第二个真相源（design.md 决策 2）。
+// 实现不抄 `re.sub` 再数长度差：那要额外分配一份与原文等长的新串，本实现单遍扫描、无分配。
+// 与 Python 的两处已知差异（不影响本仓自洽，但别写成「逐值相等」）：① astral 字符（emoji）JS 按
+// 2 个 UTF-16 单元计、Python 按 1 个码点计 —— emoji 密集文本可差到 2 倍以上；② falsy 非串（`0`/`false`）
+// Python 直接返回 0、本实现按 `String()` 后非空计 ≥1。现所有调用方传的都是字符串，两条均不可达。
+
+const CJK_HI_START = 0x4e00;
+const CJK_HI_END = 0x9fff; // 主区，占实际中文文本的绝对多数
+const CJK_EXT_A_START = 0x3400;
+const CJK_EXT_A_END = 0x4dbf;
+const OTHER_CHARS_PER_TOKEN = 3.6;
+
+/**
+ * 跨多段累计的计数器。逐段各套一次公式会把参照实现的 `max(1, …)` 下限乘上段数
+ * （流式按 1~3 字一帧下发时，1000 个 ASCII 字会被估成 1000 tokens 而非 277），
+ * 所以累计的是字数、最后一次性套公式。
+ * @returns {{ add: (text: unknown) => void, tokens: () => number }}
+ */
+export function createTokenCounter() {
+  let cjk = 0;
+  let other = 0;
+  return {
+    add(text) {
+      if (text == null) return;
+      const s = typeof text === "string" ? text : String(text);
+      for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c >= CJK_HI_START && c <= CJK_HI_END) cjk++;
+        else if (c >= CJK_EXT_A_START && c <= CJK_EXT_A_END) cjk++;
+        else other++;
+      }
+    },
+    tokens() {
+      if (cjk + other <= 0) return 0; // 空文本给 0，不吃 +1 下限
+      return cjk + Math.max(1, Math.floor(other / OTHER_CHARS_PER_TOKEN));
+    },
+  };
+}
+
+/** 单段文本的 token 估算（CJK 每字 1 token，其余每 3.6 字符 1 token，非空至少 1）。 */
+export function estimateTextTokens(text) {
+  const counter = createTokenCounter();
+  counter.add(text);
+  return counter.tokens();
+}