dsh-router-core 0.3.13 → 0.3.15

package/lib/index.js

@@ -1,4 +1,5 @@
 import { basename, dirname, join, resolve } from "node:path";
+import Schema from "@deepseek-ai/schemastery";
 import { mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
 import { createHash, randomBytes } from "node:crypto";
 import { EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, ReasoningEffortId, ToolCallId, attributionHeaders } from "@deepseek-ai/dsh-llm";
@@ -105,42 +106,34 @@ 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
 	}
 };
@@ -182,7 +175,7 @@ var AccountPool = class {
 	supplierId;
 	/** (supplier, model, uid) → 冷却/退避。 */
 	cooldowns = /* @__PURE__ */ new Map();
-	/** uid → 连接级禁用 / 手动暂停。 */
+	/** uid → 连接级冷却 / 手动暂停。 */
 	byUid = /* @__PURE__ */ new Map();
 	rrCursor = 0;
 	/** (supplier, model) → 当前驻留的号（只有**无亲和**的回退路径用它）。 */
@@ -212,46 +205,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;
@@ -370,16 +347,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") {
@@ -393,7 +371,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;
@@ -405,7 +383,7 @@ var AccountPool = class {
 		e.reason = reason;
 		for (const [k, ce] of this.cooldowns) if (k.endsWith(`${SEP}${uid}`)) ce.backoffLevel = 0;
 	}
-	/** 把核心的冷却/禁用叠加到插件报的「现在状态」上，产出面板态。
+	/** 把核心的冷却叠加到插件报的「现在状态」上，产出面板态。
 	*
 	* 冷却现在是 (模型, 连接) 粒度的，而面板状态没有「当前模型」上下文，
 	* 这里默认**聚合**：只要该连接在任一模型上有活跃冷却，就显示 cooling=true
@@ -416,11 +394,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;
@@ -440,7 +417,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
@@ -2298,10 +2274,14 @@ var Router = class {
 * 模型目录 = 组合（自动带出，不可改）。对话转发到本插件 /v1/chat/completions，
 * 由现有路由按组合策略命中供应商模型。
 *
-* 纯文本流：组合为文本模型，本 adapter 不处理图片附件。
+* 图文流：adapter 声明图片 modal（`inputModalities` 含 `image`），把 user 消息里的
+* `image` 块序列化成 OpenAI 标准的 `image_url` base64 part，经 /v1 原样透传给
+* 命中的上游供应商。最终能否看图取决于**命中的那个上游模型**——组合里是异构
+* 供应商，可能在网关端声明了图片能力、某条上游却只收文本（此时由上游自行拒收）。
+* 图片字节从 `ctx.attachments` 读取（读不到的按稳定占位文本降级，绝不静默丢图）。
 */
 /**
-* 把 DSH 消息序列化成 openai 兼容 wire 消息（纯文本 + tool）。
+* 把 DSH 消息序列化成 openai 兼容 wire 消息（文本 + 图片 + tool）。
 *
 * `system` 必须由调用方从 `options.system` 传进来：one-shot 调用方把系统提示词
 * 放在 **options.system 这个独立槽位**，不放进 messages。不读这个槽位，
@@ -2313,8 +2293,12 @@ var Router = class {
 * 可出现在任意位置以支持提示词热更新）。两条路径都必须支持 —— 与官方
 * dsh-llm-deepseek 一致（serializeRequest 前置 options.system，再按位置序列化
 * messages 里的 system 消息）。
+*
+* 图片：`image` 块被序列化成 OpenAI `content` 数组里的 `image_url` part（data URI
+* base64）。图片字节经 `resolveAttachments` 读取；读不到时回退为稳定的占位文本，
+* **绝不静默丢图**（丢图 = 模型看到一条没有图的消息却毫无提示）。
 */
-function wireMessages(options, system) {
+async function wireMessages(options, system, attachments) {
 	const out = [];
 	if (typeof system === "string" && system !== "") out.push({
 		role: "system",
@@ -2347,12 +2331,24 @@ function wireMessages(options, system) {
 			});
 			continue;
 		}
-		const text = flattenText(message.content);
 		const toolResults = message.content.filter((b) => b.type === "tool-result");
-		if (text.length > 0 || toolResults.length === 0) out.push({
-			role: "user",
-			content: text
-		});
+		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
+			});
+		}
 		for (const result of toolResults) out.push({
 			role: "tool",
 			tool_call_id: result.toolCallId,
@@ -2361,9 +2357,73 @@ function wireMessages(options, system) {
 	}
 	return out;
 }
-/** 组装 wire 请求体。 */
-function wireRequest(options) {
-	const messages = wireMessages(options, options.system);
+/**
+* 一块 DSH user/tool-result 内容序列化成 OpenAI content parts（text + image_url）。
+* 纯文本时返回空数组（上层走紧凑字符串路径）。图片转 base64 data URI；
+* attachments 缺失或读取失败时回退稳定占位文本（绝不静默丢图）。
+*/
+async function contentParts(blocks, attachments, signal) {
+	const parts = [];
+	for (const block of blocks) {
+		if (block.type === "text") {
+			const text = block.text ?? "";
+			if (text.length > 0) parts.push({
+				type: "text",
+				text
+			});
+			continue;
+		}
+		if (block.type === "image") {
+			const ref = block.attachment;
+			parts.push(...await imageParts(ref, attachments, signal));
+			continue;
+		}
+		if (block.type === "tool-result") parts.push(...await contentParts(block.content, attachments, signal));
+	}
+	return parts;
+}
+/** 一张图片 → 一个 OpenAI image_url part（或读不到附件时的占位文本）。 */
+async function imageParts(ref, attachments, signal) {
+	if (attachments === void 0) return [{
+		type: "text",
+		text: imagePlaceholder(ref.attachmentId)
+	}];
+	try {
+		const img = await attachments.readImageRequest({
+			attachmentId: ref.attachmentId,
+			mediaType: ref.mediaType,
+			bytes: ref.bytes,
+			width: ref.width,
+			height: ref.height
+		}, {
+			maxPixels: 64e4,
+			maxBytes: 1048576
+		}, signal);
+		return [{
+			type: "image_url",
+			image_url: { url: `data:${img.mediaType};base64,${bytesToBase64(img.data)}` }
+		}];
+	} catch {
+		return [{
+			type: "text",
+			text: imagePlaceholder(ref.attachmentId)
+		}];
+	}
+}
+/** Uint8Array → base64（browser + node 双环境安全，不依赖 Buffer 全局）。 */
+function bytesToBase64(bytes) {
+	let bin = "";
+	const chunk = 32768;
+	for (let i = 0; i < bytes.length; i += chunk) bin += String.fromCharCode(...bytes.subarray(i, i + chunk));
+	return btoa(bin);
+}
+/** 读不到图片字节时的稳定占位文本。 */
+function imagePlaceholder(attachmentId) {
+	return `[image omitted because the attached bytes could not be read; attachment ${attachmentId}]`;
+}
+/** 组装 wire 请求体。图片序列化需要读 attachments，故为异步。 */
+async function wireRequest(options, attachments) {
+	const messages = await wireMessages(options, options.system, attachments);
 	const body = {
 		model: options.model,
 		messages,
@@ -2410,6 +2470,14 @@ 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 事件流。
@@ -2643,10 +2711,12 @@ const ROUTER_REASONING_EFFORTS = [
 var RouterAdapter = class RouterAdapter extends LlmAdapter {
 	baseURL;
 	source;
-	constructor(baseURL, source) {
+	resolveAttachments;
+	constructor(baseURL, source, resolveAttachments) {
 		super();
 		this.baseURL = baseURL;
 		this.source = source;
+		this.resolveAttachments = resolveAttachments ?? (() => void 0);
 	}
 	providerInfo(provider) {
 		return {
@@ -2670,14 +2740,14 @@ var RouterAdapter = class RouterAdapter extends LlmAdapter {
 		return out;
 	}
 	/**
-	* 只收文本。`resolveModel` 声明 `inputModalities: ['text']` 是**必须**的：
-	* 0.1.5 的 runtime 只在 `inputModalities` 存在且不含 `image` 时才把 image 块
-	* 投影成占位文本（见 dsh-llm adapterStream 的 projectImagesForTextModel）。
-	* 不声明 = "unknown" = 不投影，而 wireMessages 只读 text 块 → 图片**静默
-	* 丢失**，模型看到一条没有图片的用户消息却毫无提示。声明后由 runtime 统一
-	* 投影，我们仍只处理文本。
+	* 声明图文：`inputModalities` 必须同时含 `text` 与 `image`。
+	* - 含 `image`：runtime/subagent 的模态门禁放行（不再抛
+	*   `MODEL_DOES_NOT_SUPPORT_IMAGES` = 界面「当前模型不支持图片」），
+	*   `projectImagesForTextModel` 也不会把图片块投影成占位文本。
+	* - 组合背后是异构供应商，**统一声明图片能力**；真正能否看图取决于命中
+	*   的某个上游模型（供应商各模型 capability 不同，网关端不能一刀切拦截）。
 	*/
-	static INPUT_MODALITIES = ["text"];
+	static INPUT_MODALITIES = ["text", "image"];
 	async resolveModel(_provider, model) {
 		const found = (await this.source.comboModels()).find((m) => m.id === model || m.name === model);
 		return {
@@ -2693,7 +2763,7 @@ var RouterAdapter = class RouterAdapter extends LlmAdapter {
 		};
 	}
 	async *stream(options) {
-		const body = wireRequest(options);
+		const body = await wireRequest(options, this.resolveAttachments());
 		const controller = new AbortController();
 		const onAbort = () => controller.abort();
 		options.signal?.addEventListener("abort", onAbort, { once: true });
@@ -3112,7 +3182,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）。
@@ -4161,13 +4231,26 @@ function apply(rawContext) {
 			disposers.push(ctx.llm.registerModelDiscovery(LLM_NS, async () => {
 				return (await router.combos()).map((c) => ({ id: c.name }));
 			}));
+			const routerSettingsSchema = Schema.object({});
+			ctx.inject(["settings"], (sctx) => {
+				const settings = sctx.settings;
+				if (settings === void 0) {
+					log("settings service absent — skip Router settings-section registration");
+					return;
+				}
+				settings.installSection(rawContext, LLM_NS, routerSettingsSchema, {}, {
+					setSource: () => {},
+					onChange: () => {}
+				});
+				log(`Router settings section registered (${LLM_NS})`);
+			});
 			disposers.push(ctx.llm.registerAdapter(["router"], new RouterAdapter("http://localhost:3080/v1", { comboModels: async () => (await router.combos()).map((c) => {
 				const w = router.comboContextWindow(c);
 				return {
 					id: c.name,
 					...w !== void 0 ? { contextWindow: w } : {}
 				};
-			}) })));
+			}) }, () => ctx.get("attachments"))));
 			log("llm provider (Router) + discovery + adapter registered ok");
 			(async () => {
 				for (const c of await router.combos()) for (const ref of c.models) {
@@ -4195,11 +4278,20 @@ function apply(rawContext) {
 		} catch (err) {
 			registeredProviders = `error: ${err.message}`;
 		}
+		let settingsNamespaces = "n/a";
+		try {
+			const settings = ctx.get("settings");
+			settingsNamespaces = settings?.describe === void 0 ? "no settings service" : settings.describe({ redactSecrets: true }).map((d) => d.ns);
+		} catch (err) {
+			settingsNamespaces = `error: ${err.message}`;
+		}
 		writeJson(res, 200, {
 			ok: true,
 			llmAvailable: ctx.llm !== void 0,
 			directory,
-			registeredProviders
+			registeredProviders,
+			settingsNamespaces,
+			routerNamespaceRegistered: Array.isArray(settingsNamespaces) && settingsNamespaces.includes("llm-dsh-router")
 		});
 	});
 	ctx.effect(() => () => {

package/lib/types/llm/adapter.d.ts

@@ -4,9 +4,34 @@
  * 模型目录 = 组合（自动带出，不可改）。对话转发到本插件 /v1/chat/completions，
  * 由现有路由按组合策略命中供应商模型。
  *
- * 纯文本流：组合为文本模型，本 adapter 不处理图片附件。
+ * 图文流：adapter 声明图片 modal（`inputModalities` 含 `image`），把 user 消息里的
+ * `image` 块序列化成 OpenAI 标准的 `image_url` base64 part，经 /v1 原样透传给
+ * 命中的上游供应商。最终能否看图取决于**命中的那个上游模型**——组合里是异构
+ * 供应商，可能在网关端声明了图片能力、某条上游却只收文本（此时由上游自行拒收）。
+ * 图片字节从 `ctx.attachments` 读取（读不到的按稳定占位文本降级，绝不静默丢图）。
  */
 import { LlmAdapter, type GenerateOptions, type LlmModelInfo, type LlmResolvedModelInfo, type StreamChunk } from '@deepseek-ai/dsh-llm';
+/**
+ * dsh-attachment 的最小本地切面：adapter 只依赖「读一张图片的请求版本」
+ * 这一行为，不引入对 dsh-attachment 包编译期/运行期的依赖（它是宿主注入的
+ * devDependency）。本地声明与原包 `AttachmentStore.readImageRequest` 形状一致，
+ * 宿主注入真实 store 时天然满足。
+ */
+export interface RouterAttachmentStore {
+    readImageRequest(ref: {
+        attachmentId: string;
+        mediaType: string;
+        bytes: number;
+        width: number;
+        height: number;
+    }, policy: {
+        maxPixels: number;
+        maxBytes: number;
+    }, signal?: AbortSignal): Promise<{
+        mediaType: string;
+        data: Uint8Array;
+    }>;
+}
 /** 模型目录来源：组合。 */
 export interface RouterAdapterSource {
     /**
@@ -32,19 +57,20 @@ export declare function translateSse(payloads: AsyncIterable<string> | Iterable<
 export declare class RouterAdapter extends LlmAdapter {
     private readonly baseURL;
     private readonly source;
-    constructor(baseURL: string, source: RouterAdapterSource);
+    private readonly resolveAttachments;
+    constructor(baseURL: string, source: RouterAdapterSource, resolveAttachments?: () => RouterAttachmentStore | undefined);
     providerInfo(provider: string): {
         id: string;
         name: string;
     };
     listModels(_provider: string): Promise<readonly LlmModelInfo[]>;
     /**
-     * 只收文本。`resolveModel` 声明 `inputModalities: ['text']` 是**必须**的：
-     * 0.1.5 的 runtime 只在 `inputModalities` 存在且不含 `image` 时才把 image 块
-     * 投影成占位文本（见 dsh-llm adapterStream 的 projectImagesForTextModel）。
-     * 不声明 = "unknown" = 不投影，而 wireMessages 只读 text 块 → 图片**静默
-     * 丢失**，模型看到一条没有图片的用户消息却毫无提示。声明后由 runtime 统一
-     * 投影，我们仍只处理文本。
+     * 声明图文：`inputModalities` 必须同时含 `text` 与 `image`。
+     * - 含 `image`：runtime/subagent 的模态门禁放行（不再抛
+     *   `MODEL_DOES_NOT_SUPPORT_IMAGES` = 界面「当前模型不支持图片」），
+     *   `projectImagesForTextModel` 也不会把图片块投影成占位文本。
+     * - 组合背后是异构供应商，**统一声明图片能力**；真正能否看图取决于命中
+     *   的某个上游模型（供应商各模型 capability 不同，网关端不能一刀切拦截）。
      */
     private static readonly INPUT_MODALITIES;
     resolveModel(_provider: string, model: string): Promise<LlmResolvedModelInfo>;

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;

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

@@ -30,7 +30,7 @@ export interface SupplierEnv {
      * 不报上来，它就会继续留在池里被轮转选中，每次都白撞一次同一个错误。
      *
      * 核心实现 = `pool.noteFailure(uid, model, state, message)`，按该状态的规则
-     * 冷却/禁用。真实案例：TRAE 免费通道对某账号拒绝某模型时发 HTTP 200 +
+     * 冷却。真实案例：TRAE 免费通道对某账号拒绝某模型时发 HTTP 200 +
      * 流内 `code=4008`，三个号里两个如此，round-robin 下 2/3 请求直接失败
      * （2026-09-08 实测）——有了这条通道，坏号被冷一次就退出轮转。
      *
@@ -43,7 +43,7 @@ export type SupplierFactory = (env: SupplierEnv) => SupplierModule;
 /**
  * 账户此刻的状态 —— 插件**解读**上游信号后的语义状态。
  *
- * 插件只报「现在怎么了」，不说「该怎么办」：冷却多久、是否禁用、要不要换号
+ * 插件只报「现在怎么了」，不说「该怎么办」：冷却多久、要不要换号
  * 都是核心的策略，见 `AccountState` 各值的处置表（docs/suppliers.md）。
  *
  * 天花板：目前是固定枚举。若将来某供应商需要更细的语义，再加值而不是放宽成
@@ -57,7 +57,7 @@ export type AccountState = 'ok' | 'rate_limit' | 'quota' | 'session_dead' | 'una
  * 把它冷却掉（历史上正是这个坑）。
  */
  | 'no_such_model';
-/** 面板展示的账号此刻状态（插件只报它观察到的部分，冷却/禁用由核心叠加）。 */
+/** 面板展示的账号此刻状态（插件只报它观察到的部分，冷却由核心叠加）。 */
 export interface SupplierAccountNow {
     uid: string;
     nickname?: string;
@@ -92,7 +92,7 @@ export type ChatOnceResult =
     status: number;
     body: string;
 }
-/** 失败：核心据此做冷却/禁用/换号。 */
+/** 失败：核心据此做冷却/换号。 */
  | {
     ok: false;
     state: AccountState;
@@ -114,7 +114,7 @@ export interface SupplierModule {
      * 应提供它——否则所有供应商弹窗都显示同一句通用提示（如默认会写 OpenRouter）。
      */
     readonly apiKeyHint?: string;
-    /** 报账号「现在状态」。冷却/禁用/错误累计由核心叠加，插件不算这些。 */
+    /** 报账号「现在状态」。冷却/错误累计由核心叠加，插件不算这些。 */
     status(): SupplierStatusNow;
     /** 模型来源。`force=true` 时强制刷新来源（核心「获取模型」按钮调用）。 */
     listModels(force?: boolean): Promise<ModelInfo[]> | ModelInfo[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-router-core",
-  "version": "0.3.13",
+  "version": "0.3.15",
   "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": {
@@ -64,11 +64,15 @@
     "prepublishOnly": "npm run build && node scripts/check-publish.mjs --pack"
   },
   "license": "MIT",
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.2"
+  },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
     "@deepseek-ai/dsh-client-locale": "^0.1.5-rc.1",
     "@deepseek-ai/dsh-client-ui-slots": "^0.1.5-rc.1",
     "@deepseek-ai/dsh-llm": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-settings": "^0.1.5-rc.2",
     "cordis": "^4.0.0-rc.7",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"

package/src/client/RouterView.tsx

@@ -100,7 +100,7 @@ export function RouterView({ onBack }: RouterViewProps): JSX.Element {
         <div className="dshr-supplierGrid">
           {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 (
               <section key={supplier.id} className="dshr-supplierCard" onClick={() => setDetailSupplier(supplier)}>
                 <div className="dshr-supplierRow">