dsh-router-core 0.3.14 → 0.3.16

package/docs/suppliers.md

@@ -14,7 +14,7 @@
 | | 谁负责 |
 |---|---|
 | 组合回退、按策略选中模型 | 核心 |
-| **账号池**:选号、冷却、禁用、遍历回退 | 核心 |
+| **账号池**:选号、冷却、遍历回退 | 核心 |
 | 响应写入(状态行、SSE 头、JSON body) | 核心 |
 | 模型启用/禁用、自定义模型、别名 | 核心 |
 | 凭证存储(`env.credentials`) | 核心 |
@@ -75,22 +75,32 @@ js 报告**此刻**观察到的账户状况,而不是把上游原始响应丢给
 | `ok` | 正常 |
 | `rate_limit` | 限流(429 类) |
 | `quota` | 额度/权益不足 |
-| `session_dead` | 凭证彻底失效,必须重新登录才能恢复 |
+| `session_dead` | 凭证失效/凭证被上游拒(403 类,含风控误伤) |
 | `unavailable` | 上游不可用(404 / 服务下线) |
 | `transport` | 网络/连接层失败(没拿到 HTTP 状态) |
 | `unknown` | 说不清是什么错 |
 | `no_such_model` | **这个模型不属于本供应商**(不是账号的失败) |
+| `bad_request` | **请求本身不合法,被上游拒**(参数错/图片认不出/tool_call 配对断裂;不是账号的失败) |
 
 **`no_such_model` 是必须的,不能拿 `unavailable` 顶替。** 后者在核心策略里会
 把**这个号 × 这个模型**冷掉——组合里每有一个别人家的模型,js 就会对每个账号
 都报一次,于是一个都选不出来(表现为「组合越用越没号可用」)。所以「这个模型
 不属于我」一定要报 `no_such_model`,核心才知道该换供应商而不是换账号。
 
