dsh-router-core 0.3.15 → 0.3.18

package/docs/suppliers.md

@@ -80,12 +80,22 @@ js 报告**此刻**观察到的账户状况,而不是把上游原始响应丢给
 | `transport` | 网络/连接层失败(没拿到 HTTP 状态) |
 | `unknown` | 说不清是什么错 |
 | `no_such_model` | **这个模型不属于本供应商**(不是账号的失败) |
+| `bad_request` | **请求本身不合法,被上游拒**(参数错/图片认不出/tool_call 配对断裂;不是账号的失败) |
 
 **`no_such_model` 是必须的,不能拿 `unavailable` 顶替。** 后者在核心策略里会
 把**这个号 × 这个模型**冷掉——组合里每有一个别人家的模型,js 就会对每个账号
 都报一次,于是一个都选不出来(表现为「组合越用越没号可用」)。所以「这个模型
 不属于我」一定要报 `no_such_model`,核心才知道该换供应商而不是换账号。
 
+**`bad_request` 同理,而且更容易踩。** 同一个非法请求对池里**每个号**结果都相同
+——冷号只会把「这条请求有问题」放大成「这个模型 30 秒内谁都别用」。2026-09-15
+读图事故就是这么来的:适配器把带图的 tool-result 排错序导致 tool_call 配对断裂,
+上游回 400/11148,插件当时归 `rate_limit` → money 组合两条腿同时被冷 30s →
+**之后连纯文本请求**也全灭 503。判据:上游明确说「请求参数/形态不对」(如
+CodeBuddy 的 `extError.type = invalid_request_error`,涵盖 11133/11135/11148/
+11128)就报 `bad_request`;只是「上游忙/临时不可用」(11134)仍归 `rate_limit`,
+那种情况换号确实管用。
+
 **js 只说「现在怎么了」,不说「该怎么办」。** 冷却多久、要不要换号
 都是核心的策略(见下),js 不该自己记冷却表——那样每个插件都会长出一份
 互相不一致的实现。
@@ -127,6 +137,7 @@ type ChatOnceResult =
 | `session_dead` | **连接级冷却 30 分钟**(该号所有模型都停用,到期自愈;没有永久禁用——403 分不清凭证死活与风控误伤) |
 | `unavailable` / `transport` / `unknown` | 瞬时短冷却 30s(**每次都冷**,不攒次数) |
 | `no_such_model` | **不惩罚账号**,核心直接跳过整个供应商换下一个 |
+| `bad_request` | **不惩罚账号**(请求非法不是号的错),核心直接跳到下一个模型/供应商 |
 
 - 非流式若聚合后发现**空响应**(无 content / reasoning / tool_calls),请返回
   `{ ok:false, state:'unknown' }` 而不是 `ok:true`——空响应交给核心换号/换模型回退,

package/lib/client-registry.js

@@ -3201,6 +3201,7 @@ window.__ModuleLoader__.load({
 			}, [period, active]);
 			const s = stats;
 			const successRate = s !== null && s.requests !== void 0 && s.requests > 0 ? Math.round((s.okCount ?? 0) / s.requests * 100) : null;