-**js 只说「现在怎么了」,不说「该怎么办」。** 冷却多久、是否禁用、要不要换号
+**`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 不该自己记冷却表——那样每个插件都会长出一份
 互相不一致的实现。
 
-核心在 `status()` 之上叠加 `cooling` / `disabled` / `err_count` / `until` / `reason`
+核心在 `status()` 之上叠加 `cooling` / `err_count` / `until` / `reason`
 再给面板,所以 js 不用(也不该)填这些字段。`accounts` 为空数组 = 无账号供应商。
 注意 `err_count` 现在是**限流退避等级**(反复被限流的号等级递增),不是
 「连续失败次数」——面板按等级展示,等级在成功后清零。
@@ -101,7 +111,7 @@ js 只要知道这一条:**报 `rate_limit`/`transport`/`unknown` 只影响「
 模型」**,不会牵连该号上的其它模型。一个连接服务多个模型时,模型 A 被限流不该
 让模型 B 也不可用。
 
-例外是 `session_dead`:凭证失效是连接级问题,该号**所有模型**都停用。
+例外是 `session_dead`:凭证失效是连接级问题,该号**所有模型**都停用(连接级冷却,到期自愈)。
 
 ## `chatOnce(uid, req)`:一次只服务一个账号
 
@@ -124,9 +134,10 @@ type ChatOnceResult =
 |---|---|
 | `rate_limit` | **指数退避**:首次 2s,每次翻倍,上限 5 分钟;成功后等级清零 |
 | `quota` | 冷却 10 分钟 |
-| `session_dead` | **永久禁用该号**(所有模型都停用,需重新登录才能恢复) |
+| `session_dead` | **连接级冷却 30 分钟**(该号所有模型都停用,到期自愈;没有永久禁用——403 分不清凭证死活与风控误伤) |
 | `unavailable` / `transport` / `unknown` | 瞬时短冷却 30s(**每次都冷**,不攒次数) |
 | `no_such_model` | **不惩罚账号**,核心直接跳过整个供应商换下一个 |
+| `bad_request` | **不惩罚账号**(请求非法不是号的错),核心直接跳到下一个模型/供应商 |
 
 - 非流式若聚合后发现**空响应**(无 content / reasoning / tool_calls),请返回
   `{ ok:false, state:'unknown' }` 而不是 `ok:true`——空响应交给核心换号/换模型回退,
@@ -137,7 +148,7 @@ type ChatOnceResult =
 「请求参数非法」「上游临时不可用」)建议归 `rate_limit`——瞬时/请求类的错,
 短冷换号比长冷划算。
 
-冷却/禁用/退避等级都是**内存态**,重启归零(与凭证、积分的持久化不同)。
+冷却/退避等级都是**内存态**,重启归零(与凭证、积分的持久化不同)。
 重启后所有号都会重新被选中一次,所以**上游确实挂了的号会各撞一次**,属预期。
 要跨重启保留,届时给账号池加一个落盘 state 文件即可,接口不用变。
 
@@ -274,7 +285,7 @@ export const id = 'echo'
 export const name = 'Echo'
 export const priority = 10
 
-// 只报「现在状态」:冷却/禁用/退避等级由核心叠加,积分由核心持久化
+// 只报「现在状态」:冷却/退避等级由核心叠加,积分由核心持久化
 // credits: -1 = 不支持/没拉到(别写 0,0 会被当成「用完了」存下来)
 const accounts = [{ uid: 'echo-1', nickname: 'Echo 1', credits: -1, state: 'ok' }]
 

package/lib/client-registry.js

@@ -116,10 +116,6 @@ window.__ModuleLoader__.load({
 			return `剩余 ${Math.ceil(minutes / 60)} 小时`;
 		}
 		function statusBadge(account) {
-			if (account.disabled) return {
-				text: "已禁用",
-				cls: "dshr-badge-danger"
-			};
 			if (account.cooling) return {
 				text: "冷却中",
 				cls: "dshr-badge-warn"
@@ -768,7 +764,7 @@ window.__ModuleLoader__.load({
 							className: "dshr-linkList",
 							children: orderedAccounts.map((account, index) => {
 								const badge = statusBadge(account);
-								const coolingText = account.cooling || account.disabled ? `${account.reason ?? ""}${untilLabel(account) !== "" ? ` · ${untilLabel(account)}` : ""}` : "";
+								const coolingText = account.cooling ? `${account.reason ?? ""}${untilLabel(account) !== "" ? ` · ${untilLabel(account)}` : ""}` : "";
 								return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 									className: `dshr-linkRow${dragIndex === index ? " dshr-linkRowDragging" : ""}`,
 									draggable: renameUid !== account.uid,
@@ -3585,7 +3581,7 @@ window.__ModuleLoader__.load({
 						className: "dshr-supplierGrid",
 						children: group.map((supplier) => {
 							const supplierAccounts = accounts.filter((a) => a.supplier === supplier.id);
-							const healthy = supplierAccounts.filter((a) => !a.cooling && !a.disabled).length;
+							const healthy = supplierAccounts.filter((a) => !a.cooling).length;
 							return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 								className: "dshr-supplierCard",
 								onClick: () => setDetailSupplier(supplier),

package/lib/client.js

@@ -116,10 +116,6 @@ window.__ModuleLoader__.load({
 			return `剩余 ${Math.ceil(minutes / 60)} 小时`;
 		}
 		function statusBadge(account) {
-			if (account.disabled) return {
-				text: "已禁用",
-				cls: "dshr-badge-danger"
-			};
 			if (account.cooling) return {
 				text: "冷却中",
 				cls: "dshr-badge-warn"
@@ -768,7 +764,7 @@ window.__ModuleLoader__.load({
 							className: "dshr-linkList",
 							children: orderedAccounts.map((account, index) => {
 								const badge = statusBadge(account);
-								const coolingText = account.cooling || account.disabled ? `${account.reason ?? ""}${untilLabel(account) !== "" ? ` · ${untilLabel(account)}` : ""}` : "";
+								const coolingText = account.cooling ? `${account.reason ?? ""}${untilLabel(account) !== "" ? ` · ${untilLabel(account)}` : ""}` : "";
 								return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 									className: `dshr-linkRow${dragIndex === index ? " dshr-linkRowDragging" : ""}`,
 									draggable: renameUid !== account.uid,
@@ -3585,7 +3581,7 @@ window.__ModuleLoader__.load({
 						className: "dshr-supplierGrid",
 						children: group.map((supplier) => {
 							const supplierAccounts = accounts.filter((a) => a.supplier === supplier.id);
-							const healthy = supplierAccounts.filter((a) => !a.cooling && !a.disabled).length;
+							const healthy = supplierAccounts.filter((a) => !a.cooling).length;
 							return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 								className: "dshr-supplierCard",
 								onClick: () => setDetailSupplier(supplier),

package/lib/index.js

@@ -106,42 +106,38 @@ const MINUTE = 6e4;
 const RULES = {
 	ok: {
 		cooldown: 0,
-		disable: false,
 		counts: false
 	},
 	rate_limit: {
 		cooldown: "backoff",
-		disable: false,
 		counts: false
 	},
 	quota: {
 		cooldown: 10 * MINUTE,
-		disable: false,
 		counts: false
 	},
 	session_dead: {
-		cooldown: 0,
-		disable: true,
+		cooldown: 30 * MINUTE,
 		counts: false
 	},
 	unavailable: {
 		cooldown: "transient",
-		disable: false,
 		counts: false
 	},
 	transport: {
 		cooldown: "transient",
-		disable: false,
 		counts: false
 	},
 	unknown: {
 		cooldown: "transient",
-		disable: false,
 		counts: false
 	},
 	no_such_model: {
 		cooldown: 0,
-		disable: false,
+		counts: false
+	},
+	bad_request: {
+		cooldown: 0,
 		counts: false
 	}
 };
@@ -183,7 +179,7 @@ var AccountPool = class {
 	supplierId;
 	/** (supplier, model, uid) → 冷却/退避。 */
 	cooldowns = /* @__PURE__ */ new Map();
-	/** uid → 连接级禁用 / 手动暂停。 */
+	/** uid → 连接级冷却 / 手动暂停。 */
 	byUid = /* @__PURE__ */ new Map();
 	rrCursor = 0;
 	/** (supplier, model) → 当前驻留的号（只有**无亲和**的回退路径用它）。 */
@@ -213,46 +209,30 @@ var AccountPool = class {
 		}
 		return e;
 	}
-	/** 某连接整体状态（禁用/手动暂停）。 */
+	/** 某连接整体状态（连接级冷却/手动暂停）。 */
 	uidState(uid) {
 		let e = this.byUid.get(uid);
 		if (!e) {
 			e = {
 				until: 0,
-				disabled: false,
 				reason: ""
 			};
 			this.byUid.set(uid, e);
 		}
 		return e;
 	}
-	/** 该连接是否被禁用 / 手动整连接暂停中（跨模型生效）。 */
+	/** 该连接是否处于连接级冷却/手动暂停中（跨模型生效，到期自愈）。 */
 	uidBlocked(uid, now) {
 		const e = this.byUid.get(uid);
-		if (!e) return {
-			blocked: false,
-			disabled: false
-		};
-		if (e.disabled) return {
-			blocked: true,
-			disabled: true
-		};
-		if (e.until > now) return {
-			blocked: true,
-			disabled: false
-		};
-		return {
-			blocked: false,
-			disabled: false
-		};
+		return e !== void 0 && e.until > now;
 	}
 	/**
 	* 给定要试的模型，该连接是否可服务：
-	*  - 未被连接级禁用/手动暂停（跨模型）；
+	*  - 不处于连接级冷却/手动暂停（跨模型，到期自愈）；
 	*  - 且此 (supplier, model, uid) 冷却单元不在冷却中。
 	*/
 	healthy(uid, model, now) {
-		if (this.uidBlocked(uid, now).blocked) return false;
+		if (this.uidBlocked(uid, now)) return false;
 		const c = this.cooldowns.get(this.key(model, uid));
 		if (!c) return true;
 		return c.until <= now;
@@ -371,16 +351,17 @@ var AccountPool = class {
 	blockKey(modelId) {
 		return `${this.supplierId}${SEP}${modelId}`;
 	}
-	/** 记录一次失败：按状态处置（冷却/禁用/退避），落在「(模型, 连接)」这个冷却单元上。 */
+	/** 记录一次失败：按状态处置（冷却/退避），落在「(模型, 连接)」这个冷却单元上。 */
 	noteFailure(uid, modelId, state, message) {
 		const rule = RULES[state];
-		if (rule.disable) {
+		if (rule.cooldown === 0) return;
+		if (state === "session_dead") {
 			const e = this.uidState(uid);
-			e.disabled = true;
+			const cd = rule.cooldown;
+			e.until = Math.max(e.until, Date.now() + (typeof cd === "number" ? cd : 0));
 			e.reason = message;
 			return;
 		}
-		if (rule.cooldown === 0) return;
 		const e = this.entry(modelId, uid);
 		e.reason = message;
 		if (rule.cooldown === "backoff") {
@@ -394,7 +375,7 @@ var AccountPool = class {
 		}
 		e.until = Math.max(e.until, Date.now() + rule.cooldown);
 	}
-	/** 记录一次成功：清零「该模型」的限流退避等级（好号不背历史惩罚）。不解除禁用。 */
+	/** 记录一次成功：清零「该模型」的限流退避等级（好号不背历史惩罚）。 */
 	noteSuccess(uid, modelId) {
 		const e = this.cooldowns.get(this.key(modelId, uid));
 		if (e) e.backoffLevel = 0;
@@ -406,7 +387,7 @@ var AccountPool = class {
 		e.reason = reason;
 		for (const [k, ce] of this.cooldowns) if (k.endsWith(`${SEP}${uid}`)) ce.backoffLevel = 0;
 	}
-	/** 把核心的冷却/禁用叠加到插件报的「现在状态」上，产出面板态。
+	/** 把核心的冷却叠加到插件报的「现在状态」上，产出面板态。
 	*
 	* 冷却现在是 (模型, 连接) 粒度的，而面板状态没有「当前模型」上下文，
 	* 这里默认**聚合**：只要该连接在任一模型上有活跃冷却，就显示 cooling=true
@@ -417,11 +398,10 @@ var AccountPool = class {
 		const now = Date.now();
 		return accounts.map((a) => {
 			const u = this.byUid.get(a.uid);
-			const disabled = u?.disabled ?? false;
-			const manualCooling = u !== void 0 && !u.disabled && u.until > now;
-			let cooling = manualCooling;
-			let maxUntil = manualCooling ? u.until : 0;
-			let reason = manualCooling ? u.reason : void 0;
+			const uidCooling = u !== void 0 && u.until > now;
+			let cooling = uidCooling;
+			let maxUntil = uidCooling ? u.until : 0;
+			let reason = uidCooling ? u.reason : void 0;
 			let err = 0;
 			for (const [k, ce] of this.cooldowns) {
 				if (!k.endsWith(`${SEP}${a.uid}`)) continue;
@@ -441,7 +421,6 @@ var AccountPool = class {
 			return {
 				...a,
 				cooling,
-				disabled,
 				err_count: err,
 				until: cooling && maxUntil > 0 ? new Date(maxUntil).toISOString() : void 0,
 				reason: reason !== void 0 && reason !== "" ? reason : void 0
@@ -1350,6 +1329,7 @@ function stripAlias(model, alias) {
 *
 * 只对**瞬时**故障等：连接层失败 / 上游不可用（对应 9router 的 502/503/504）。
 * 模型不属于本供应商（no_such_model）绝不能等 —— 它不是故障，等纯属浪费。
+* 请求本身非法（bad_request）同理：换哪个模型都是同一个 400，等也是白等。
 */
 const TRANSIENT_SETTLE_MS = 2e3;
 function isTransient(state) {
@@ -2191,7 +2171,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;
@@ -2212,8 +2192,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);
@@ -2323,14 +2306,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)
@@ -2338,6 +2347,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,
@@ -2357,32 +2367,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 缺失或读取失败时回退稳定占位文本（绝不静默丢图）。
@@ -2495,14 +2515,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 事件流。
@@ -3207,7 +3219,7 @@ function cap(set, key) {
 }
 /** 账号状态指纹（积分 + 健康），用于判断刷新是否落地。 */
 function fingerprint(accounts) {
-	return accounts.map((a) => `${a.uid}:${a.credits}:${a.cooling}:${a.disabled}`).join("|");
+	return accounts.map((a) => `${a.uid}:${a.credits}:${a.cooling}`).join("|");
 }
 /**
 * 反复调插件已有的 status()，直到快照稳定再返回（是否有变化 = changed）。

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/account-pool.d.ts

@@ -1,5 +1,5 @@
 /**
- * 账号池 —— dsh-router 核心策略：选号、冷却、禁用、遍历回退。
+ * 账号池 —— dsh-router 核心策略：选号、冷却、遍历回退。
  *
  * 供应商插件只管「对单个账号调通上游」，账号层面的策略全在这里。
  *
@@ -11,7 +11,8 @@
  * 失败而对其它模型也不可用，这是错的。
  *
  *   - 冷却/限流退避/瞬时 → 键 = (supplierId, modelId, uid)，只冷「这个号 × 这个模型」
- *   - 禁用(session_dead)     → 键 = uid（登录态问题，该号所有模型都不可用）
+ *   - 凭证失效(session_dead) → 键 = uid 连接级冷却（登录态问题，该号所有模型都不可用）；
+ *     **没有永久禁用**——403 分不清凭证死活与风控误伤，冷却到期自愈
  *   - 手动冷却(面板)         → 键 = uid（管理员整连接暂停）
  *
  * 为什么键里要带 supplierId：不同供应商**会有同名的模型 id**（如 traework 与
@@ -19,7 +20,7 @@
  * 会把跨供应商的同名模型串到一起。尽管本池实例当前是单供应商（loader 每供应商
  * 一个 AccountPool），键仍显式带 supplierId，语义自明且将来若池合并也安全。
  *
- * 天花板：冷却/禁用都是**内存态**，重启归零（与旧插件行为一致）。要跨重启保留
+ * 天花板：冷却都是**内存态**，重启归零（与旧插件行为一致）。要跨重启保留
  * 得落盘，届时加 stateFile 即可，接口不用变。
  */
 import type { AccountState, SupplierAccountNow } from '../suppliers/contract.ts';
@@ -28,7 +29,7 @@ export declare class AccountPool {
     private supplierId;
     /** (supplier, model, uid) → 冷却/退避。 */
     private cooldowns;
-    /** uid → 连接级禁用 / 手动暂停。 */
+    /** uid → 连接级冷却 / 手动暂停。 */
     private byUid;
     private rrCursor;
     /** (supplier, model) → 当前驻留的号（只有**无亲和**的回退路径用它）。 */
@@ -42,13 +43,13 @@ export declare class AccountPool {
     constructor(supplierId?: string);
     private key;
     private entry;
-    /** 某连接整体状态（禁用/手动暂停）。 */
+    /** 某连接整体状态（连接级冷却/手动暂停）。 */
     private uidState;
-    /** 该连接是否被禁用 / 手动整连接暂停中（跨模型生效）。 */
+    /** 该连接是否处于连接级冷却/手动暂停中（跨模型生效，到期自愈）。 */
     private uidBlocked;
     /**
      * 给定要试的模型，该连接是否可服务：
-     *  - 未被连接级禁用/手动暂停（跨模型）；
+     *  - 不处于连接级冷却/手动暂停（跨模型，到期自愈）；
      *  - 且此 (supplier, model, uid) 冷却单元不在冷却中。
      */
     private healthy;
@@ -109,13 +110,13 @@ export declare class AccountPool {
     dropBlock(modelId: string): void;
     /** 块状态键：与冷却同粒度 (supplier, model)，不含 uid。 */
     private blockKey;
-    /** 记录一次失败：按状态处置（冷却/禁用/退避），落在「(模型, 连接)」这个冷却单元上。 */
+    /** 记录一次失败：按状态处置（冷却/退避），落在「(模型, 连接)」这个冷却单元上。 */
     noteFailure(uid: string, modelId: string, state: AccountState, message: string): void;
-    /** 记录一次成功：清零「该模型」的限流退避等级（好号不背历史惩罚）。不解除禁用。 */
+    /** 记录一次成功：清零「该模型」的限流退避等级（好号不背历史惩罚）。 */
     noteSuccess(uid: string, modelId: string): void;
     /** 手动暂停整连接（面板/管理用途，跨模型）。ms<=0 表示解除。 */
     cooldown(uid: string, ms: number, reason: string): void;
-    /** 把核心的冷却/禁用叠加到插件报的「现在状态」上，产出面板态。
+    /** 把核心的冷却叠加到插件报的「现在状态」上，产出面板态。
      *
      * 冷却现在是 (模型, 连接) 粒度的，而面板状态没有「当前模型」上下文，
      * 这里默认**聚合**：只要该连接在任一模型上有活跃冷却，就显示 cooling=true
@@ -124,7 +125,6 @@ export declare class AccountPool {
      */
     decorate(accounts: SupplierAccountNow[], modelId?: string): Array<SupplierAccountNow & {
         cooling: boolean;
-        disabled: boolean;
         err_count: number;
         until?: string;
         reason?: string;

package/lib/types/router/types.d.ts

@@ -13,7 +13,6 @@ export interface SupplierAccount {
     cooling: boolean;
     until?: string;
     reason?: string;
-    disabled: boolean;
     err_count?: number;
 }
 /** 供应商面板状态。 */

package/lib/types/shared.d.ts

@@ -22,7 +22,6 @@ export interface RouterAccount {
     cooling: boolean;
     until?: string;
     reason?: string;
-    disabled: boolean;
     err_count?: number;
     /** 所属供应商 id。 */
     supplier?: string;