+			const cacheRatio = s !== null && (s.promptTokens ?? 0) > 0 ? Math.round((s.cachedTokens ?? 0) / (s.promptTokens ?? 0) * 100) : null;
 			const estimated = s !== null && ((s.estimatedInputs ?? 0) > 0 || (s.estimatedOutputs ?? 0) > 0);
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 				className: "dshr-tabBody",
@@ -3276,10 +3277,11 @@ window.__ModuleLoader__.load({
 									tone: "ok"
 								}),
 								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatCard, {
-									label: "缓存 Tokens",
-									value: fmtShort(s?.cachedTokens),
-									hint: "命中缓存的输入部分",
-									tone: "default"
+									label: "缓存命中率",
+									value: cacheRatio === null ? "—" : `${cacheRatio}%`,
+									hint: cacheRatio === null ? "命中缓存的输入占比" : `命中 ${fmtShort(s?.cachedTokens)} / 输入 ${fmtShort(s?.promptTokens)}`,
+									tone: cacheRatio !== null && cacheRatio >= 80 ? "ok" : "default",
+									title: "缓存命中率 = 命中缓存的输入 tokens ÷ 总输入 tokens"
 								}),
 								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatCard, {
 									label: "平均耗时",

package/lib/client.js

@@ -3201,6 +3201,7 @@ window.__ModuleLoader__.load({
 			}, [period, active]);
 			const s = stats;
 			const successRate = s !== null && s.requests !== void 0 && s.requests > 0 ? Math.round((s.okCount ?? 0) / s.requests * 100) : null;
+			const cacheRatio = s !== null && (s.promptTokens ?? 0) > 0 ? Math.round((s.cachedTokens ?? 0) / (s.promptTokens ?? 0) * 100) : null;
 			const estimated = s !== null && ((s.estimatedInputs ?? 0) > 0 || (s.estimatedOutputs ?? 0) > 0);
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 				className: "dshr-tabBody",
@@ -3276,10 +3277,11 @@ window.__ModuleLoader__.load({
 									tone: "ok"
 								}),
 								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatCard, {
-									label: "缓存 Tokens",
-									value: fmtShort(s?.cachedTokens),
-									hint: "命中缓存的输入部分",
-									tone: "default"
+									label: "缓存命中率",
+									value: cacheRatio === null ? "—" : `${cacheRatio}%`,
+									hint: cacheRatio === null ? "命中缓存的输入占比" : `命中 ${fmtShort(s?.cachedTokens)} / 输入 ${fmtShort(s?.promptTokens)}`,
+									tone: cacheRatio !== null && cacheRatio >= 80 ? "ok" : "default",
+									title: "缓存命中率 = 命中缓存的输入 tokens ÷ 总输入 tokens"
 								}),
 								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatCard, {
 									label: "平均耗时",

package/lib/index.js

@@ -135,6 +135,10 @@ const RULES = {
 	no_such_model: {
 		cooldown: 0,
 		counts: false
+	},
+	bad_request: {
+		cooldown: 0,
+		counts: false
 	}
 };
 /**
@@ -1048,7 +1052,14 @@ function num(v) {
 * `cached_tokens` 口径照 9router 的 `canonicalizeUsage`：OpenAI 系报的
 * prompt_tokens **已含**缓存，直接透传；Claude 系报的是**不含**缓存的
 * prompt + 单独的 cache_read，要折进来，否则总输入偏小。
-* 判别式就是「有没有 cache_read_input_tokens」。
+*
+* 判别式**不能只看有没有 `cache_read_input_tokens`**：TRAE(SOLO) 借用了这个
+* Claude 字段名，语义却是 OpenAI 的「prompt_tokens 已含缓存」——
+* 于是同时报了 `prompt_tokens=160019` 和 `cache_read_input_tokens=159744`，
+* 旧逻辑无条件相加 → 总量翻倍、命中率被腰斩成 50%。正确判别是**看 prompt
+* 车道**：有 `prompt_tokens` = OpenAI 总语义（已含缓存，**不**再折 cache_read）；
+* 只有 `input_tokens`/`promptTokenCount` = Claude/Gemini 不含缓存，才折。
+* 这与供应商无关、自描述，比把 supplierId 灌进 usage 管线更干净。
 *
 * @returns 归一用量；一个非零字段都没有时返回 null（= 没拿到 usage）
 */
@@ -1057,7 +1068,7 @@ function normalizeUsage(raw) {
 	const u = raw;
 	const cached = num(u.cached_tokens) + num(u.cache_read_input_tokens) + num(u.cachedContentTokenCount) + num(u.prompt_tokens_details?.cached_tokens);
 	let prompt = num(u.prompt_tokens) + num(u.input_tokens) + num(u.promptTokenCount);
-	if (u.cache_read_input_tokens !== void 0) prompt += num(u.cache_read_input_tokens);
+	if (u.cache_read_input_tokens !== void 0 && u.prompt_tokens === void 0) prompt += num(u.cache_read_input_tokens);
 	const completion = num(u.completion_tokens) + num(u.output_tokens) + num(u.candidatesTokenCount);
 	if (prompt === 0 && completion === 0 && cached === 0) return null;
 	return {
@@ -1325,6 +1336,7 @@ function stripAlias(model, alias) {
 *
 * 只对**瞬时**故障等：连接层失败 / 上游不可用（对应 9router 的 502/503/504）。
 * 模型不属于本供应商（no_such_model）绝不能等 —— 它不是故障，等纯属浪费。
+* 请求本身非法（bad_request）同理：换哪个模型都是同一个 400，等也是白等。
 */
 const TRANSIENT_SETTLE_MS = 2e3;
 function isTransient(state) {
@@ -2166,7 +2178,7 @@ var Router = class {
 		if (s.accounts !== void 0 && s.accounts().length === 0) {
 			const r = await s.chatOnce("", req.lv ?? "auto", req);
 			if (!r.ok) {
-				if (r.state === "no_such_model") return false;
+				if (r.state === "no_such_model" || r.state === "bad_request") return false;
 				if (trace !== void 0) trace.lastState = r.state;
 				pool.noteFailure("", req.model, r.state, r.message);
 				return false;
@@ -2187,8 +2199,11 @@ var Router = class {
 			tried.add(uid);
 			const r = await s.chatOnce(uid, req.lv ?? "auto", req);
 			if (!r.ok) {
-				if (r.state === "no_such_model") {
-					if (trace !== void 0) trace.lastError = "no_such_model";
+				if (r.state === "no_such_model" || r.state === "bad_request") {
+					if (trace !== void 0) {
+						trace.lastError = r.state;
+						trace.lastState = r.state;
+					}
 					return false;
 				}
 				pool.noteFailure(uid, req.model, r.state, r.message);
@@ -2298,14 +2313,40 @@ var Router = class {
 * base64）。图片字节经 `resolveAttachments` 读取；读不到时回退为稳定的占位文本，
 * **绝不静默丢图**（丢图 = 模型看到一条没有图的消息却毫无提示）。
 */
+/** tool-result 里图片挂到 user 消息时用的说明文字（与官方适配器一致）。 */
+const TOOL_RESULT_IMAGE_TEXT = "Tool result images";
 async function wireMessages(options, system, attachments) {
 	const out = [];
+	/**
+	* 攒着「tool-result 里带出来的图片」，等这一串 tool 消息**发完**再合并成一条
+	* user 消息补在后面。
+	*
+	* 为什么必须跨消息攒、而不是各消息各发一条：harness 把**每个 tool 结果放
+	* 自己的 user-role 消息**里（读两张图 = 两条消息）。若每条消息各发一个
+	* `user(图)`，wire 就成 `assistant → tool → user(图) → tool → user(图)`——
+	* 中间那条 user 又把 tool_call/tool_result 配对接断了，上游照样 400/11148
+	* （实测：tool,user,tool,user = 400；tool,tool,user(两图) = 200）。
+	* 官方 dsh-llm-deepseek 的 serializeMessagesWithImages 同样这么做。
+	*/
+	let pendingToolImages = [];
+	const flushToolImages = () => {
+		if (pendingToolImages.length === 0) return;
+		out.push({
+			role: "user",
+			content: [{
+				type: "text",
+				text: TOOL_RESULT_IMAGE_TEXT
+			}, ...pendingToolImages]
+		});
+		pendingToolImages = [];
+	};
 	if (typeof system === "string" && system !== "") out.push({
 		role: "system",
 		content: system
 	});
 	for (const message of options.messages) {
 		if (message.role === "system") {
+			flushToolImages();
 			out.push({
 				role: "system",
 				content: flattenText(message.content)
@@ -2313,6 +2354,7 @@ async function wireMessages(options, system, attachments) {
 			continue;
 		}
 		if (message.role === "assistant") {
+			flushToolImages();
 			const text = flattenText(message.content);
 			const toolCalls = message.content.filter((b) => b.type === "tool-call").map((b) => ({
 				id: b.id,
@@ -2332,32 +2374,42 @@ async function wireMessages(options, system, attachments) {
 			continue;
 		}
 		const toolResults = message.content.filter((b) => b.type === "tool-result");
-		if (hasImageBlock(message.content)) {
-			const parts = await contentParts(message.content, attachments, options.signal);
-			if (parts.length > 0) out.push({
-				role: "user",
-				content: parts
-			});
-			else if (toolResults.length === 0) out.push({
+		const ownParts = await contentParts(message.content.filter((b) => b.type !== "tool-result"), attachments, options.signal);
+		if (ownParts.length > 0 || toolResults.length === 0) {
+			flushToolImages();
+			out.push({
 				role: "user",
-				content: ""
+				content: compactUserContent(ownParts)
 			});
-		} else {
-			const text = flattenText(message.content);
-			if (text.length > 0 || toolResults.length === 0) out.push({
-				role: "user",
+		}
+		for (const result of toolResults) {
+			const parts = await contentParts(result.content, attachments, options.signal);
+			const imageParts = parts.filter((p) => p.type !== "text");
+			const text = parts.filter((p) => p.type === "text").map((p) => p.text ?? "").join("");
+			out.push({
+				role: "tool",
+				tool_call_id: result.toolCallId,
 				content: text
 			});
+			pendingToolImages.push(...imageParts);
 		}
-		for (const result of toolResults) out.push({
-			role: "tool",
-			tool_call_id: result.toolCallId,
-			content: flattenText(result.content)
-		});
 	}
+	flushToolImages();
 	return out;
 }
 /**
+* 纯文本 parts 收成紧凑字符串 wire 形式（无图时不回归成数组）。
+* 与官方适配器的 userContent 同义：只要有非 text part 就保持数组，否则 join。
+*/
+function compactUserContent(parts) {
+	const texts = [];
+	for (const p of parts) {
+		if (p.type !== "text") return parts;
+		texts.push(p.text ?? "");
+	}
+	return texts.join("");
+}
+/**
 * 一块 DSH user/tool-result 内容序列化成 OpenAI content parts（text + image_url）。
 * 纯文本时返回空数组（上层走紧凑字符串路径）。图片转 base64 data URI；
 * attachments 缺失或读取失败时回退稳定占位文本（绝不静默丢图）。
@@ -2470,14 +2522,6 @@ function applyReasoning(body, effort) {
 function flattenText(blocks) {
 	return blocks.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
 }
-/** 内容块里（含递归进 tool-result）是否存在 image 块。决定走数组 content 还是字符串。 */
-function hasImageBlock(blocks) {
-	for (const b of blocks) {
-		if (b.type === "image") return true;
-		if (b.type === "tool-result" && hasImageBlock(b.content)) return true;
-	}
-	return false;
-}
 /** openai SSE payload → DSH StreamChunk 流。导出以便单测锁死 usage 契约。 */
 /**
 * 把上游 SSE 的 `data:` 载荷流翻译成 DSH 的 StreamChunk 事件流。

package/lib/suppliers/nvidia.js

@@ -1,3 +1,4 @@
+import { t as stateFromHttpStatus } from "../http-state-CGDexmJf.js";
 import { join } from "node:path";
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 //#region src/suppliers/nvidia/plugin.ts
@@ -308,7 +309,7 @@ function factory(env) {
 				const msg = `upstream ${upstream.status}: ${text.slice(0, 120)}`;
 				return {
 					ok: false,
-					state: upstream.status === 429 ? "rate_limit" : upstream.status === 401 || upstream.status === 403 ? "session_dead" : upstream.status === 404 ? "unavailable" : "unknown",
+					state: stateFromHttpStatus(upstream.status),
 					message: msg
 				};
 			}

package/lib/suppliers/opencode.js

@@ -1,3 +1,4 @@
+import { t as stateFromHttpStatus } from "../http-state-CGDexmJf.js";
 //#region src/suppliers/opencode/plugin.ts
 const id = "opencode";
 const name = "OpenCode Free";
@@ -106,7 +107,7 @@ function factory(env) {
 				const msg = `upstream ${upstream.status}: ${text.slice(0, 200)}`;
 				return {
 					ok: false,
-					state: upstream.status === 429 ? "rate_limit" : upstream.status === 404 ? "unavailable" : "unknown",
+					state: stateFromHttpStatus(upstream.status),
 					message: msg
 				};
 			}

package/lib/suppliers/openrouter.js

@@ -1,3 +1,4 @@
+import { t as stateFromHttpStatus } from "../http-state-CGDexmJf.js";
 //#region src/suppliers/openrouter/plugin.ts
 const id = "openrouter";
 const name = "OpenRouter";
@@ -196,7 +197,7 @@ function factory(env) {
 				const msg = `upstream ${upstream.status}: ${text.slice(0, 120)}`;
 				return {
 					ok: false,
-					state: upstream.status === 429 ? "rate_limit" : upstream.status === 401 || upstream.status === 403 ? "session_dead" : upstream.status === 404 ? "unavailable" : "unknown",
+					state: stateFromHttpStatus(upstream.status),
 					message: msg
 				};
 			}

package/lib/types/router/usage-tokens.d.ts

@@ -38,7 +38,14 @@ export interface Usage extends UsageTokens {
  * `cached_tokens` 口径照 9router 的 `canonicalizeUsage`：OpenAI 系报的
  * prompt_tokens **已含**缓存，直接透传；Claude 系报的是**不含**缓存的
  * prompt + 单独的 cache_read，要折进来，否则总输入偏小。
- * 判别式就是「有没有 cache_read_input_tokens」。
+ *
+ * 判别式**不能只看有没有 `cache_read_input_tokens`**：TRAE(SOLO) 借用了这个
+ * Claude 字段名，语义却是 OpenAI 的「prompt_tokens 已含缓存」——
+ * 于是同时报了 `prompt_tokens=160019` 和 `cache_read_input_tokens=159744`，
+ * 旧逻辑无条件相加 → 总量翻倍、命中率被腰斩成 50%。正确判别是**看 prompt
+ * 车道**：有 `prompt_tokens` = OpenAI 总语义（已含缓存，**不**再折 cache_read）；
+ * 只有 `input_tokens`/`promptTokenCount` = Claude/Gemini 不含缓存，才折。
+ * 这与供应商无关、自描述，比把 supplierId 灌进 usage 管线更干净。
  *
  * @returns 归一用量；一个非零字段都没有时返回 null（= 没拿到 usage）
  */

package/lib/types/suppliers/contract.d.ts

@@ -56,7 +56,17 @@ export type AccountState = 'ok' | 'rate_limit' | 'quota' | 'session_dead' | 'una
  * 否则组合里每有一个别人家的模型，就会给无关账号攒一次错误，攒够阈值
  * 把它冷却掉（历史上正是这个坑）。
  */
- | 'no_such_model';
+ | 'no_such_model'
+/**
+ * 请求本身不合法，被上游拒（参数错、图片格式不支持、tool_call 配对断裂…）。
+ *
+ * **不是账号的错**：同一个请求对池里每个号都会失败，冷号只会让好号白白
+ * 失效，把一次「这条请求有问题」放大成「这个模型 30 秒内谁都别用」——
+ * 组合里两条腿同时被冷就是这个机制（2026-09-15 读图 11148 事故）。
+ * 核心据此**不惩罚账号**，直接跳出本供应商换下一个模型/供应商。
+ * 与 `no_such_model` 的区别：那个是「模型不归我」，这个是「请求我不认」。
+ */
+ | 'bad_request';
 /** 面板展示的账号此刻状态（插件只报它观察到的部分，冷却由核心叠加）。 */
 export interface SupplierAccountNow {
     uid: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-router-core",
-  "version": "0.3.15",
+  "version": "0.3.18",
   "description": "DSH plugin: a simplified 9router (AI routing gateway). Adds a 路由系统 (Routing System) sidebar entry beside 记忆系统; the panel shows suppliers, account pool, combos, and endpoint/API keys.",
   "type": "module",
   "repository": {

package/src/client/StatsTab.tsx

@@ -421,6 +421,12 @@ export function StatsTab({ onRefresh, refreshing, active, health }: StatsTabProp
   const successRate = s !== null && s.requests !== undefined && s.requests > 0
     ? Math.round(((s.okCount ?? 0) / s.requests) * 100)
     : null
+  // 缓存命中率 = cachedTokens / promptTokens（cachedTokens 是 promptTokens
+  // 的子集：命中缓存的输入部分）。分母 0 = 本周期没有带缓存语义的请求，
+  // 显示 — 而不是硬造 0%（那会把「没数据」和「全未命中」混为一谈）。
+  const cacheRatio = s !== null && (s.promptTokens ?? 0) > 0
+    ? Math.round(((s.cachedTokens ?? 0) / (s.promptTokens ?? 0)) * 100)
+    : null
   // 估算提示：只有真有估算时才显示，别没事吓唬人
   const estimated = s !== null && ((s.estimatedInputs ?? 0) > 0 || (s.estimatedOutputs ?? 0) > 0)
 
@@ -490,8 +496,16 @@ export function StatsTab({ onRefresh, refreshing, active, health }: StatsTabProp
                 hint={(s?.estimatedOutputs ?? 0) > 0 ? '~ 含估算' : undefined}
                 tone="ok"
               />
-              {/* 缓存排在输入/输出之后：它是输入的子集，不是并列的第三种 token */}
-              <StatCard label="缓存 Tokens" value={fmtShort(s?.cachedTokens)} hint="命中缓存的输入部分" tone="default" />
+              {/* 缓存排在输入/输出之后：它是输入的子集，不是并列的第三种 token。
+                  显示命中率而不是 token 数：50.2% 这种数一眼能读出「缓存工作是否正常」，
+                  绝对值要看的话输入 Tokens 卡里已含（title 给出原始数字）。 */}
+              <StatCard
+                label="缓存命中率"
+                value={cacheRatio === null ? '—' : `${cacheRatio}%`}
+                hint={cacheRatio === null ? '命中缓存的输入占比' : `命中 ${fmtShort(s?.cachedTokens)} / 输入 ${fmtShort(s?.promptTokens)}`}
+                tone={cacheRatio !== null && cacheRatio >= 80 ? 'ok' : 'default'}
+                title="缓存命中率 = 命中缓存的输入 tokens ÷ 总输入 tokens"
+              />
               <StatCard
                 label="平均耗时"
                 value={fmtDuration(s?.avgDurationMs)}

package/src/llm/adapter.test.ts

@@ -620,8 +620,110 @@ test('wire：无 attachments 时图片回退占位文本，绝不静默丢图',
     messages: [{ role: 'user', content: [{ type: 'image', attachment: ref }] }],
   }, undefined)
   const user = (body.messages as Array<{ role: string; content: unknown }>).find((m) => m.role === 'user')
-  const parts = (user?.content ?? []) as Array<{ type: string; text?: string }>
-  assert.equal(parts.length, 1)
-  assert.equal(parts[0]?.type, 'text')
-  assert.ok((parts[0]?.text ?? '').includes('image omitted'), '读不到附件时必须给占位文本，图片不能无声消失')
+  // 读不到字节时 parts 只剩一个 text 占位 → 收成紧凑字符串（无图可发，别硬撑数组）
+  const text = typeof user?.content === 'string' ? user.content : JSON.stringify(user?.content)
+  assert.ok(text.includes('image omitted'), '读不到附件时必须给占位文本，图片不能无声消失')
+  assert.ok(!text.includes('image_url'), '读不到字节时不能伪造图片 part')
+})
+
+test('wire：一步两个 read_image（每条一个 user 消息，同现场）→ tool 消息紧跟 assistant，图片合并到末尾', async () => {
+  const ref = {
+    attachmentId: 'sha256:abcdef1234567890',
+    mediaType: 'image/png',
+    bytes: 11,
+    width: 4,
+    height: 2,
+  }
+  // **关键**：harness 把每个 tool 结果放**各自的** user-role 消息里（现场就是
+  // 两条独立消息）。这是第一版修复漏掉的形态——按消息各发一条 user(图) 会得到
+  // `tool,user,tool,user`，上游照样 400/11148。必须跨消息攒图、发完整串再补一条。
+  const body = await captureBodyWith({
+    messages: [
+      { role: 'user', content: [{ type: 'text', text: '读这两张图' }] },
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', id: 'c1', name: 'read_image', arguments: '{}' },
+          { type: 'tool-call', id: 'c2', name: 'read_image', arguments: '{}' },
+        ],
+      },
+      { role: 'user', content: [{ type: 'tool-result', toolCallId: 'c1', content: [{ type: 'text', text: 'tree_assembly.png' }, { type: 'image', attachment: ref }] }] },
+      { role: 'user', content: [{ type: 'tool-result', toolCallId: 'c2', content: [{ type: 'text', text: 'tree_part.png' }, { type: 'image', attachment: ref }] }] },
+    ],
+  }, fakeAttachments())
+  const messages = body.messages as Array<{ role: string; tool_call_id?: string; tool_calls?: Array<{ id: string }>; content: unknown }>
+  assertToolPairingIntact(messages)
+
+  // 两条 tool 消息必须**连续**紧跟 assistant，各自的文本标签留在自己的 tool 里
+  const ai = messages.findIndex((m) => m.role === 'assistant')
+  assert.deepEqual(messages.slice(ai + 1, ai + 3).map((m) => m.role), ['tool', 'tool'], '两条 tool 必须连续，中间不得插 user')
+  assert.equal(messages[ai + 1]?.content, 'tree_assembly.png', '第一条 tool 带自己的标签')
+  assert.equal(messages[ai + 2]?.content, 'tree_part.png', '第二条 tool 带自己的标签')
+
+  // 图片合并到全部 tool 之后的那**一条** user 消息里（两张都在，不静默丢图）
+  const userWithImage = messages.find((m) => m.role === 'user' && Array.isArray(m.content))
+  assert.ok(userWithImage !== undefined, '带图内容必须序列化成 user 消息的 content 数组')
+  const parts = userWithImage.content as Array<{ type: string; text?: string }>
+  assert.equal(parts.filter((p) => p.type === 'image_url').length, 2, '两张图都要发出去')
+  const lastTool = messages.map((m) => m.role).lastIndexOf('tool')
+  const imageAt = messages.indexOf(userWithImage)
+  assert.ok(imageAt > lastTool, `带图 user 消息必须排在全部 tool 消息之后（实际 tool 末位 ${lastTool}，图在 ${imageAt}）`)
+  // 整段 wire 里 user(带图) 只出现一次：插两次就会把 tool 串切断
+  const imageUsers = messages.filter((m) => m.role === 'user' && Array.isArray(m.content))
+  assert.equal(imageUsers.length, 1, '带图 user 消息只能有一条（多条 = 切断了 tool 配对）')
+})
+
+/**
+ * 为什么要有这一组：`read_image` 的结果是**带图的 tool-result**。适配器曾把
+ * 图片和文本一起提成一条 `user` 消息、排在 `tool` 消息**之前**，于是 wire 里
+ * 出现 `assistant(tool_calls) → user(image) → tool`。上游判定 tool_call 与
+ * tool_result 失配，回 400 网关码 11148「tool calls and tool results do not
+ * match」（实测直连复现，把 tool 提前即 200）。
+ *
+ * 后果被池策略放大：11148 当时归 `unknown` → 瞬时冷却 30s；组合 money 两条腿
+ * 都用同一份历史，一条带图请求就把它俩同时冷掉，之后**连纯文本请求**也全灭
+ * 503（用户看到的现象）。所以这条不变式必须在 wire 层锁死：
+ * **assistant 的每个 tool_call 后面必须紧跟配套 tool 消息，中间不得插任何
+ * 其它角色**。
+ */
+
+/** 断言 wire 里 tool_call / tool_result 严格配对且不被插队。 */
+function assertToolPairingIntact(messages: Array<{ role: string; tool_call_id?: string; tool_calls?: Array<{ id: string }> }>): void {
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i]
+    if (m?.role !== 'assistant' || (m.tool_calls ?? []).length === 0) continue
+    const wanted = new Set((m.tool_calls ?? []).map((c) => c.id))
+    // 紧随其后的必须**连续**是配套 tool 消息，中途混入任何别的角色都算失配
+    // （现场踩的就是 user(图) 插在两条 tool 之间，wire 成 tool,user,tool,user）
+    let j = i + 1
+    const satisfied = new Set<string>()
+    while (j < messages.length && messages[j]?.role === 'tool') {
+      const id = messages[j]?.tool_call_id ?? ''
+      assert.ok(wanted.has(id), `第 ${j} 条 tool 消息的 tool_call_id ${JSON.stringify(id)} 不在上一条 assistant 的 tool_calls 里`)
+      satisfied.add(id)
+      j += 1
+    }
+    assert.equal(
+      satisfied.size,
+      wanted.size,
+      `assistant 的 tool_calls 未被紧邻的 tool 消息配齐`
+        + `（中间插了别的角色：${messages.slice(i + 1, j).map((x) => x.role).join(',') || '—'}）`,
+    )
+    for (const id of wanted) {
+      assert.ok(satisfied.has(id), `tool_call ${id} 没有配套 tool 消息（上游会回 11148）`)
+    }
+  }
+}
+
+test('wire：纯文本 tool-result 不因图片逻辑改变顺序（tool 紧跟 assistant）', async () => {
+  const body = await captureBodyWith({
+    messages: [
+      { role: 'user', content: [{ type: 'text', text: '跑一下' }] },
+      { role: 'assistant', content: [{ type: 'tool-call', id: 'c1', name: 'bash', arguments: '{}' }] },
+      { role: 'user', content: [{ type: 'tool-result', toolCallId: 'c1', content: [{ type: 'text', text: 'out' }] }] },
+    ],
+  }, fakeAttachments())
+  const messages = body.messages as Array<{ role: string; tool_call_id?: string; tool_calls?: Array<{ id: string }> }>
+  assertToolPairingIntact(messages)
+  assert.deepEqual(messages.map((m) => m.role), ['user', 'assistant', 'tool'], '纯文本 tool 结果仍紧跟 assistant')
 })

package/src/llm/adapter.ts

@@ -78,18 +78,40 @@ export interface RouterAdapterSource {
  * base64）。图片字节经 `resolveAttachments` 读取；读不到时回退为稳定的占位文本，
  * **绝不静默丢图**（丢图 = 模型看到一条没有图的消息却毫无提示）。
  */
+/** tool-result 里图片挂到 user 消息时用的说明文字（与官方适配器一致）。 */
+const TOOL_RESULT_IMAGE_TEXT = 'Tool result images'
+
 async function wireMessages(options: GenerateOptions, system: string | undefined, attachments: RouterAttachmentStore | undefined): Promise<Array<Record<string, unknown>>> {
   const out: Array<Record<string, unknown>> = []
+  /**
+   * 攒着「tool-result 里带出来的图片」，等这一串 tool 消息**发完**再合并成一条
+   * user 消息补在后面。
+   *
+   * 为什么必须跨消息攒、而不是各消息各发一条：harness 把**每个 tool 结果放
+   * 自己的 user-role 消息**里（读两张图 = 两条消息）。若每条消息各发一个
+   * `user(图)`，wire 就成 `assistant → tool → user(图) → tool → user(图)`——
+   * 中间那条 user 又把 tool_call/tool_result 配对接断了，上游照样 400/11148
+   * （实测：tool,user,tool,user = 400；tool,tool,user(两图) = 200）。
+   * 官方 dsh-llm-deepseek 的 serializeMessagesWithImages 同样这么做。
+   */
+  let pendingToolImages: Array<Record<string, unknown>> = []
+  const flushToolImages = (): void => {
+    if (pendingToolImages.length === 0) return
+    out.push({ role: 'user', content: [{ type: 'text', text: TOOL_RESULT_IMAGE_TEXT }, ...pendingToolImages] })
+    pendingToolImages = []
+  }
   if (typeof system === 'string' && system !== '') {
     out.push({ role: 'system', content: system })
   }
   for (const message of options.messages) {
     if (message.role === 'system') {
       // 手写调用也可能把 system 塞进 messages（one-shot 场景），照旧支持
+      flushToolImages()
       out.push({ role: 'system', content: flattenText(message.content) })
       continue
     }
     if (message.role === 'assistant') {
+      flushToolImages()
       const text = flattenText(message.content)
       const toolCalls = message.content
         .filter((b) => b.type === 'tool-call')
@@ -108,24 +130,50 @@ async function wireMessages(options: GenerateOptions, system: string | undefined
     }
     // user / tool-result
     const toolResults = message.content.filter((b) => b.type === 'tool-result')
-    // 有图 → content 数组；纯文本 → 保持紧凑字符串 wire 形式不回归。
-    if (hasImageBlock(message.content)) {
-      const parts = await contentParts(message.content, attachments, options.signal)
-      if (parts.length > 0) out.push({ role: 'user', content: parts })
-      else if (toolResults.length === 0) out.push({ role: 'user', content: '' })
-    } else {
-      const text = flattenText(message.content)
-      if (text.length > 0 || toolResults.length === 0) out.push({ role: 'user', content: text })
+    // 这条消息自己的（非 tool-result 的）user 部分：文本 + 图片。
+    const ownParts = await contentParts(
+      message.content.filter((b) => b.type !== 'tool-result'),
+      attachments,
+      options.signal,
+    )
+    // 有实质 user 内容（或压根没有 tool 结果）就先发这条 user 消息；
+    // 只有 tool 结果的「纯工具」消息不发空 user，图片留到 pending 里合并。
+    if (ownParts.length > 0 || toolResults.length === 0) {
+      flushToolImages()
+      out.push({ role: 'user', content: compactUserContent(ownParts) })
     }
     for (const result of toolResults) {
+      // **tool 消息必须紧跟 assistant(tool_calls)**：中间插进任何 user 消息，
+      // 上游都会判定 tool_call 与 tool_result 失配 —— codebuddy 直接 400 网关码
+      // 11148「tool calls and tool results do not match」。
+      // 图片不能放进 tool 消息（实测模型会把两张不同的图认成同一张），
+      // 也不能插在两条 tool 之间（同样 400），所以先攒起来、发完整串再补一条 user。
+      const parts = await contentParts(result.content, attachments, options.signal)
+      const imageParts = parts.filter((p) => p.type !== 'text')
+      const text = parts.filter((p) => p.type === 'text').map((p) => (p as { text?: string }).text ?? '').join('')
       // 空结果就发空串，不要替换成 '(no output)' 之类的字面量 —— 模型会
       // 以为工具真的打印了那句话（9router 也是补 content: ""）。
-      out.push({ role: 'tool', tool_call_id: result.toolCallId, content: flattenText(result.content) })
+      out.push({ role: 'tool', tool_call_id: result.toolCallId, content: text })
+      pendingToolImages.push(...imageParts)
     }
   }
+  flushToolImages()
   return out
 }
 
+/**
+ * 纯文本 parts 收成紧凑字符串 wire 形式（无图时不回归成数组）。
+ * 与官方适配器的 userContent 同义：只要有非 text part 就保持数组，否则 join。
+ */
+function compactUserContent(parts: Array<Record<string, unknown>>): string | Array<Record<string, unknown>> {
+  const texts: string[] = []
+  for (const p of parts) {
+    if (p.type !== 'text') return parts
+    texts.push((p as { text?: string }).text ?? '')
+  }
+  return texts.join('')
+}
+
 /**
  * 一块 DSH user/tool-result 内容序列化成 OpenAI content parts（text + image_url）。
  * 纯文本时返回空数组（上层走紧凑字符串路径）。图片转 base64 data URI；
@@ -238,15 +286,6 @@ function flattenText(blocks: readonly { type: string; text?: string }[]): string
   return blocks.filter((b) => b.type === 'text').map((b) => b.text ?? '').join('')
 }
 
-/** 内容块里（含递归进 tool-result）是否存在 image 块。决定走数组 content 还是字符串。 */
-function hasImageBlock(blocks: readonly { type: string }[]): boolean {
-  for (const b of blocks) {
-    if (b.type === 'image') return true
-    if (b.type === 'tool-result' && hasImageBlock((b as unknown as { content: ReadonlyArray<{ type: string }> }).content)) return true
-  }
-  return false
-}
-
 interface OpenBlock {
   index: number
   kind: 'text' | 'reasoning' | 'tool-call'

package/src/router/account-pool.test.ts

@@ -380,6 +380,22 @@ test('no_such_model 不惩罚账号：不冷却、不计数', () => {
   assert.equal(out?.err_count, 0)
 })
 
+/**
+ * 为什么要有这一条：请求本身非法（如 11133 参数错、11148 tool_call 配对断裂）
+ * 对池里**每个号**结果都相同。曾把这类归 rate_limit → 瞬冷 30s，于是一次
+ * 带图请求把 money 组合两条腿同时冷掉，之后连纯文本请求也全灭 503。
+ * 不惩罚账号，好号才不会替一条坏请求陪葬。
+ */
+test('bad_request 不惩罚账号：不冷却、不计数（一次坏请求不该冷掉整池）', () => {
+  const p = pool()
+  const list = accs(['a'])
+  for (let i = 0; i < 10; i++) p.noteFailure('a', 'm1', 'bad_request', 'codebuddy 11148: tool calls do not match')
+  assert.equal(p.pick(list, [], 'fallback', 'm1'), 'a', '号必须仍然可用')
+  const out = p.decorate(list, 'm1')[0]
+  assert.equal(out?.cooling, false, '请求非法不该把号标成冷却')
+  assert.equal(out?.err_count, 0)
+})
+
 test('状态表：各 AccountState 的处置符合预期', () => {
   const p = pool()
   const list = accs(['rate', 'quota', 'dead', 'unavail'])

package/src/router/account-pool.ts

@@ -76,6 +76,9 @@ const RULES: Record<AccountState, Rule> = {
   unknown: { cooldown: 'transient', counts: false },
   // 模型不属于本供应商：不是账号的错，不冷却也不计数（核心据此换下一个供应商）
   no_such_model: { cooldown: 0, counts: false },
+  // 请求本身非法（上游拒收这个 payload）：同一个请求对池里每个号都会失败，
+  // 冷号只会把「这条请求有问题」放大成「这个模型谁都别用」。不惩罚账号。
+  bad_request: { cooldown: 0, counts: false },
 }
 
 /**

package/src/router/index.ts

@@ -71,6 +71,7 @@ function stripAlias(model: string, alias: string): string {
  *
  * 只对**瞬时**故障等：连接层失败 / 上游不可用（对应 9router 的 502/503/504）。
  * 模型不属于本供应商（no_such_model）绝不能等 —— 它不是故障，等纯属浪费。
+ * 请求本身非法（bad_request）同理：换哪个模型都是同一个 400，等也是白等。
  */
 const TRANSIENT_SETTLE_MS = 2_000
 
@@ -998,7 +999,8 @@ export class Router {
     if (s.accounts !== undefined && s.accounts().length === 0) {
       const r = await s.chatOnce('', req.lv ?? 'auto', req)
       if (!r.ok) {
-        if (r.state === 'no_such_model') return false // 不是我的模型：换供应商，不记账
+        // 模型不属于本供应商、或请求本身被上游拒收：换供应商，不记账
+        if (r.state === 'no_such_model' || r.state === 'bad_request') return false
         if (trace !== undefined) trace.lastState = r.state
         pool.noteFailure('', req.model, r.state, r.message)
         return false
@@ -1028,10 +1030,15 @@ export class Router {
       tried.add(uid)
       const r = await s.chatOnce(uid, req.lv ?? 'auto', req)
       if (!r.ok) {
-        // 模型不属于本供应商：整个供应商都跳过，换号重试没有意义，
-        // 也不能记在账号头上（否则无关账号会被攒够错误冷却掉）
-        if (r.state === 'no_such_model') {
-          if (trace !== undefined) trace.lastError = 'no_such_model'
+        // 模型不属于本供应商、或请求本身被上游拒收：整个供应商都跳过，
+        // 换号重试没有意义，也不能记在账号头上（否则无关账号会被冷掉）。
+        // bad_request（如 tool_call 配对断裂、图片格式不认）对每个号结果相同，
+        // 冷号只会把一次「请求有问题」放大成「这个模型谁都别用」。
+        if (r.state === 'no_such_model' || r.state === 'bad_request') {
+          if (trace !== undefined) {
+            trace.lastError = r.state
+            trace.lastState = r.state
+          }
           return false
         }
         pool.noteFailure(uid, req.model, r.state, r.message)

package/src/router/usage-tokens.ts

@@ -61,7 +61,14 @@ function num(v: unknown): number {
  * `cached_tokens` 口径照 9router 的 `canonicalizeUsage`：OpenAI 系报的
  * prompt_tokens **已含**缓存，直接透传；Claude 系报的是**不含**缓存的
  * prompt + 单独的 cache_read，要折进来，否则总输入偏小。
- * 判别式就是「有没有 cache_read_input_tokens」。
+ *
+ * 判别式**不能只看有没有 `cache_read_input_tokens`**：TRAE(SOLO) 借用了这个
+ * Claude 字段名，语义却是 OpenAI 的「prompt_tokens 已含缓存」——
+ * 于是同时报了 `prompt_tokens=160019` 和 `cache_read_input_tokens=159744`，
+ * 旧逻辑无条件相加 → 总量翻倍、命中率被腰斩成 50%。正确判别是**看 prompt
+ * 车道**：有 `prompt_tokens` = OpenAI 总语义（已含缓存，**不**再折 cache_read）；
+ * 只有 `input_tokens`/`promptTokenCount` = Claude/Gemini 不含缓存，才折。
+ * 这与供应商无关、自描述，比把 supplierId 灌进 usage 管线更干净。
  *
  * @returns 归一用量；一个非零字段都没有时返回 null（= 没拿到 usage）
  */
@@ -77,7 +84,11 @@ export function normalizeUsage(raw: unknown): UsageTokens | null {
 
   // promptTokenCount 是 Gemini 形态；input_tokens 是 Claude 形态
   let prompt = num(u.prompt_tokens) + num(u.input_tokens) + num(u.promptTokenCount)
-  if (u.cache_read_input_tokens !== undefined) prompt += num(u.cache_read_input_tokens)
+  // 有 prompt_tokens = OpenAI 总语义（含缓存）；没有 = Claude/Gemini 不含缓存，
+  // 这时才该把 cache_read 折进来，否则像 TRAE 会加两遍
+  if (u.cache_read_input_tokens !== undefined && u.prompt_tokens === undefined) {
+    prompt += num(u.cache_read_input_tokens)
+  }
 
   const completion = num(u.completion_tokens) + num(u.output_tokens) + num(u.candidatesTokenCount)
 

package/src/router/usage.test.ts

@@ -12,6 +12,7 @@ import {
   tapStreamUsage,
   withEstimates,
   estimateTokens,
+  toTokenUsage,
 } from './usage-tokens.ts'
 import { UsageStore, localDateKey } from './usage-store.ts'
 import { mkdirSync, writeFileSync } from 'node:fs'
@@ -35,6 +36,22 @@ test('归一化：Claude 形态的 prompt 不含缓存，cache_read 要折进输
   assert.deepEqual(u, { promptTokens: 130, completionTokens: 10, cachedTokens: 80 })
 })
 
+test('归一化：TRAE 借 Claude 字段名、语义却是 OpenAI —— 不得重复加 cache（命中率腰斩 bug）', () => {
+  // TRAE(SOLO) 同时报 prompt_tokens（OpenAI 总语义，**已含**缓存）和
+  // cache_read_input_tokens。语义与字段名分属两条车道，判别不能只看后者。
+  // 2026-09-16 实测同一次请求：160019 + 159744 被加两遍 → 319763，命中率腰斩
+  // 成 ~50%；真实命中率 159744/160019 = 99.8%。
+  const u = normalizeUsage({
+    prompt_tokens: 160019,
+    completion_tokens: 307,
+    cache_read_input_tokens: 159744,
+  })
+  assert.deepEqual(u, { promptTokens: 160019, completionTokens: 307, cachedTokens: 159744 }, 'prompt_tokens 已含缓存，不得再加 cache_read')
+  // DISJOINT 折算后必须还原上游真实值：160019 - 159744 = 275 未缓存输入
+  const t = toTokenUsage(u)
+  assert.deepEqual(t, { inputTokens: 275, outputTokens: 307, cacheReadTokens: 159744 })
+})
+
 test('归一化：Gemini 形态（promptTokenCount / usageMetadata）', () => {
   const u = normalizeUsage({ promptTokenCount: 7, candidatesTokenCount: 3, cachedContentTokenCount: 2 })
   assert.deepEqual(u, { promptTokens: 7, completionTokens: 3, cachedTokens: 2 })

package/src/suppliers/contract.ts

@@ -67,6 +67,16 @@ export type AccountState =
    * 把它冷却掉（历史上正是这个坑）。
    */
   | 'no_such_model'
+  /**
+   * 请求本身不合法，被上游拒（参数错、图片格式不支持、tool_call 配对断裂…）。
+   *
+   * **不是账号的错**：同一个请求对池里每个号都会失败，冷号只会让好号白白
+   * 失效，把一次「这条请求有问题」放大成「这个模型 30 秒内谁都别用」——
+   * 组合里两条腿同时被冷就是这个机制（2026-09-15 读图 11148 事故）。
+   * 核心据此**不惩罚账号**，直接跳出本供应商换下一个模型/供应商。
+   * 与 `no_such_model` 的区别：那个是「模型不归我」，这个是「请求我不认」。
+   */
+  | 'bad_request'
 
 /** 面板展示的账号此刻状态（插件只报它观察到的部分，冷却由核心叠加）。 */
 export interface SupplierAccountNow {

package/src/suppliers/http-state.test.ts

@@ -0,0 +1,36 @@
+/**
+ * HTTP 状态码 → AccountState 公共映射测试。
+ *
+ * 存在的原因：这条映射曾在内置三家供应商里各写一份，于是「哪个错误算账号的错」
+ * 有三份实现——bad_request 加固差点只补上 codebuddy，三家内置仍是 4xx→unknown
+ * →瞬冷 30s（同型事故）。收敛成一处后，这一份测试同时守住三家。
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { stateFromHttpStatus } from './http-state.ts'
+
+test('映射：账号侧错误（换号会好的）归各自的冷却状态', () => {
+  assert.equal(stateFromHttpStatus(429), 'rate_limit', '限流 = 换号有用')
+  assert.equal(stateFromHttpStatus(401), 'session_dead', '凭证失效')
+  assert.equal(stateFromHttpStatus(403), 'session_dead', '403 分不清死活与风控，按连接级冷却')
+  assert.equal(stateFromHttpStatus(402), 'quota', '要钱/额度不足')
+  assert.equal(stateFromHttpStatus(404), 'unavailable', '上游没有这个端点/服务下线')
+})
+
+test('映射：请求侧 4xx 归 bad_request —— 同一个请求对每个号都一样失败，不该冷号', () => {
+  for (const status of [400, 405, 409, 413, 422, 499]) {
+    assert.equal(stateFromHttpStatus(status), 'bad_request', `${status} 是请求形态问题，不是账号的错`)
+  }
+})
+
+test('映射：5xx 与异常码仍归 unknown（上游故障侧，瞬冷换号是对的）', () => {
+  for (const status of [500, 502, 503, 504, 599]) {
+    assert.equal(stateFromHttpStatus(status), 'unknown', `${status} 是上游故障`)
+  }
+})
+
+test('映射：绝不返回 ok —— 这个函数只在非 2xx 分支被调用', () => {
+  for (const status of [400, 401, 402, 403, 404, 429, 500]) {
+    assert.notEqual(stateFromHttpStatus(status), 'ok')
+  }
+})

package/src/suppliers/http-state.ts

@@ -0,0 +1,31 @@
+/**
+ * HTTP 状态码 → AccountState 的公共映射（内置三家供应商共用）。
+ *
+ * 为什么收敛成一处：opencode / openrouter / nvidia 本来各写一份逐字相同的
+ * 三元表达式，于是「哪个状态算谁的错」这件事有三份实现，改一处就漏两处
+ * （bad_request 就是这么差点只补了 codebuddy）。
+ *
+ * 关键判据：**这个错误换一个账号会不会好？**
+ *  - 会好（限流/额度/凭证）→ 是账号的错，交给核心冷却/换号
+ *  - 不会好（请求参数、模型不存在）→ 不是账号的错，绝不能冷号
+ *    否则一次坏请求会把整个池冷掉（2026-09-15 codebuddy 读图事故的同型：
+ *    组合两条腿同时被冷，之后连正常文本请求也全灭 503）
+ */
+import type { AccountState } from './contract.ts'
+
+/**
+ * 非 2xx 上游响应 → 语义状态。
+ *
+ * 4xx 里除了「限流/凭证/不存在」这三种明确归属账号的，剩下的都是**请求本身
+ * 有问题**（400 参数错、413 太大、422 语义错…）——同一个请求对池里每个号结果
+ * 都相同，归 `bad_request`（核心不惩罚账号，直接换下一个模型）。
+ * 5xx / 说不清的仍归 `unknown`（上游故障侧，瞬冷换号是对的）。
+ */
+export function stateFromHttpStatus(status: number): AccountState {
+  if (status === 429) return 'rate_limit'
+  if (status === 401 || status === 403) return 'session_dead'
+  if (status === 404) return 'unavailable'
+  if (status === 402) return 'quota'
+  if (status >= 400 && status < 500) return 'bad_request'
+  return 'unknown'
+}

package/src/suppliers/nvidia/plugin.ts

@@ -18,6 +18,7 @@ import { join } from 'node:path'
 import type { ChatRequest, ModelInfo } from '../../router/types.ts'
 import type { AccountState, ChatOnceResult, SupplierStatusNow } from '../contract.ts'
 import type { SupplierEnv, SupplierModule } from '../contract.ts'
+import { stateFromHttpStatus } from '../http-state.ts'
 
 export const id = 'nvidia'
 export const name = 'NVIDIA NIM'
@@ -287,12 +288,7 @@ export default function factory(env: SupplierEnv): SupplierModule {
       if (upstream.status < 200 || upstream.status >= 300) {
         const text = await upstream.text().catch(() => '')
         const msg = `upstream ${upstream.status}: ${text.slice(0, 120)}`
-        const state: AccountState =
-          upstream.status === 429 ? 'rate_limit'
-            : upstream.status === 401 || upstream.status === 403 ? 'session_dead'
-              : upstream.status === 404 ? 'unavailable'
-                : 'unknown'
-        return { ok: false, state, message: msg }
+        return { ok: false, state: stateFromHttpStatus(upstream.status), message: msg }
       }
 
       // 流式：上游已是 OpenAI SSE，原样交回核心写

package/src/suppliers/opencode/plugin.ts

@@ -9,7 +9,8 @@
  * 面板只显示模型卡片（连接池、签到由能力检测自动隐藏）。
  */
 import type { ChatRequest, ModelInfo } from '../../router/types.ts'
-import type { AccountState, ChatOnceResult, SupplierEnv, SupplierModule, SupplierStatusNow } from '../contract.ts'
+import type { ChatOnceResult, SupplierEnv, SupplierModule, SupplierStatusNow } from '../contract.ts'
+import { stateFromHttpStatus } from '../http-state.ts'
 
 
 export const id = 'opencode'
@@ -125,9 +126,7 @@ export default function factory(env: SupplierEnv): SupplierModule {
       if (upstream.status < 200 || upstream.status >= 300) {
         const text = await upstream.text().catch(() => '')
         const msg = `upstream ${upstream.status}: ${text.slice(0, 200)}`
-        const state: AccountState =
-          upstream.status === 429 ? 'rate_limit' : upstream.status === 404 ? 'unavailable' : 'unknown'
-        return { ok: false, state, message: msg }
+        return { ok: false, state: stateFromHttpStatus(upstream.status), message: msg }
       }
 
       // 流式：上游已是 OpenAI SSE，原样交回核心（核心负责写响应）

package/src/suppliers/openrouter/plugin.ts

@@ -12,6 +12,7 @@
 import type { ChatRequest, ModelInfo } from '../../router/types.ts'
 import type { AccountState, ChatOnceResult, SupplierStatusNow } from '../contract.ts'
 import type { SupplierEnv, SupplierModule } from '../contract.ts'
+import { stateFromHttpStatus } from '../http-state.ts'
 
 export const id = 'openrouter'
 export const name = 'OpenRouter'
@@ -202,13 +203,8 @@ export default function factory(env: SupplierEnv): SupplierModule {
       if (upstream.status < 200 || upstream.status >= 300) {
         const text = await upstream.text().catch(() => '')
         const msg = `upstream ${upstream.status}: ${text.slice(0, 120)}`
-        // 401/403 = 这个 key 本身不可用；429 = 限流；其余归为说不清
-        const state: AccountState =
-          upstream.status === 429 ? 'rate_limit'
-            : upstream.status === 401 || upstream.status === 403 ? 'session_dead'
-              : upstream.status === 404 ? 'unavailable'
-                : 'unknown'
-        return { ok: false, state, message: msg }
+        // 401/403 = 这个 key 本身不可用；429 = 限流；其余见 stateFromHttpStatus
+        return { ok: false, state: stateFromHttpStatus(upstream.status), message: msg }
       }
 
       // 流式：上游已是 OpenAI SSE，原样交回核心写