dsh-router-core 0.3.21 → 0.4.1

package/lib/index.js

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 import { basename, dirname, join, resolve } from "node:path";
 import Schema from "@deepseek-ai/schemastery";
 import { mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
@@ -68,7 +69,27 @@ function textOf(content) {
 	return s;
 }
 /**
-* 算请求的前缀指纹。
+* 算请求的亲和指纹（选号主键）。
+*
+* **身份优先，内容兜底**：
+*   1. 宿主给了会话身份（`session`，来自 dsh-llm 的 `sessionId`）→ 直接用它。
+*      精确、零撞车 —— 同一会话永不漂移，不同会话（含 team 各成员）天然隔离。
+*   2. 没有身份（外部 OpenAI 客户端）→ 回落 {@link prefixFingerprint}。
+*
+* 为什么优先身份而不是内容指纹：DSH 的 system prompt 是同一个 agent preset
+* 生成的几 KB 文本，内容指纹只取前 512 字符 → 各会话高度雷同 → 撞车导致
+* 绑定互相覆盖、同会话漂移（team 多成员时实测过）。
+*
+* @param session 宿主会话身份；无则 undefined
+* @param messages OpenAI 请求体的 `messages`（无身份时才用）
+* @returns 指纹字符串；**空串 = 算不出来（无亲和，回退到块轮询）**
+*/
+function sessionFingerprint(session, messages) {
+	if (session !== void 0 && session !== "") return `sid:${session}`;
+	return prefixFingerprint(messages);
+}
+/**
+* 算请求的前缀指纹（内容兜底）。
 * @param messages OpenAI 请求体的 `messages` 字段（未校验，来自外部输入）
 * @returns 指纹字符串；**空串 = 算不出来（无亲和，回退到块轮询）**
 */
@@ -184,9 +205,9 @@ var AccountPool = class {
 	rrCursor = 0;
 	/** (supplier, model) → 当前驻留的号（只有**无亲和**的回退路径用它）。 */
 	blocks = /* @__PURE__ */ new Map();
-	/** (supplier, model, uid) → 该号的缓存质量样本（降权判据，跨驻留累计）。 */
+	/** (supplier, model, uid[, session]) → 该号在某会话下的缓存质量样本。 */
 	samples = /* @__PURE__ */ new Map();
-	/** (supplier, model, uid) → 缓存无效降权。 */
+	/** 同上键 → 缓存无效降权。 */
 	demoted = /* @__PURE__ */ new Map();
 	/** (supplier, model) → Map<前缀指纹, uid>：前缀亲和的选号记忆（LRU 封顶）。 */
 	affinity = /* @__PURE__ */ new Map();
@@ -196,6 +217,22 @@ var AccountPool = class {
 	key(model, uid) {
 		return `${this.supplierId}${SEP}${model}${SEP}${uid}`;
 	}
+	/**
+	* 缓存质量样本/降权的键。
+	*
+	* **按会话隔离**（team 场景的关键）：同一个号被多个会话共用时，各会话的
+	* 前缀会互相驱逐，把它们混在一起算命中率，会把「多会话互踩」误判成
+	* 「这个号缓存坏了」→ 错误降权 → 只剩一个号 → 那个号又被打低 → 降权串。
+	* 所以有会话身份时按 (model, uid, session) 记，降权只反映**该会话自己**
+	* 在这个号上的真实缓存表现。
+	*
+	* 无会话身份（外部 OpenAI 客户端，走无指纹回退路径）→ 保持 (model, uid)，
+	* 与块轮询的原语义一致（那时本就是单会话视角）。
+	*/
+	sampleKey(model, uid, session) {
+		const base = this.key(model, uid);
+		return session === void 0 || session === "" ? base : `${base}${SEP}${session}`;
+	}
 	entry(model, uid) {
 		const k = this.key(model, uid);
 		let e = this.cooldowns.get(k);
@@ -238,48 +275,98 @@ var AccountPool = class {
 		return c.until <= now;
 	}
 	/**
-	* 按策略为「某个模型」选一个健康账号。
+	* 为「某个模型」选一个健康账号 —— **会话亲和选号，无策略旋钮**。
 	*
-	* round-robin = **前缀亲和定号 + 块统计只用来判定缓存无效**：
+	* 旧的两策略（fallback 取第一个 / round-robin 轮转）都删了：前者让所有
+	* 会话挤同一个号（team/多会话必互踩），后者的"轮转"与亲和"同会话永不换号"
+	* 直接冲突。正确模型只有一条：
 	*
 	*  1. 算请求的前缀指纹（messages 前几条），查绑定表 → 命中且该号健康 → 用它。
-	*     这是第一优先：同一个会话的连续请求**永远落回同一个号**，前缀在该号的
-	*     缓存里只写一份。块轮询治不了跨会话驱逐（多会话大前缀在同一号互踩，
-	*     实测 3 会话 3.8% vs 单会话 82.5%），亲和才是根治。
+	*     同一个会话的连续请求**永远落回同一个号**，前缀在该号缓存里只写一份。
 	*  2. 新指纹（或绑定的号不健康）→ 按游标挑一个号并**记下绑定**，之后就固定。
 	*     新会话用游标分发，所以不同会话天然散到不同号上（均衡）。
-	*  3. 块统计不再驱动轮转（亲和已经保证驻留，再轮转只会把会话踢出已热前缀），
-	*     只保留 `BLOCK_MAX` 次不达标 → 降权该号（缓存无效，可恢复）。
+	*  3. 指纹算不出（拿不到 messages）→ **块轮询兜底**（§2 旧行为）。这不是
+	*     "策略"，是无会话身份时的替身。
+	*  4. 块统计不驱动轮转（亲和已保证驻留），只保留 `BLOCK_MAX` 次不达标 →
+	*     降权该号（缓存无效，可恢复）。
 	*
-	* 亲和失效（拿不到 messages / 指纹算不出）时**回退到块轮询**，行为与之前一致。
-	* 设计见 docs/pool-sticky-block.md §8。
+	* 天花板：号数 < 并发会话数时必然有会话共用号 → 互踩，无法用选号手法消除
+	* （缓存空间是账号侧物理限制）。见 docs/pool-sticky-block.md §10。
 	*
 	* @param accounts 插件报告的「现在状态」（顺序即插件的自然顺序）
 	* @param poolOrder 用户在面板拖出来的顺序（核心管）
-	* @param strategy fallback 取第一个健康 / round-robin 前缀亲和
 	* @param modelId 当前要路由的模型（决定查哪个 (model, uid) 冷却单元）
-	* @param messages 请求体的 messages（可选；给了才能算前缀指纹）
+	* @param messages 请求体的 messages（算亲和指纹的内容兜底）
+	* @param session 宿主会话身份；给了就以它为主键（精确、零撞车）
 	* @returns 选中的 uid；无健康账号返回 undefined
 	*/
-	pick(accounts, poolOrder, strategy, modelId, messages) {
+	pick(accounts, poolOrder, modelId, messages, session) {
 		const now = Date.now();
 		const byUid = new Map(accounts.map((a) => [a.uid, a]));
 		const healthy = [...poolOrder.filter((uid) => byUid.has(uid)), ...accounts.map((a) => a.uid).filter((uid) => !poolOrder.includes(uid))].filter((uid) => this.healthy(uid, modelId, now));
-		if (healthy.length === 0) return void 0;
-		if (strategy !== "round-robin") return healthy[0];
-		const usable = healthy.filter((uid) => !this.isDemoted(uid, modelId, now));
+		if (healthy.length === 0) {
+			this.lastWhy = "全池无健康号（都在冷却）";
+			return;
+		}
+		const usable = healthy.filter((uid) => !this.isDemoted(uid, modelId, now, session));
 		const pool = usable.length > 0 ? usable : healthy;
-		const fp = messages === void 0 ? "" : prefixFingerprint(messages);
-		if (fp !== "" && pool.includes(this.affinity.get(this.blockKey(modelId))?.get(fp) ?? "")) return this.affinity.get(this.blockKey(modelId)).get(fp);
+		const fp = sessionFingerprint(session, messages);
+		const bound = fp === "" ? void 0 : this.affinity.get(this.blockKey(modelId))?.get(fp);
+		if (bound !== void 0 && pool.includes(bound)) {
+			this.lastWhy = `亲和命中 ${bound}（会话/前缀已绑定）`;
+			return bound;
+		}
+		const why = [];
+		if (fp === "") why.push("无指纹（拿不到 messages/会话）");
+		else if (bound === void 0) why.push("该指纹无绑定（会话首次出现）");
+		else if (!healthy.includes(bound)) {
+			const c = this.cooldowns.get(this.key(modelId, bound));
+			why.push(`原绑定 ${bound} 正在冷却${c?.reason ? `(${c.reason})` : ""}`);
+		} else if (!usable.includes(bound)) why.push(`原绑定 ${bound} 被降权（本会话样本不达标）`);
+		else why.push(`原绑定 ${bound} 不在当前健康池`);
 		const block = this.blocks.get(this.blockKey(modelId));
-		if (fp === "" && block !== void 0 && pool.includes(block) && this.blockKeeps(modelId, block)) return block;
-		const uid = pool[(block === void 0 ? this.rrCursor : Math.max(0, pool.indexOf(block) + 1)) % pool.length];
+		if (fp === "" && block !== void 0 && pool.includes(block) && this.blockKeeps(modelId, block)) {
+			this.lastWhy = `块驻留 ${block}（无指纹路径）`;
+			return block;
+		}
+		const uid = fp !== "" ? this.allocSession(pool, modelId, fp) : pool[(block === void 0 ? this.rrCursor : Math.max(0, pool.indexOf(block) + 1)) % pool.length];
 		this.rrCursor = (pool.indexOf(uid) + 1) % pool.length;
 		this.blocks.set(this.blockKey(modelId), uid);
-		if (fp !== "") this.bind(modelId, fp, uid);
-		else this.samples.delete(this.key(modelId, uid));
+		if (fp !== "") {
+			this.bind(modelId, fp, uid);
+			const free = this.freeUids(pool, modelId, fp);
+			why.push(free.length === 0 ? `号已铺满，按游标复用 ${uid}` : `铺开到空闲号 ${uid}`);
+		} else {
+			this.samples.delete(this.key(modelId, uid));
+			why.push(`块推进到 ${uid}`);
+		}
+		this.lastWhy = why.join("；");
 		return uid;
 	}
+	/**
+	* 新会话分配：优先返回**未被其它会话占用**的号（按游标推进），
+	* 空闲号用尽才回绕到已占用的号（此时按游标复用，语义等同旧行为）。
+	*
+	* 「占用」= 该 model 的绑定表里，某个 **其它** 指纹当前指向该 uid。
+	* 同一会话自己的旧绑定不算占用（它已经在上面的亲和分支处理过，走到这里
+	* 说明原绑定不可用，允许它改绑到自己的其它号或空闲号）。
+	*/
+	allocSession(pool, modelId, fp) {
+		const free = this.freeUids(pool, modelId, fp);
+		const candidates = free.length > 0 ? free : pool;
+		return candidates[this.rrCursor % candidates.length];
+	}
+	/** 当前 model 下、本指纹之外没有任何其它会话绑定的号（按 pool 原顺序）。 */
+	freeUids(pool, modelId, fp) {
+		const taken = /* @__PURE__ */ new Set();
+		const m = this.affinity.get(this.blockKey(modelId));
+		if (m !== void 0) {
+			for (const [k, v] of m) if (k !== fp) taken.add(v);
+		}
+		return pool.filter((uid) => !taken.has(uid));
+	}
+	/** 上一次 pick 的选号理由（诊断用：解释"为什么没粘住原号"）。 */
+	lastWhy = "";
 	/** 记下「前缀指纹 → 号」的绑定（LRU：超上限丢最久未用的）。 */
 	bind(modelId, fp, uid) {
 		const k = this.blockKey(modelId);
@@ -295,9 +382,14 @@ var AccountPool = class {
 			if (oldest !== void 0) m.delete(oldest);
 		}
 	}
-	/** 该号在本模型上是否被判定「缓存无效」（降权中）。 */
-	isDemoted(uid, modelId, now) {
-		const e = this.demoted.get(this.key(modelId, uid));
+	/**
+	* 该号在**本会话**（有身份时）本模型上是否被判定「缓存无效」（降权中）。
+	*
+	* 判据按会话隔离（见 sampleKey）：降权只惩罚「这个会话在这个号上真的
+	* 反复不命中」，不会因别的会话共用同号互踩而被牵连。
+	*/
+	isDemoted(uid, modelId, now, session) {
+		const e = this.demoted.get(this.sampleKey(modelId, uid, session));
 		return e !== void 0 && e.until > now;
 	}
 	/**
@@ -323,14 +415,16 @@ var AccountPool = class {
 	* 记录一次成功请求的缓存命中情况（降权判据的反馈信号）。
 	*
 	* 只有**成功**请求才计入：失败没产生缓存，计入会污染命中率并导致错降权。
-	* 统计按 (model, uid) 记，**不管这个号是不是「当前驻留」**——亲和开启后
-	* 多个会话各绑各的号交错服务，按驻留记会漏掉大部分真实反馈。
+	* 统计按 (model, uid[, session]) 记，**不管这个号是不是「当前驻留」**——
+	* 亲和开启后多个会话各绑各的号交错服务，按驻留记会漏掉大部分真实反馈。
+	* 按会话隔离（见 sampleKey）则保证「多会话共用同号互踩」不会误伤降权。
 	* @param uid 实际服务的号
 	* @param modelId 模型（块粒度）
 	* @param cachedTokens 上游报的命中 token 数；0 = 全量重算
+	* @param session 宿主会话身份；有则按会话隔离统计
 	*/
-	noteCache(uid, modelId, cachedTokens) {
-		const k = this.key(modelId, uid);
+	noteCache(uid, modelId, cachedTokens, session) {
+		const k = this.sampleKey(modelId, uid, session);
 		const s = this.samples.get(k) ?? {
 			served: 0,
 			hits: 0
@@ -467,11 +561,11 @@ var SupplierConfigStore = class {
 		let cfg = this.bySupplier.get(supplierId);
 		if (!cfg) {
 			cfg = {
+				enabled: true,
 				alias: "",
 				disabled: [],
 				custom: [],
 				poolOrder: [],
-				poolStrategy: "fallback",
 				credits: {},
 				accountNames: {}
 			};
@@ -495,6 +589,22 @@ var SupplierConfigStore = class {
 		this.saveLocked();
 		return { ok: true };
 	}
+	/** 这个供应商是否参与路由（未记录过 = 开）。 */
+	isEnabled(supplierId) {
+		return this.get(supplierId).enabled;
+	}
+	/**
+	* 置供应商开关。**不写盘**时值不变也要返回，让调用方知道是否需要重连路由。
+	* @returns 值确实变了
+	*/
+	setEnabled(supplierId, enabled) {
+		if (supplierId === "") return false;
+		const cfg = this.get(supplierId);
+		if (cfg.enabled === enabled) return false;
+		cfg.enabled = enabled;
+		this.saveLocked();
+		return true;
+	}
 	setModelEnabled(supplierId, modelId, enabled) {
 		const cfg = this.get(supplierId);
 		cfg.disabled = enabled ? cfg.disabled.filter((m) => m !== modelId) : [.../* @__PURE__ */ new Set([...cfg.disabled, modelId])];
@@ -520,11 +630,6 @@ var SupplierConfigStore = class {
 		this.get(supplierId).poolOrder = [...new Set(uids)];
 		this.saveLocked();
 	}
-	setPoolStrategy(supplierId, strategy) {
-		if (strategy !== "fallback" && strategy !== "round-robin") return;
-		this.get(supplierId).poolStrategy = strategy;
-		this.saveLocked();
-	}
 	/** 读某连接的显示别名;没设或为空返回 `undefined`(用供应商原始昵称)。 */
 	getAccountName(supplierId, uid) {
 		const n = this.get(supplierId).accountNames[uid];
@@ -578,11 +683,11 @@ var SupplierConfigStore = class {
 			return;
 		}
 		for (const [id, c] of Object.entries(f.suppliers ?? {})) this.bySupplier.set(id, {
+			enabled: typeof c.enabled === "boolean" ? c.enabled : true,
 			alias: typeof c.alias === "string" ? c.alias : "",
 			disabled: Array.isArray(c.disabled) ? c.disabled.filter((m) => typeof m === "string") : [],
 			custom: Array.isArray(c.custom) ? c.custom.filter((m) => typeof m === "string") : [],
 			poolOrder: Array.isArray(c.poolOrder) ? c.poolOrder.filter((u) => typeof u === "string") : [],
-			poolStrategy: c.poolStrategy === "round-robin" ? "round-robin" : "fallback",
 			credits: readCredits(c.credits),
 			accountNames: readNames(c.accountNames)
 		});
@@ -591,11 +696,11 @@ var SupplierConfigStore = class {
 		if (this.fp === "") return;
 		const f = { suppliers: {} };
 		for (const [id, cfg] of this.bySupplier) f.suppliers[id] = {
+			enabled: cfg.enabled,
 			alias: cfg.alias,
 			disabled: [...cfg.disabled],
 			custom: [...cfg.custom],
 			poolOrder: [...cfg.poolOrder],
-			poolStrategy: cfg.poolStrategy,
 			credits: { ...cfg.credits },
 			accountNames: { ...cfg.accountNames }
 		};
@@ -889,6 +994,16 @@ var UsageStore = class UsageStore {
 	recentList(limit = 20) {
 		return this.recent.slice(0, limit);
 	}
+	/**
+	* 最近一次命中。给了 `session` 就只在该会话的记录里找（「最近命中」徽章
+	* 要显示**当前会话**的命中，team 多会话下全局最近会张冠李戴）；
+	* 不给则退回全局最近一条。
+	* @param session 宿主会话身份；undefined = 全局
+	*/
+	lastHit(session) {
+		if (session === void 0) return this.recent[0];
+		return this.recent.find((r) => r.session === session);
+	}
 	clear() {
 		this.days.clear();
 		this.recent = [];
@@ -1302,8 +1417,8 @@ function withEstimates(usage, requestChars, outputChars) {
 //#region src/router/index.ts
 /**
 * dsh-router 路由器本体：供应商注册表 + OpenAI 兼容 /v1/* 处理。
-* 仿 9router：组合 = 一组模型，请求 model 命中组合名时，按策略
-* （fallback 顺序尝试 / round-robin 轮转）选中一个模型路由。
+* 仿 9router：组合 = 一组模型，请求 model 命中组合名时，作为降级链
+* 按序尝试选中一个模型路由（无策略旋钮，见 docs/pool-sticky-block.md §10）。
 */
 /**
 * 模型列表缓存有效期。
@@ -1357,6 +1472,99 @@ function isTransient(state) {
 	return state === "transport" || state === "unavailable";
 }
 /**
+* **每条降级腿的首字节预算**：从进入这条腿起，多久内上游必须吐出第一个字节。
+*
+* 为什么必须有（2026-09-24 夜里 money 组合实测）：上游（codebuddy 系）额度用完 /
+* 过载时，连接照常建立、HTTP 200 响应头照常回来，**body 却一个字节都不吐**。
+* 这既不是成功也不是失败，于是
+*   - `chatOnce` 的 120s 只守「连接+响应头」，`fetch` 一返回就撤表 → 守不到 body
+*   - 核心写响应的路径也没有任何计时器 → 组合链卡在这一条腿上不动
+*   - 客户端（dsh-router 自己的 adapter）有 300s 流空闲超时，但那是「整条请求」
+*     的兜底，与降级无关
+* 实测用户干等 200 多秒手动暂停：ttfb 84s / 122s / 151s / 244s / 246s / 250s /
+* 254s / 255s，8 次全部 `ok: true`——**全都最终成功了**，只是晚了四分钟。同一批
+* 账号因为「没失败」也不冷却，下一次请求继续挑它（cb-8 连吃 248s + 155s）。
+*
+* 60s 的来历（本机 500 条真实请求的 ttfb 分布）：p50 4.1s / p95 14.9s，
+* 最大的**非停滞**值 47.7s，停滞簇从 84.5s 起 —— 60s 正落在两簇之间的空档，
+* 砍得动停滞、砍不到真实慢请求。首个字节之后**不再计时**：长生成可以跑很久。
+*
+* 为什么按「腿」而不是按「账号」计：停滞是上游级的（同一供应商的所有号一起
+* 挂）。按账号计的话，codebuddy 有 11 个号，一次请求能 11×60s = 11 分钟才轮到
+* 下一个模型；按腿计，最坏 3 条腿 × 60s ≈ 3 分钟，且期间一定会走到下一个模型。
+*/
+const FIRST_BYTE_BUDGET_MS = 6e4;
+/**
+* 给上游流套一层**首字节截止**：截止前一个字节都没来，就把这条流判失败
+* （error 出去，调用方看到「一个字节都没写」→ 换号/换模型）。
+* 第一个字节到手后立刻撤表，之后多久都不管。
+*
+* 为什么套在核心而不是插件：首字节迟迟不来时，**只有核心**能做「还没提交响应
+* → 换一条腿」的决定（插件在 `fetch` 拿到响应头那一刻就把流交出去了，
+* 谁也没法再改结果）。核心也是所有供应商唯一的收口点，套一次全都受益。
+*/
+function withFirstByteDeadline(stream, ms) {
+	const reader = stream.getReader();
+	let first = true;
+	/** 消费方已取消：这之后任何 ctrl.* 都会抛（流已死），必须全部跳过。 */
+	let cancelled = false;
+	/**
+	* 上游 reader 只解绑一次。wrapper 替核心持有了这个 reader，所以**必须由
+	* wrapper 负责收尾**：上游正常读完 / 上游自己 error / 被取消时都解锁，
+	* 否则流永久锁着，上层想 cancel 会抛 `Invalid state: ReadableStream is locked`
+	* （disconnect-leak 那条判据守的就是这个；历史上由 aggregateSSE 的 finally 解锁，
+	* 现在读的是 wrapper，解绑责任跟着搬过来）。
+	*/
+	let released = false;
+	const release = () => {
+		if (released) return;
+		released = true;
+		try {
+			reader.releaseLock();
+		} catch {}
+	};
+	/** 取消要传到底下的上游（cancel 本身会顺带解锁）。 */
+	const cancelUpstream = (reason) => {
+		if (released) return Promise.resolve();
+		released = true;
+		return reader.cancel(reason).then(() => {}, () => {});
+	};
+	return new ReadableStream({
+		async pull(ctrl) {
+			let expired = false;
+			const timer = first ? setTimeout(() => {
+				expired = true;
+				cancelUpstream(/* @__PURE__ */ new Error("first byte timeout"));
+				try {
+					ctrl.error(/* @__PURE__ */ new Error(`no first byte within ${ms}ms`));
+				} catch {}
+			}, ms) : void 0;
+			try {
+				const { done, value } = await reader.read();
+				if (expired || cancelled) return;
+				if (done) {
+					release();
+					ctrl.close();
+					return;
+				}
+				first = false;
+				ctrl.enqueue(value);
+			} catch (e) {
+				release();
+				if (!expired && !cancelled) try {
+					ctrl.error(e);
+				} catch {}
+			} finally {
+				if (timer !== void 0) clearTimeout(timer);
+			}
+		},
+		cancel: (reason) => {
+			cancelled = true;
+			return cancelUpstream(reason);
+		}
+	});
+}
+/**
 * 从请求体里取 `messages`（前缀亲和的指纹输入）。解析失败/字段缺失返回
 * undefined —— 亲和拿不到输入就自动回退到块轮询，不影响路由本身。
 */
@@ -1627,8 +1835,11 @@ function fixFrame(frame) {
 *
 * 天花板：一旦写出第一个字节就绑死（HTTP 语义），中途断流只能截断，
 * 不能回退。要彻底解决得在写头前缓冲判定，代价是首字节延迟——未做。
+*
+* @param firstByteTimeoutMs 上游多久内必须吐出第一个字节（见 FIRST_BYTE_BUDGET_MS）。
+*   超时按「一个字节都没写」返回 false，调用方照常换号/换模型。
 */
-async function writeChatResult(res, r, wantsStream, probe, startedAt = 0) {
+async function writeChatResult(res, r, wantsStream, probe, startedAt = 0, firstByteTimeoutMs = FIRST_BYTE_BUDGET_MS) {
 	if (!r.ok) return false;
 	if (!("stream" in r)) {
 		if (probe !== void 0) probe.tokens = usageFromJsonBody(r.body);
@@ -1639,12 +1850,13 @@ async function writeChatResult(res, r, wantsStream, probe, startedAt = 0) {
 		res.end(r.body);
 		return true;
 	}
+	const src = withFirstByteDeadline(r.stream, firstByteTimeoutMs);
 	if (!wantsStream) {
 		let body;
 		try {
-			body = await aggregateSSE(r.stream);
+			body = await aggregateSSE(src);
 		} catch {
-			await r.stream.cancel().catch(() => {});
+			await src.cancel().catch(() => {});
 			return false;
 		}
 		if (probe !== void 0) probe.tokens = usageFromJsonBody(body);
@@ -1655,7 +1867,7 @@ async function writeChatResult(res, r, wantsStream, probe, startedAt = 0) {
 		res.end(body);
 		return true;
 	}
-	const tapped = probe === void 0 ? void 0 : tapStreamUsage(r.stream, startedAt);
+	const tapped = probe === void 0 ? void 0 : tapStreamUsage(src, startedAt);
 	let wroteAny = false;
 	/** 响应已死（客户端断开/res 已销毁）：等 drain 的写入要立刻放弃，别吊死。 */
 	let dead = false;
@@ -1719,7 +1931,7 @@ async function writeChatResult(res, r, wantsStream, probe, startedAt = 0) {
 		abort.abort();
 	};
 	res.once("close", onClose);
-	const norm = normalizeSSEStream(tapped?.stream ?? r.stream);
+	const norm = normalizeSSEStream(tapped?.stream ?? src);
 	try {
 		await norm.stream.pipeTo(new WritableStream({ write: writeChunk }), { signal: abort.signal });
 	} catch {} finally {
@@ -1750,12 +1962,16 @@ function extractUpstreamError(body) {
 }
 /** 路由器。 */
 var Router = class {
+	/**
+	* **已装载**的全部供应商（含被开关关掉的）。关掉的仍留在列表里 —— 否则用户关掉
+	* 之后它在 `/health`、面板、插件页里一起消失，开关就没有可指的对象、也没法再开。
+	*
+	* 真正参与路由的只有 `active` 那一份。
+	*/
 	suppliers = [];
 	combosFp = "";
 	customCombos = [];
-	/** round-robin 轮转游标（按组合 id 记忆）。 */
-	rrCursors = /* @__PURE__ */ new Map();
-	/** 通用供应商配置（连接池顺序/策略、模型启用、别名）。 */
+	/** 通用供应商配置（连接池顺序、模型启用、别名）。 */
 	store;
 	/** 模型列表缓存（supplierId → 模型 + 拉取时间）。插件只管拉，不缓存。 */
 	modelsCache = /* @__PURE__ */ new Map();
@@ -1766,12 +1982,15 @@ var Router = class {
 	modelsInflight = /* @__PURE__ */ new Map();
 	/** 请求日志出口（面板/宿主 logger）。 */
 	log;
+	/** 每条降级腿的首字节预算（ms）。只给测试一个入口，生产恒为 FIRST_BYTE_BUDGET_MS。 */
+	firstByteBudgetMs;
 	/** 用量统计（概览看板）。 */
 	usage;
-	constructor(stateFile = "", store, log) {
+	constructor(stateFile = "", store, log, opts) {
 		this.combosFp = stateFile ? join(dirname(stateFile), "combos.json") : "";
 		this.store = store ?? new SupplierConfigStore(stateFile);
 		this.log = log ?? (() => {});
+		this.firstByteBudgetMs = opts?.firstByteBudgetMs ?? FIRST_BYTE_BUDGET_MS;
 		this.usage = new UsageStore(stateFile);
 		this.loadCombos();
 	}
@@ -1795,13 +2014,12 @@ var Router = class {
 					if (slash <= 0) return m;
 					const alias = m.slice(0, slash);
 					const modelId = m.slice(slash + 1);
-					const s = this.suppliers.find((x) => x.getAlias() === alias);
+					const s = this.active.find((x) => x.getAlias() === alias);
 					return s === void 0 ? modelId : `${s.id},${modelId}`;
 				});
 				return {
 					id: c.id,
 					name: typeof c.name === "string" ? c.name : c.id,
-					strategy: c.strategy === "round-robin" ? "round-robin" : "fallback",
 					models
 				};
 			}).filter((c) => c.models.length > 0);
@@ -1823,6 +2041,20 @@ var Router = class {
 		this.suppliers.sort((a, b) => a.priority - b.priority);
 		this.store.sync(this.suppliers.map((s) => s.id));
 	}
+	/**
+	* **参与路由的供应商** —— 装载清单里开关为开的那一份，按 priority 排好。
+	*
+	* 这是「供应商开关」唯一的收口点：请求分发、别名反查、模型列表、组合、面板状态
+	* 全部读它。关掉一个供应商 = 它从这里消失，而不是在每个调用点各写一遍判断 ——
+	* 后者一定会漏（本次实测路由有 15 处读 `this.suppliers`）。
+	*/
+	get active() {
+		return this.suppliers.filter((s) => this.store.isEnabled(s.id));
+	}
+	/** 某供应商当前是否参与路由（面板与 API 用）。 */
+	isEnabled(supplierId) {
+		return this.store.isEnabled(supplierId);
+	}
 	/** 移除供应商（外部插件卸载时注销）。 */
 	removeSupplier(id) {
 		const i = this.suppliers.findIndex((s) => s.id === id);
@@ -1832,13 +2064,20 @@ var Router = class {
 		s?.dispose();
 		return true;
 	}
-	/** 返回全部供应商状态（面板用）。 */
+	/**
+	* 返回全部供应商状态（面板用）。**含被开关关掉的** —— 面板要能显示它们
+	* （「已关闭」），否则用户在面板上就再也看不到自己装过的供应商。
+	* 开关状态由 `enabled` 字段带出，调用方自己决定要不要只留开着的。
+	*/
 	status() {
-		return { suppliers: this.suppliers.map((s) => s.status()) };
+		return { suppliers: this.suppliers.map((s) => ({
+			...s.status(),
+			enabled: this.store.isEnabled(s.id)
+		})) };
 	}
-	/** 供应商前缀信息（组合模型全名 = alias/id，展示时动态拼接）。 */
+	/** 供应商前缀信息（组合模型全名 = alias/id，展示时动态拼接）。只含开着的。 */
 	aliases() {
-		return this.suppliers.map((s) => ({
+		return this.active.map((s) => ({
 			id: s.id,
 			name: s.name,
 			alias: s.getAlias()
@@ -1856,7 +2095,7 @@ var Router = class {
 			seen.add(c.name);
 			out.push({ id: c.name });
 		}
-		for (const s of this.suppliers) try {
+		for (const s of this.active) try {
 			const ids = s.customModelIds?.();
 			for (const id of ids ?? []) if (!seen.has(id)) {
 				seen.add(id);
@@ -1915,7 +2154,7 @@ var Router = class {
 		return min;
 	}
 	async modelsOf(supplierId, force = false) {
-		const s = this.suppliers.find((x) => x.id === supplierId);
+		const s = this.active.find((x) => x.id === supplierId);
 		if (s === void 0) return [];
 		const hit = this.modelsCache.get(supplierId);
 		const fresh = hit !== void 0 && Date.now() - hit.fetchedAt < MODELS_TTL_MS;
@@ -1979,7 +2218,7 @@ var Router = class {
 	/** 可用模型（按供应商分组，仅启用），面板加模型用。
 	*  各供应商**并行**拉取——串行会把每个上游的延迟累加起来。 */
 	async supplierModels() {
-		return (await Promise.all(this.suppliers.map(async (s) => {
+		return (await Promise.all(this.active.map(async (s) => {
 			try {
 				const models = (await this.modelsOf(s.id)).filter((m) => m.enabled);
 				return {
@@ -1998,9 +2237,6 @@ var Router = class {
 	validModels(models) {
 		return Array.isArray(models) && models.length > 0 && models.every((m) => typeof m === "string" && m !== "");
 	}
-	validStrategy(strategy) {
-		return strategy === "fallback" || strategy === "round-robin";
-	}
 	/** 组合模型统一存裸 id：剥掉 alias/ 前缀（前缀随供应商动态变）。
 	*  只剥「已知 alias + /」开头的前缀——模型 id 本身可以含斜杠
 	*  （如 nvidia 的 `deepseek-ai/deepseek-v4-flash-0731`），用 lastIndexOf 会把
@@ -2017,12 +2253,12 @@ var Router = class {
 			if (slash <= 0) return m;
 			const alias = m.slice(0, slash);
 			const modelId = m.slice(slash + 1);
-			const s = this.suppliers.find((x) => x.getAlias() === alias);
+			const s = this.active.find((x) => x.getAlias() === alias);
 			return s === void 0 ? modelId : `${s.id},${modelId}`;
 		});
 	}
-	/** 创建组合（name 唯一，非 default）。 */
-	createCombo(name, strategy, models) {
+	/** 创建组合（name 唯一，非 default）。选模型是降级链（按序尝试），无策略。 */
+	createCombo(name, models) {
 		const clean = name.trim();
 		if (clean === "" || clean === "default") return {
 			ok: false,
@@ -2040,14 +2276,9 @@ var Router = class {
 			ok: false,
 			error: "至少需要一个模型"
 		};
-		if (!this.validStrategy(strategy)) return {
-			ok: false,
-			error: "策略无效"
-		};
 		const combo = {
 			id: clean,
 			name: clean,
-			strategy,
 			models: this.normalizeModelIds(models)
 		};
 		this.customCombos.push(combo);
@@ -2058,7 +2289,7 @@ var Router = class {
 		};
 	}
 	/** 更新组合（按 id）。 */
-	updateCombo(id, name, strategy, models) {
+	updateCombo(id, name, models) {
 		const target = this.customCombos.find((c) => c.id === id);
 		if (!target) return {
 			ok: false,
@@ -2081,12 +2312,7 @@ var Router = class {
 			ok: false,
 			error: "至少需要一个模型"
 		};
-		if (!this.validStrategy(strategy)) return {
-			ok: false,
-			error: "策略无效"
-		};
 		target.name = clean;
-		target.strategy = strategy;
 		target.models = this.normalizeModelIds(models);
 		this.saveCombos();
 		return { ok: true };
@@ -2143,18 +2369,17 @@ var Router = class {
 				durationMs: Date.now() - probe.startedAt,
 				ttfbMs: probe.ttfbMs,
 				...ok && probe.uid !== "" ? { uid: probe.uid } : {},
+				...req.session === void 0 ? {} : { session: req.session },
 				...error === void 0 ? {} : { error }
 			}, usage);
 		};
 		const combo = this.comboByName(req.model);
 		if (combo) {
-			const start = combo.strategy === "round-robin" ? (this.rrCursors.get(combo.id) ?? 0) % combo.models.length : 0;
-			if (combo.strategy === "round-robin") this.rrCursors.set(combo.id, (this.rrCursors.get(combo.id) ?? 0) + 1);
 			for (let i = 0; i < combo.models.length; i++) {
-				const model = combo.models[(start + i) % combo.models.length];
+				const model = combo.models[i];
 				if (model === void 0) continue;
 				const trace = { attempts: 0 };
-				if (await this.chatWithModel(req, res, model, probe, trace)) {
+				if (await this.chatWithModel(req, res, model, probe, trace, Date.now() + this.firstByteBudgetMs)) {
 					settle(true);
 					return;
 				}
@@ -2200,8 +2425,11 @@ var Router = class {
 	* @param outTrace 可选出参：把这次调用的追踪信息带回去（组合据此判断
 	*   要不要「喘口气」再降级）。裸 id 遍历路径不填（多供应商混在一起，
 	*   失败状态没有单一归属）。
+	* @param firstByteDeadlineAt 这条腿的首字节截止时刻（绝对 ms）。同一条腿内的
+	*   多个账号共享它——停滞是上游级的，按号各给一份会 11×60s 才轮到下一个模型。
+	*   缺省 = 此刻起一份全新预算（直接调用路径只有这一条腿）。
 	*/
-	async chatWithModel(req, res, model, probe, outTrace) {
+	async chatWithModel(req, res, model, probe, outTrace, firstByteDeadlineAt = Date.now() + this.firstByteBudgetMs) {
 		const comma = model.indexOf(",");
 		const supplierId = comma > 0 ? model.slice(0, comma) : void 0;
 		const modelId = comma > 0 ? model.slice(comma + 1) : model;
@@ -2221,25 +2449,26 @@ var Router = class {
 			this.logChat(req.model, msg, 0);
 			return false;
 		}
-		const s = this.suppliers.find((x) => x.id === supplierId);
+		const s = this.active.find((x) => x.id === supplierId);
 		if (s === void 0) {
-			this.logChat(req.model, `supplier ${JSON.stringify(supplierId)} 不存在`, 0);
+			const reason = this.suppliers.some((x) => x.id === supplierId) ? `supplier ${JSON.stringify(supplierId)} 已关闭` : `supplier ${JSON.stringify(supplierId)} 不存在`;
+			this.logChat(req.model, reason, 0);
 			return false;
 		}
 		const t0 = Date.now();
 		const trace = { attempts: 0 };
-		const served = await this.chatWithSupplier(s, clone, res, trace, probe);
+		const served = await this.chatWithSupplier(s, clone, res, trace, probe, firstByteDeadlineAt);
 		if (outTrace !== void 0) {
 			outTrace.attempts = trace.attempts;
 			outTrace.lastError = trace.lastError;
 			outTrace.lastState = trace.lastState;
 		}
-		this.logChat(req.model, served ? `${s.id}/${modelId} (${trace.uid ?? "?"}) ok${trace.attempts > 0 ? ` 重试${trace.attempts}次` : ""}` : `${s.id}/${modelId} 失败 ${trace.lastError ?? "no account"}`, Date.now() - t0);
+		this.logChat(req.model, served ? `${s.id}/${modelId} (${trace.uid ?? "?"}) ok${trace.attempts > 0 ? ` 重试${trace.attempts}次` : ""}${trace.pickWhy !== void 0 ? ` [选号: ${trace.pickWhy}]` : ""}` : `${s.id}/${modelId} 失败 ${trace.lastError ?? "no account"}`, Date.now() - t0);
 		return served;
 	}
 	/** 按别名找供应商（对外模型全名 = alias/model）。别名唯一，故最多命中一个。 */
 	supplierByAlias(alias) {
-		return this.suppliers.find((s) => s.getAlias() === alias);
+		return this.active.find((s) => s.getAlias() === alias);
 	}
 	/**
 	* 单个供应商内遍历账号（核心策略）：选号 → 调 chatOnce → 按返回的
@@ -2249,8 +2478,16 @@ var Router = class {
 	* 还能换号重试；一旦写出第一个字节就绑死（HTTP 语义，9router 同样如此），
 	* 之后出错不再换号——要彻底能回退就得在写头前缓冲判定，代价是首字节
 	* 延迟，目前未做。
+	*
+	* @param firstByteDeadlineAt 这条腿的首字节截止时刻（见 chatWithModel）。
+	*   预算耗尽后不再调任何号：剩下的号大概率同样停滞（上游级故障），
+	*   挨个等下去只会把 60s 乘以号数，组合永远轮不到下一个模型。
+	*/
+	/**
+	* @param onlyUid - 只试这一个连接，**不做账号池回退**。给面板「指定连接」那档用
+	*   （诊断单个链接到底通不通）；正常请求与普通模型测试都不传，走账号池。
 	*/
-	async chatWithSupplier(s, req, res, trace, probe) {
+	async chatWithSupplier(s, req, res, trace, probe, firstByteDeadlineAt = Date.now() + this.firstByteBudgetMs, onlyUid) {
 		const pool = s.pool;
 		const cfg = this.store.get(s.id);
 		if (s.accounts !== void 0 && s.accounts().length === 0) {
@@ -2267,13 +2504,28 @@ var Router = class {
 				probe.model = `${s.getAlias()}/${stripAlias(req.model, s.getAlias())}`;
 				probe.uid = "";
 			}
-			return await writeChatResult(res, r, req.stream, probe, probe?.startedAt ?? 0);
+			return await writeChatResult(res, r, req.stream, probe, probe?.startedAt ?? 0, firstByteDeadlineAt - Date.now());
 		}
 		const messages = reqMessages(req.rawBody);
 		const tried = /* @__PURE__ */ new Set();
+		let pickWhy = "";
 		for (;;) {
-			const uid = pool.pick(s.accounts().filter((a) => !tried.has(a.uid)), cfg.poolOrder, cfg.poolStrategy, req.model, messages);
-			if (uid === void 0) return false;
+			const uid = onlyUid !== void 0 ? s.accounts().some((a) => a.uid === onlyUid) && !tried.has(onlyUid) ? onlyUid : void 0 : pool.pick(s.accounts().filter((a) => !tried.has(a.uid)), cfg.poolOrder, req.model, messages, req.session);
+			if (uid === void 0) {
+				if (onlyUid !== void 0 && trace !== void 0) {
+					trace.lastState = "unknown";
+					trace.lastError = `连接 ${JSON.stringify(onlyUid)} 不存在（可能已被删除）`;
+				}
+				return false;
+			}
+			if (firstByteDeadlineAt - Date.now() <= 0) {
+				if (trace !== void 0) {
+					trace.lastState = "transport";
+					trace.lastError = "first-byte budget exhausted";
+				}
+				return false;
+			}
+			pickWhy = pool.lastWhy;
 			tried.add(uid);
 			const r = await s.chatOnce(uid, req.lv ?? "auto", req);
 			if (!r.ok) {
@@ -2294,14 +2546,17 @@ var Router = class {
 				continue;
 			}
 			pool.noteSuccess(uid, req.model);
-			if (trace !== void 0) trace.uid = uid;
+			if (trace !== void 0) {
+				trace.uid = uid;
+				trace.pickWhy = pickWhy;
+			}
 			if (probe !== void 0) {
 				probe.supplier = s.id;
 				probe.model = `${s.getAlias()}/${stripAlias(req.model, s.getAlias())}`;
 				probe.uid = uid;
 			}
-			if (await writeChatResult(res, r, req.stream, probe, probe?.startedAt ?? 0)) {
-				pool.noteCache(uid, req.model, probe?.tokens?.cachedTokens ?? 0);
+			if (await writeChatResult(res, r, req.stream, probe, probe?.startedAt ?? 0, firstByteDeadlineAt - Date.now())) {
+				pool.noteCache(uid, req.model, probe?.tokens?.cachedTokens ?? 0, req.session);
 				return true;
 			}
 			pool.noteFailure(uid, req.model, "transport", "stream failed before first byte");
@@ -2312,11 +2567,17 @@ var Router = class {
 			}
 		}
 	}
-	/** 测试某供应商的某模型是否可用。
-	*  走真实的账号遍历 + chatOnce 路径：账号池回退/冷却由核心实现，自动生效；
-	*  响应丢弃到 sink，限定单一供应商（不跨供应商回退）。 */
-	async testModel(supplierId, model) {
-		const s = this.suppliers.find((x) => x.id === supplierId);
+	/**
+	* 测试某供应商的某模型是否可用。
+	*
+	* 走真实的账号遍历 + chatOnce 路径：账号池回退/冷却由核心实现，自动生效；
+	* 响应丢弃到 sink，限定单一供应商（不跨供应商回退）。
+	*
+	* @param onlyUid - 限定只测这一个连接（诊断单个链接），**不做账号池回退**。
+	*   不传 = 与面板「测试」按钮完全同一条路径（池内任选可用号，失败自动换号）。
+	*/
+	async testModel(supplierId, model, onlyUid) {
+		const s = this.active.find((x) => x.id === supplierId);
 		if (s === void 0) return {
 			ok: false,
 			error: `unknown supplier ${JSON.stringify(supplierId)}`
@@ -2338,7 +2599,7 @@ var Router = class {
 		let served = false;
 		const trace = { attempts: 0 };
 		try {
-			served = await this.chatWithSupplier(s, req, sink, trace);
+			served = await this.chatWithSupplier(s, req, sink, trace, void 0, Date.now() + this.firstByteBudgetMs, onlyUid);
 		} catch (err) {
 			return {
 				ok: false,
@@ -2371,8 +2632,43 @@ var Router = class {
 * `image` 块序列化成 OpenAI 标准的 `image_url` base64 part，经 /v1 原样透传给
 * 命中的上游供应商。最终能否看图取决于**命中的那个上游模型**——组合里是异构
 * 供应商，可能在网关端声明了图片能力、某条上游却只收文本（此时由上游自行拒收）。
-* 图片字节从 `ctx.attachments` 读取（读不到的按稳定占位文本降级，绝不静默丢图）。
+* 图片字节从 `ctx.attachments` 读取。读不到时按稳定占位文本降级（不让整条消息失败），
+* 但**必须留痕**：降级原因走 adapter 的 `log` 出口打到宿主 logger。曾经这里是
+* 一个空 `catch {}`，字段改名导致的读图失败静默了跨两个内测版本（issue #8）。
+*/
+/** 送上游的请求图的像素预算（宽 × 高），沿用 0.1.5 时代 `maxPixels` 的意图。 */
+const MAX_REQUEST_PIXELS = 64e4;
+/** 送上游的请求图的字节上限。 */
+const MAX_REQUEST_BYTES = 1048576;
+/**
+* 把源图尺寸投影到「总像素 ≤ maxPixels」的请求目标（等比、只缩不放）。
+*
+* 为什么需要它：宿主 0.1.6 起要的是 `ImageRequestTarget`（width/height/maxBytes），
+* 而「别把一张 12MP 手机照原样塞进对话」这个意图原本靠 `maxPixels` 表达。
+* 宿主自己**只按 target 的长边**缩放、短边由它推，所以我们要做的只是给出一组
+* 落在预算内的正整数；短边取 floor 即可（它只参与校验与缓存键，不决定出图尺寸）。
+*
+* 没有直接复用官方的 `requestImageDimensions`（`@deepseek-ai/dsh-attachment` 有导出）：
+* 本文件刻意不依赖那个包（见 `RouterAttachmentStore` 的说明 —— 它是宿主注入的
+* devDependency，引入它等于给插件加一条编译期/运行期依赖）。这 8 行是纯函数、
+* 有测试钉住；真要换成官方实现时，语义等价。
 */
+function projectImageDimensions(width, height, maxPixels) {
+	const pixels = width * height;
+	if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) return {
+		width,
+		height
+	};
+	if (pixels <= maxPixels) return {
+		width,
+		height
+	};
+	const scale = Math.sqrt(maxPixels / pixels);
+	return {
+		width: Math.max(1, Math.floor(width * scale)),
+		height: Math.max(1, Math.floor(height * scale))
+	};
+}
 /**
 * 把 DSH 消息序列化成 openai 兼容 wire 消息（文本 + 图片 + tool）。
 *
@@ -2390,6 +2686,10 @@ var Router = class {
 * 图片：`image` 块被序列化成 OpenAI `content` 数组里的 `image_url` part（data URI
 * base64）。图片字节经 `resolveAttachments` 读取；读不到时回退为稳定的占位文本，
 * **绝不静默丢图**（丢图 = 模型看到一条没有图的消息却毫无提示）。
+*
+* 工具结果双模型兼容：0.1.5/0.1.6 里 tool result 是 user 消息里的 'tool-result' 块
+* （旧路径）；0.1.7+ 改成了独立 role:'tool' 消息、toolCallId 挂消息级（新分支）。
+* 两者在 wire 上统一序列化为 role:'tool'，产物一致。见主循环里的 role==='tool' 分支。
 */
 /** tool-result 里图片挂到 user 消息时用的说明文字（与官方适配器一致）。 */
 const TOOL_RESULT_IMAGE_TEXT = "Tool result images";
@@ -2403,7 +2703,7 @@ const TOOL_RESULT_IMAGE_TEXT = "Tool result images";
 * 只守空闲、不封总时长：长生成只要持续吐块就不该被打断。
 */
 const STREAM_IDLE_TIMEOUT_MS = 3e5;
-async function wireMessages(options, system, attachments) {
+async function wireMessages(options, system, attachments, log) {
 	const out = [];
 	/**
 	* 攒着「tool-result 里带出来的图片」，等这一串 tool 消息**发完**再合并成一条
@@ -2461,8 +2761,21 @@ async function wireMessages(options, system, attachments) {
 			});
 			continue;
 		}
+		if (message.role === "tool") {
+			const toolCallId = message.toolCallId;
+			const parts = await contentParts(message.content, attachments, options.signal, log);
+			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: String(toolCallId ?? ""),
+				content: text
+			});
+			pendingToolImages.push(...imageParts);
+			continue;
+		}
 		const toolResults = message.content.filter((b) => b.type === "tool-result");
-		const ownParts = await contentParts(message.content.filter((b) => b.type !== "tool-result"), attachments, options.signal);
+		const ownParts = await contentParts(message.content.filter((b) => b.type !== "tool-result"), attachments, options.signal, log);
 		if (ownParts.length > 0 || toolResults.length === 0) {
 			flushToolImages();
 			out.push({
@@ -2471,7 +2784,7 @@ async function wireMessages(options, system, attachments) {
 			});
 		}
 		for (const result of toolResults) {
-			const parts = await contentParts(result.content, attachments, options.signal);
+			const parts = await contentParts(result.content, attachments, options.signal, log);
 			const imageParts = parts.filter((p) => p.type !== "text");
 			const text = parts.filter((p) => p.type === "text").map((p) => p.text ?? "").join("");
 			out.push({
@@ -2502,7 +2815,7 @@ function compactUserContent(parts) {
 * 纯文本时返回空数组（上层走紧凑字符串路径）。图片转 base64 data URI；
 * attachments 缺失或读取失败时回退稳定占位文本（绝不静默丢图）。
 */
-async function contentParts(blocks, attachments, signal) {
+async function contentParts(blocks, attachments, signal, log) {
 	const parts = [];
 	for (const block of blocks) {
 		if (block.type === "text") {
@@ -2515,35 +2828,41 @@ async function contentParts(blocks, attachments, signal) {
 		}
 		if (block.type === "image") {
 			const ref = block.attachment;
-			parts.push(...await imageParts(ref, attachments, signal));
+			parts.push(...await imageParts(ref, attachments, signal, log));
 			continue;
 		}
-		if (block.type === "tool-result") parts.push(...await contentParts(block.content, attachments, signal));
+		if (block.type === "tool-result") parts.push(...await contentParts(block.content, attachments, signal, log));
 	}
 	return parts;
 }
 /** 一张图片 → 一个 OpenAI image_url part（或读不到附件时的占位文本）。 */
-async function imageParts(ref, attachments, signal) {
-	if (attachments === void 0) return [{
-		type: "text",
-		text: imagePlaceholder(ref.attachmentId)
-	}];
+async function imageParts(ref, attachments, signal, log) {
+	if (attachments === void 0) {
+		log?.("图片附件 store 不可用（ctx.attachments 未注入），该图降级为占位文本");
+		return [{
+			type: "text",
+			text: imagePlaceholder(ref.attachmentId)
+		}];
+	}
+	const ref0 = {
+		attachmentId: ref.attachmentId,
+		mediaType: ref.mediaType,
+		bytes: ref.bytes,
+		width: ref.width,
+		height: ref.height
+	};
+	const target = {
+		...projectImageDimensions(ref.width, ref.height, MAX_REQUEST_PIXELS),
+		maxBytes: MAX_REQUEST_BYTES
+	};
 	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);
+		const img = await attachments.readImageRequest(ref0, target, signal);
 		return [{
 			type: "image_url",
 			image_url: { url: `data:${img.mediaType};base64,${bytesToBase64(img.data)}` }
 		}];
-	} catch {
+	} catch (err) {
+		log?.(`读取图片 ${ref.attachmentId} 失败，已降级为占位文本：${err.message}`);
 		return [{
 			type: "text",
 			text: imagePlaceholder(ref.attachmentId)
@@ -2562,8 +2881,8 @@ 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);
+async function wireRequest(options, attachments, log) {
+	const messages = await wireMessages(options, options.system, attachments, log);
 	const body = {
 		model: options.model,
 		messages,
@@ -2846,16 +3165,21 @@ var RouterAdapter = class RouterAdapter extends LlmAdapter {
 	resolveAttachments;
 	/** 流空闲超时（ms）：上游这么久不吐字节就判 TIMEOUT。 */
 	idleTimeoutMs;
+	/** 降级/失败诊断的出口（宿主接 ctx.logger.warn）。缺省丢弃 —— 仅为测试可注入。 */
+	log;
 	/**
 	* @param idleTimeoutMs 流空闲超时；缺省用生产值（300s，对齐 pi-ai）。
 	*   可注入只为测试能压到几百毫秒，生产不传。
+	* @param log 降级诊断出口。图片读不到时会降级成占位文本，原因走这里 ——
+	*   曾经那条路径是个空 `catch`，出问题跨版本都没人发现（issue #8）。
 	*/
-	constructor(baseURL, source, resolveAttachments, idleTimeoutMs = STREAM_IDLE_TIMEOUT_MS) {
+	constructor(baseURL, source, resolveAttachments, idleTimeoutMs = STREAM_IDLE_TIMEOUT_MS, log) {
 		super();
 		this.baseURL = baseURL;
 		this.source = source;
 		this.resolveAttachments = resolveAttachments ?? (() => void 0);
 		this.idleTimeoutMs = idleTimeoutMs;
+		this.log = log;
 	}
 	providerInfo(provider) {
 		return {
@@ -2902,7 +3226,7 @@ var RouterAdapter = class RouterAdapter extends LlmAdapter {
 		};
 	}
 	async *stream(options) {
-		const body = await wireRequest(options, this.resolveAttachments());
+		const body = await wireRequest(options, this.resolveAttachments(), this.log);
 		const controller = new AbortController();
 		const onAbort = () => controller.abort();
 		options.signal?.addEventListener("abort", onAbort, { once: true });
@@ -2913,7 +3237,8 @@ var RouterAdapter = class RouterAdapter extends LlmAdapter {
 				headers: {
 					...attributionHeaders(),
 					"content-type": "application/json",
-					accept: "text/event-stream"
+					accept: "text/event-stream",
+					...options.sessionId === void 0 ? {} : { "x-dsh-router-session": String(options.sessionId) }
 				},
 				body: JSON.stringify(body),
 				signal: controller.signal
@@ -3141,12 +3466,18 @@ var KeysStore = class {
 //#endregion
 //#region src/suppliers/loader.ts
 /**
-* 供应商 loader —— 扫描 suppliers 目录下的 *.js，动态 import，按契约包装成
+* 供应商 loader —— 扫描 **用户目录**下的 *.js，动态 import，按契约包装成
 * 内部 Supplier，并暴露"能力检测"(capabilities)供通用路由/前端按能力渲染。
 *
-* 加载来源（两处，profile 优先）：
-*   1. 内置：<plugin>/lib/suppliers/*.js（随插件分发）
-*   2. 用户：~/.dsh/profiles/web/suppliers/*.js（用户自定义）
+* 加载来源（两处）：
+*   1. 用户：`~/.dsh/profiles/<profile>/suppliers/*.js`（自定义供应商）
+*   2. 内置：**插件页「包含的组件」里的行** —— core 自己的 cordis.patch.yml
+*      insert 了三个子路径模块，经 `router.suppliers` 表进来，与独立安装的
+*      供应商插件同一条通道，核心不区分内外，只看工厂上的 `source` 标签。
+*
+* 内置曾经也是「扫 `<plugin>/lib/suppliers/*.js`」（本文件早先的 builtinDir）。
+* 改成行之后那条路径已删：扫目录拿不到行的身份（插件页的开关/显示名/说明），
+* 而且关一个内置供应商要手改配置才生效 —— 行才有宿主管的开关。
 */
 function isFn(v) {
 	return typeof v === "function";
@@ -3282,7 +3613,27 @@ function scanDir(dir) {
 		return [];
 	}
 }
-/** 加载全部供应商（内置 + 用户，用户覆盖内置同 id）。 */
+/**
+* 同 id 冲突时的优先级：**用户目录 js > 内置行 > 外部插件供应商**。
+*
+* 为什么用户目录最高：用户放一个同 id 的 js 就是想替换它，这是「扫目录时代」
+* 就有的语义（见本文件早先的 `loadSuppliers`：内置被用户版覆盖），内置改成行
+* 之后不能悄悄反过来。
+*
+* 纯函数 + 有测试：这条规则错了不会抛异常，只会让用户的覆盖悄悄失效。
+*/
+const SUPPLIER_RANK = {
+	user: 2,
+	builtin: 1,
+	external: 0
+};
+function supplierWins(incoming, existing) {
+	return SUPPLIER_RANK[incoming] > SUPPLIER_RANK[existing];
+}
+/**
+* 加载用户目录下的供应商。同一个 id 出现多个文件时**后者覆盖前者**（按文件名序），
+* 与内置共存的裁决交给核心（`registerLoaded` 的优先级：用户目录 js > 行）。
+*/
 async function loadSuppliers(opts) {
 	const env = {
 		dataDir: opts.dataDir,
@@ -3292,18 +3643,10 @@ async function loadSuppliers(opts) {
 	};
 	const byId = /* @__PURE__ */ new Map();
 	const errors = [];
-	const files = [...scanDir(opts.builtinDir).map((f) => ({
-		f,
-		builtin: true
-	})), ...scanDir(opts.userDir).map((f) => ({
-		f,
-		builtin: false
-	}))];
-	for (const { f, builtin } of files) try {
-		const loaded = await loadOne(f, env, builtin ? "builtin" : "user");
-		if (byId.get(loaded.supplier.id) && builtin) continue;
+	for (const f of scanDir(opts.userDir).sort()) try {
+		const loaded = await loadOne(f, env, "user");
 		byId.set(loaded.supplier.id, loaded);
-		opts.log(`supplier ${loaded.supplier.id} loaded (${builtin ? "builtin" : "user"}) from ${basename(f)}`);
+		opts.log(`supplier ${loaded.supplier.id} loaded (user) from ${basename(f)}`);
 	} catch (err) {
 		errors.push({
 			id: basename(f, ".js"),
@@ -3318,6 +3661,355 @@ async function loadSuppliers(opts) {
 	};
 }
 //#endregion
+//#region src/suppliers/probe.ts
+/**
+* 契约成员清单（体检的唯一事实来源）。
+*
+* `required: false` = 差异化能力，按存在性暴露端点/UI；`probe: 'skip'` 的理由都写在这里，
+* 面板会把 `skipReason` 原样显示 —— 用户能知道「有这个能力，只是体检不替你调」。
+*/
+const SUPPLIER_CONTRACT_MEMBERS = [
+	{
+		key: "id",
+		label: "供应商 id",
+		required: true,
+		probe: "safe"
+	},
+	{
+		key: "name",
+		label: "显示名",
+		required: true,
+		probe: "safe"
+	},
+	{
+		key: "priority",
+		label: "优先级",
+		required: false,
+		probe: "safe"
+	},
+	{
+		key: "icon",
+		label: "图标",
+		required: false,
+		probe: "safe"
+	},
+	{
+		key: "apiKeyHint",
+		label: "API key 提示文案",
+		required: false,
+		probe: "safe"
+	},
+	{
+		key: "status",
+		label: "账号状态",
+		required: true,
+		probe: "safe"
+	},
+	{
+		key: "listModels",
+		label: "模型列表",
+		required: true,
+		probe: "safe"
+	},
+	{
+		key: "chatOnce",
+		label: "调用上游",
+		required: true,
+		probe: "skip",
+		skipReason: "会真的发一次请求（消耗额度）。用上面的「跑一次访问测试」单独测，或在供应商详情里测模型。"
+	},
+	{
+		key: "checkinNow",
+		label: "签到",
+		required: false,
+		probe: "skip",
+		skipReason: "会替这个连接真的去签到。"
+	}
+];
+/** 读原始模块实例（`wrapModule` 挂在 wrapper 上）。 */
+function rawModule(loaded) {
+	return loaded.supplier.__module ?? {};
+}
+/** 读出账号状态列表（只读，不改任何东西）。 */
+function accountStates(status) {
+	if (typeof status !== "object" || status === null) return [];
+	const accounts = status.accounts;
+	if (!Array.isArray(accounts)) return [];
+	return accounts.flatMap((a) => {
+		const uid = a?.uid;
+		if (typeof uid !== "string") return [];
+		return [{
+			uid,
+			state: typeof a.state === "string" ? a.state : "ok",
+			cooling: a.cooling === true
+		}];
+	});
+}
+/** 第一个连接 uid（`checkinNow` 之类要真实连接时用）。 */
+function firstAccountUid(m) {
+	return accountStates(m.status())[0]?.uid;
+}
+/** 账号状态分布：`正常 2、冷却 1`、`session_dead 1` 这样。 */
+function accountTally(accounts) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const a of accounts) {
+		const key = a.cooling ? "冷却" : a.state === "ok" ? "正常" : a.state;
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+	}
+	return [...counts].map(([k, n]) => `${k} ${n}`).join("、");
+}
+/**
+* 摘要：把返回值压成一行**对排查有用**的文本。
+*
+* 原先只说「返回 number」「返回 data:image/svg+xml,%3Csvg…」——等于没说话：
+* 体检的意义就是让人一眼看出「priority 是几」「图标给了没有」。
+*/
+function describe(value) {
+	if (value === void 0) return "未提供（可选）";
+	if (value === null) return "返回 null";
+	if (Array.isArray(value)) return `${value.length} 项`;
+	if (typeof value === "string") {
+		if (value.startsWith("data:")) return `已提供（内联 ${value.slice(5, value.indexOf("/") || 12)}）`;
+		if (value === "") return "返回空串";
+		return value.length > 48 ? `返回 ${value.slice(0, 48)}…` : `返回 ${value}`;
+	}
+	if (typeof value === "number" || typeof value === "boolean") return `返回 ${value}`;
+	if (typeof value === "object") {
+		const o = value;
+		if (typeof o.ok === "boolean") return o.ok === false ? `ok:false ${String(o.error ?? o.message ?? "")}`.trim() : "ok:true";
+		return Object.keys(o).slice(0, 4).join(", ") || "空对象";
+	}
+	return `返回 ${typeof value}`;
+}
+/** 异步取一个值并压成摘要（同步抛错也要接住）。 */
+async function probeValue(call) {
+	try {
+		return {
+			ok: true,
+			detail: describe(await call())
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			detail: err.message
+		};
+	}
+}
+/**
+*（这里原本有一份「永不实跑」名单：`dispose` / `addApiKey`。
+*   两者都已移出体检清单，名单随之作废 —— 留着空机制比删掉更糟：
+*   它看起来像个可配置的开关，其实没有任何成员会命中。
+*   「为什么要移」见 PROBE_EXCLUDED_MEMBERS。）
+*/
+/** 深度档用来「不碰真实状态就跑通代码路径」的探针输入。 */
+const PROBE_UID = "__probe_no_such_uid__";
+const PROBE_CALLBACK = "https://invalid.example/__probe__";
+/**
+* 体检一个已装载的供应商。
+*
+* 只跑 `probe: 'safe'` 的成员；`skip` 的只报存在性。绝不代替用户调有副作用的成员。
+*
+* @param models - 该供应商当前的模型启用状态（由调用方用 `router.modelsOf` 取，
+*   走核心缓存不额外打上游）。取不到就传 undefined —— 报告里会如实写「拿不到」，
+*   不能拿 0 冒充「一个模型都没有」。
+*/
+async function probeSupplier(loaded, input = {}) {
+	const m = rawModule(loaded);
+	const members = [];
+	for (const member of SUPPLIER_CONTRACT_MEMBERS) {
+		const present = member.key in m ? m[member.key] !== void 0 : false;
+		const base = {
+			key: member.key,
+			label: member.label,
+			required: member.required,
+			present,
+			executed: present ? "ran" : "no"
+		};
+		if (!present) {
+			members.push({
+				...base,
+				state: member.required ? "fail" : "absent",
+				...member.required ? { detail: "必填成员缺失，插件不完整" } : {}
+			});
+			continue;
+		}
+		const outcome = member.probe === "safe" ? await runSafeProbe(member.key, m, input) : await runProbedMember(member.key, m, input);
+		members.push({
+			...base,
+			state: outcome.ok ? "ok" : outcome.detail.startsWith("无法验证") ? "unverified" : "fail",
+			detail: outcome.detail
+		});
+	}
+	const bulkResult = await runBulkRoundTrip(input);
+	input.models;
+	const summary = {
+		total: members.length,
+		implemented: members.filter((x) => x.present).length,
+		ok: members.filter((x) => x.state === "ok").length,
+		fail: members.filter((x) => x.state === "fail").length,
+		absent: members.filter((x) => x.state === "absent").length,
+		unverified: members.filter((x) => x.state === "unverified").length
+	};
+	const listModels = members.find((x) => x.key === "listModels");
+	return {
+		supplier: loaded.supplier.id,
+		name: loaded.supplier.name,
+		members,
+		core: await coreReport(input, listModels?.state === "ok", bulkResult),
+		summary: {
+			...summary,
+			ran: members.filter((x) => x.executed === "ran" && x.present).length,
+			bulk: bulkResult.ran ? bulkResult.ok === true ? "ok" : "fail" : "unverified"
+		}
+	};
+}
+/**
+* 实跑「有副作用但可以安全试」的成员：要么用**无害探针输入**跑通代码路径，要么用
+* **连接池里的真实连接**真跑一次（前提由使用者保证：池里已放好可用 token）。
+*/
+async function runProbedMember(key, m, input) {
+	try {
+		switch (key) {
+			case "chatOnce": {
+				if (input.runChatOnce === void 0) return {
+					ok: false,
+					detail: "无法验证：没有发起真实调用的入口"
+				};
+				const model = input.models?.find((x) => x.enabled)?.id ?? input.models?.[0]?.id;
+				if (model === void 0) return {
+					ok: false,
+					detail: "无法验证：没有已启用的模型（先启用至少一个）"
+				};
+				const r = await input.runChatOnce(model);
+				return {
+					ok: r.ok,
+					detail: `真实调用 ${model}：${r.ok ? "通了" : `失败（${r.detail}）`}`
+				};
+			}
+			case "checkinNow": {
+				const uid = firstAccountUid(m);
+				if (uid === void 0) return {
+					ok: false,
+					detail: "无法验证：连接池里没有可用连接（先加一个 token）"
+				};
+				const v = await m.checkinNow?.(uid);
+				return {
+					ok: v?.ok !== false,
+					detail: `对连接 ${uid} 真实签到：${describe(v)}`
+				};
+			}
+			case "generateLoginUrl": return {
+				ok: true,
+				detail: describe(await m.generateLoginUrl?.())
+			};
+			case "completeLogin": return {
+				ok: true,
+				detail: `无效回调实跑：${describe(await m.completeLogin?.(PROBE_CALLBACK))}（没抛错即通过）`
+			};
+			case "removeLink": {
+				const v = await m.removeLink?.(PROBE_UID);
+				return {
+					ok: v !== false,
+					detail: `不存在的连接实跑：${describe(v)}`
+				};
+			}
+			default: return {
+				ok: true,
+				detail: "未纳入自动实跑"
+			};
+		}
+	} catch (err) {
+		return {
+			ok: false,
+			detail: `实跑抛错（这本身就是一条问题）：${err.message}`
+		};
+	}
+}
+/** 核心代劳的能力区：模型启用/禁用状态 + 那几个改配置的操作（只报可用性）。 */
+/** 核心区：模型启用状态 + 「全部启用/禁用」实跑结果。 */
+async function coreReport(input, modelsProbed, bulk) {
+	const models = input.models;
+	const enabled = models?.filter((m) => m.enabled).length;
+	const disabled = models === void 0 ? void 0 : models.length - (enabled ?? 0);
+	return {
+		models: {
+			total: models?.length ?? null,
+			enabled: enabled ?? 0,
+			disabled: disabled ?? 0,
+			...models === void 0 ? { note: modelsProbed ? "拿不到模型列表" : "listModels 不可用，无法读启用状态" } : {}
+		},
+		operations: [{
+			key: "models.bulk",
+			label: "模型全部启用 / 全部禁用",
+			ran: bulk.ran,
+			...bulk.ok === void 0 ? {} : { ok: bulk.ok },
+			detail: bulk.detail
+		}]
+	};
+}
+/**
+* 实跑「全部禁用 → 看列表 → 全部启用」。
+*
+* 违规的插件会在这里露馅：它把已禁用的模型从 `listModels` 里过滤掉了，于是全部禁用
+* 之后核心**看不到任何一个模型** —— 用户点「全部启用」也就再也点不回来了
+* （路由里没有可用的模型 id 可传）。
+*/
+async function runBulkRoundTrip(input) {
+	if (input.runBulkToggleRoundTrip === void 0) return {
+		ran: false,
+		detail: "没有模型可禁用"
+	};
+	try {
+		const r = await input.runBulkToggleRoundTrip();
+		return {
+			ran: true,
+			ok: r.ok,
+			detail: r.detail
+		};
+	} catch (err) {
+		return {
+			ran: true,
+			ok: false,
+			detail: `实跑抛错：${err.message}`
+		};
+	}
+}
+/** 无副作用成员的实跑。**每个 case 都必须没有副作用** —— 新增成员时照此办理。 */
+async function runSafeProbe(key, m, input) {
+	switch (key) {
+		case "id":
+		case "name":
+		case "priority":
+		case "icon":
+		case "apiKeyHint": {
+			const value = m[key];
+			if (value === void 0) return {
+				ok: true,
+				detail: "未提供（可选）"
+			};
+			return {
+				ok: true,
+				detail: describe(value)
+			};
+		}
+		case "status": {
+			const r = await probeValue(() => m.status());
+			if (!r.ok) return r;
+			const accounts = accountStates(m.status());
+			return {
+				ok: true,
+				detail: accounts.length === 0 ? "无账号（无账号直连型供应商）" : `${accounts.length} 个账号：${accountTally(accounts)}`
+			};
+		}
+		case "listModels": return await probeValue(() => m.listModels());
+		case "pollLogin": return await probeValue(() => m.pollLogin?.());
+		default: return {
+			ok: true,
+			detail: "未纳入自动探测"
+		};
+	}
+}
+//#endregion
 //#region src/suppliers/registry.ts
 function writeJson$1(res, status, body) {
 	const payload = JSON.stringify(body);
@@ -3394,6 +4086,106 @@ function supplierRoutes(base, loaded, store, router) {
 			});
 		}
 	});
+	routes.push({
+		kind: "exact",
+		path: `${p}/enabled`,
+		handler: async (req, res) => {
+			let body;
+			try {
+				body = JSON.parse(await readBody$1(req));
+			} catch {
+				writeJson$1(res, 400, {
+					ok: false,
+					error: "invalid JSON body"
+				});
+				return;
+			}
+			if (typeof body.enabled !== "boolean") {
+				writeJson$1(res, 400, {
+					ok: false,
+					error: "enabled must be a boolean"
+				});
+				return;
+			}
+			store.setEnabled(s.id, body.enabled);
+			router.invalidateModels(s.id);
+			writeJson$1(res, 200, {
+				ok: true,
+				id: s.id,
+				enabled: router.isEnabled(s.id)
+			});
+		}
+	});
+	routes.push({
+		kind: "exact",
+		path: `${p}/probe`,
+		handler: async (req, res) => {
+			if (req.method !== "POST") {
+				writeJson$1(res, 405, {
+					ok: false,
+					error: "probe requires POST"
+				});
+				return;
+			}
+			try {
+				let pick = {};
+				const raw = (await readBody$1(req)).trim();
+				if (raw !== "") {
+					const body = JSON.parse(raw);
+					pick = {
+						...typeof body.model === "string" ? { model: body.model } : {},
+						...typeof body.uid === "string" ? { uid: body.uid } : {}
+					};
+				}
+				writeJson$1(res, 200, {
+					ok: true,
+					report: await probeSupplier(loaded, {
+						models: await router.modelsOf(s.id).catch(() => void 0),
+						runBulkToggleRoundTrip: async () => {
+							const original = [...store.get(s.id).disabled];
+							const ids = (await router.modelsOf(s.id)).map((mm) => mm.id);
+							if (ids.length === 0) return {
+								ok: true,
+								detail: "该供应商没有模型，跳过"
+							};
+							try {
+								store.setAllModelsEnabled(s.id, false, ids);
+								router.invalidateModels(s.id);
+								const after = await router.modelsOf(s.id, true);
+								const hidden = after.filter((mm) => !mm.enabled).length;
+								const missing = ids.length - after.length;
+								if (hidden !== ids.length || missing !== 0) return {
+									ok: false,
+									detail: `全部禁用后只剩 ${after.length}/${ids.length} 个 —— 插件在 listModels 里藏了已禁用的模型（启用状态由核心合并）`
+								};
+								return {
+									ok: true,
+									detail: `全部禁用后 ${after.length} 个都在，再启用可恢复`
+								};
+							} finally {
+								store.setAllModelsEnabled(s.id, true, ids);
+								for (const id of original) store.setAllModelsEnabled(s.id, false, [id]);
+								router.invalidateModels(s.id);
+								await router.modelsOf(s.id, true);
+							}
+						},
+						runChatOnce: async (model) => {
+							const r = await router.testModel(s.id, model, pick.uid);
+							return {
+								ok: r.ok,
+								detail: r.ok ? "通了" : r.error ?? "上游没给原因"
+							};
+						}
+					})
+				});
+			} catch (err) {
+				writeJson$1(res, 500, {
+					ok: false,
+					error: err.message
+				});
+			}
+		}
+	});
 	routes.push({
 		kind: "exact",
 		path: `${p}/alias`,
@@ -3512,29 +4304,6 @@ function supplierRoutes(base, loaded, store, router) {
 			writeJson$1(res, 200, { ok: true });
 		}
 	});
-	routes.push({
-		kind: "exact",
-		path: `${p}/pool/strategy`,
-		handler: async (req, res) => {
-			if (req.method === "GET") {
-				writeJson$1(res, 200, {
-					ok: true,
-					strategy: store.get(s.id).poolStrategy
-				});
-				return;
-			}
-			const body = JSON.parse(await readBody$1(req));
-			if (body.strategy !== "fallback" && body.strategy !== "round-robin") {
-				writeJson$1(res, 400, {
-					ok: false,
-					error: "策略无效"
-				});
-				return;
-			}
-			store.setPoolStrategy(s.id, body.strategy);
-			writeJson$1(res, 200, { ok: true });
-		}
-	});
 	routes.push({
 		kind: "exact",
 		path: `${p}/models/fetch`,
@@ -3550,7 +4319,8 @@ function supplierRoutes(base, loaded, store, router) {
 		path: `${p}/models/test`,
 		handler: async (req, res) => {
 			const body = JSON.parse(await readBody$1(req));
-			const result = await router.testModel(s.id, body.id ?? "");
+			const onlyUid = typeof body.uid === "string" && body.uid !== "" ? body.uid : void 0;
+			const result = await router.testModel(s.id, body.id ?? "", onlyUid);
 			writeJson$1(res, result.ok ? 200 : 400, result);
 		}
 	});
@@ -3795,6 +4565,98 @@ function dshHome() {
 	return resolve(value);
 }
 //#endregion
+//#region src/host-version.ts
+/**
+* 宿主 DSH 版本探测 —— **0.1.5 / 0.1.7 兼容分叉的唯一判据来源**。
+*
+* 原先三处兼容都靠「能力检测」（看方法/属性在不在），语义上是同一个问题
+* ——「这是 0.1.7 还是更老」——却各检各的、还容易误判（插件自己 node_modules
+* 里的依赖版本与宿主实际加载的版本并不一致：实测插件解析到 schemastery 3.18.4，
+* profile 里却是 3.18.3、全局是 3.18.2）。所以统一改成**读宿主版本号**判定：
+*
+*   1. 「最近命中」徽章：composer.dock 在 0.1.5 渲染位置不对 → >= 0.1.7 才挂。
+*   2. 设置命名空间：0.1.5 用 `settings.installSection` 注册；0.1.7 改由导出的
+*      Config 驱动（无此方法）→ 按版本走对应注册路径。
+*   3. adapter 的 tool-result 消息形态：0.1.5/0.1.6 = user 里的 'tool-result'
+*      块；0.1.7+ = 独立 role:'tool' 消息。
+*
+* 读法：宿主把 profile 目录挂在 `ctx.baseUrl`（见 data-dir.ts）。本插件跑在宿主
+* 进程内，`require.resolve('@deepseek-ai/dsh/package.json', { paths: [profile] })`
+* 会沿 profile 的 node_modules 向上解析到全局安装根（实测命中 bun 全局目录）。
+* 拿不到就回落直接拼路径，再不行就返回 undefined（按「不支持/老版本」处理，不抛）。
+*
+* 注意：**只能在 `apply(ctx)` 里用**（那时才有 baseUrl）。模块顶层（如 Config 导出）
+* 解析到的是插件自己的依赖，不能代表宿主——那处保留能力检测，见 index.ts 注释。
+*/
+/** 各兼容分叉的版本门槛。 */
+/** composer.dock 徽章 / 独立 role:'tool' 消息形态：0.1.7 起。 */
+const V0_1_7 = [
+	0,
+	1,
+	7
+];
+/**
+* 解析并比较 semver（只取前导数字段，预发布标识忽略）。
+* `0.1.7-alpha.2` → [0,1,7]，`0.1.5-rc.3` → [0,1,5]。
+* 返回负数/0/正数，语义同 `<`/`==`/`>`。
+*/
+function compareVersion(a, b) {
+	for (let i = 0; i < Math.max(a.length, b.length); i++) {
+		const x = a[i] ?? 0;
+		const y = b[i] ?? 0;
+		if (x !== y) return x - y;
+	}
+	return 0;
+}
+/** `0.1.7-alpha.2` → [0,1,7]；解析失败返回 null。 */
+function parseVersion(raw) {
+	const m = /^(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(raw.trim());
+	if (m === null) return null;
+	return [
+		Number(m[1]),
+		Number(m[2] ?? 0),
+		Number(m[3] ?? 0)
+	];
+}
+/**
+* 探测 profile 里安装的 DSH 宿主版本。
+* @param baseUrl 宿主注入的 profile 锚点（`ctx.baseUrl`）
+* @returns 形如 `0.1.7-alpha.2`；读不到返回 undefined（调用方按「不支持」处理）
+*/
+function detectHostVersion(baseUrl) {
+	const profile = profileDirOf(baseUrl);
+	const candidates = [];
+	try {
+		candidates.push(createRequire(join(profile, "noop.js")).resolve("@deepseek-ai/dsh/package.json"));
+	} catch {}
+	candidates.push(join(profile, "node_modules", "@deepseek-ai", "dsh", "package.json"));
+	for (const file of candidates) try {
+		const parsed = JSON.parse(readFileSync(file, "utf8"));
+		if (typeof parsed.version === "string" && parsed.version !== "") return parsed.version;
+	} catch {}
+}
+/** 宿主版本是否 >= 门槛。读不到版本 → false（按老版本处理）。 */
+function atLeast(baseUrl, min) {
+	const v = detectHostVersion(baseUrl);
+	if (v === void 0) return false;
+	const parsed = parseVersion(v);
+	if (parsed === null) return false;
+	return compareVersion(parsed, min) >= 0;
+}
+/**
+* 宿主是否 >= 0.1.7。三处兼容分叉共用这一个判据：
+*   - 「最近命中」徽章（composer.dock 位置正确）
+*   - 设置命名空间（Config 驱动而非 installSection）
+*   - adapter 的独立 role:'tool' 消息形态
+*/
+function isHost017Plus(baseUrl) {
+	return atLeast(baseUrl, V0_1_7);
+}
+/** 「最近命中」徽章是否可用（= 宿主 >= 0.1.7）。 */
+function supportsLastHitDock(baseUrl) {
+	return isHost017Plus(baseUrl);
+}
+//#endregion
 //#region src/ext/store.ts
 /**
 * 扩展存储 —— **开关状态与插件数据都归核心持久化**,插件不自己 file IO。
@@ -3913,6 +4775,31 @@ var ExtStore = class {
 const name = "dsh-router-core";
 /** Services required before mounting: the webserver (routes) + llm (设置-模型). */
 const inject = ["webServer", "llm"];
+/**
+* `Config` 导出：让 Router 卡片进 0.1.7 的设置镜像。
+*
+* **这处刻意保留能力检测，不用宿主版本号** —— 与另两处兼容点（installSection /
+* adapter 消息形态）不同。原因（已实测）：这是**模块顶层导出**，loader 一 import
+* 就求值；而 schemastery 是本插件的**普通依赖**（`^3.18.4`，见 package.json），
+* 解析到的是**插件自己 node_modules 里那一份**，跟宿主实际加载的版本无关
+* （实测：插件解析到 3.18.4，而 profile 里是 3.18.3、全局是 3.18.2）。既然这里
+* 拿不到宿主版本，就只剩「这份 Schema 实例到底有没有 `.volatile`」这个真问题 ——
+* 能力检测恰好就是**对**的判据。
+*
+* 定位说明（非兼容分叉）：`.volatile()` 是 schemastery 3.18.4 才有的原型方法；
+* 老版本上直写 `Schema.object({}).volatile()` 会 `.volatile` 为 undefined →
+* 抛 TypeError → **整个插件加载失败**（不只是卡片，是 dsh-router 完全挂掉）。
+*   - 有 volatile：走 volatile，空 object 不被 volatileForm 过滤 → 卡片进镜像；
+*   - 无 volatile：回落普通空 schema，不抛；此时宿主必是 0.1.5，本就靠
+*     installSection 出卡片（见下方按版本分流的注册），这个 Config 无副作用。
+*/
+const emptySchema = Schema.object({});
+/**
+* 0.1.7 的设置镜像只认「插件导出的 Config + 配置树行 id」这条收录链，且空 object
+* 会被 volatileForm 过滤掉 —— 顶层 `.volatile()` 才能让 Router 卡片出现在设置-模型。
+* Router 的真配置在自己的 state.json（路由系统面板），这里故意不暴露任何字段。
+*/
+const Config = typeof emptySchema.volatile === "function" ? emptySchema.volatile() : emptySchema;
 function writeJson(res, status, body) {
 	const payload = JSON.stringify(body);
 	res.writeHead(status, {
@@ -3945,6 +4832,10 @@ function apply(rawContext) {
 	const dataDir = dataDirOf(ctx.baseUrl);
 	const stateFile = join(dataDir, "state.json");
 	log(`data dir: ${dataDir}`);
+	const hostVersion = detectHostVersion(ctx.baseUrl);
+	const host017Plus = isHost017Plus(ctx.baseUrl);
+	const lastHitDock = supportsLastHitDock(ctx.baseUrl);
+	log(`host version: ${hostVersion ?? "未知"} (>=0.1.7: ${host017Plus ? "yes" : "no"}, last-hit dock: ${lastHitDock ? "on" : "off"})`);
 	const store = new SupplierConfigStore(stateFile);
 	const credentials = new CredentialStore(join(dataDir, "auths"));
 	const router = new Router(stateFile, store, log);
@@ -3983,6 +4874,15 @@ function apply(rawContext) {
 	const extStore = new ExtStore(stateFile);
 	ctx.provide("router.extStore", extStore);
 	const registerLoaded = (loaded) => {
+		const existing = loadedSuppliers.find((l) => l.supplier.id === loaded.supplier.id);
+		if (existing !== void 0) {
+			if (!supplierWins(loaded.source, existing.source)) {
+				log(`supplier ${loaded.supplier.id} (${loaded.source}) skipped: ${existing.source} already registered`);
+				return;
+			}
+			log(`supplier ${loaded.supplier.id}: ${existing.source} replaced by ${loaded.source}`);
+			unregisterSupplier(loaded.supplier.id);
+		}
 		loadedSuppliers.push(loaded);
 		router.add(loaded.supplier);
 		registerSupplierRoutes(loaded);
@@ -3993,22 +4893,24 @@ function apply(rawContext) {
 		for (const [sid, factory] of Object.entries(suppliers)) {
 			if (externalSupplierIds.includes(sid)) continue;
 			try {
-				const loaded = wrapModule(factory({
+				const module = factory({
 					dataDir,
 					log,
 					store,
 					credentials
-				}), {
+				});
+				const kind = factory.source === "builtin" ? "builtin" : "external";
+				const loaded = wrapModule(module, {
 					dataDir,
 					log,
 					store,
 					credentials
-				}, `service router.suppliers.${sid}`);
+				}, `service router.suppliers.${sid}`, kind);
 				registerLoaded(loaded);
 				externalSupplierIds.push(loaded.supplier.id);
-				log(`external supplier loaded: ${sid}`);
+				log(`${kind} supplier loaded: ${sid}`);
 			} catch (err) {
-				ctx.logger.warn(`[dsh-router] external supplier ${sid} load failed: ${err.message}`);
+				ctx.logger.warn(`[dsh-router] supplier ${sid} load failed: ${err.message}`);
 			}
 		}
 	};
@@ -4027,10 +4929,8 @@ function apply(rawContext) {
 	});
 	(async () => {
 		try {
-			const userDir = join(profileDirOf(ctx.baseUrl), "suppliers");
 			const { suppliers, errors } = await loadSuppliers({
-				builtinDir: join(import.meta.dirname, "suppliers"),
-				userDir,
+				userDir: join(profileDirOf(ctx.baseUrl), "suppliers"),
 				dataDir,
 				store,
 				credentials,
@@ -4088,17 +4988,22 @@ function apply(rawContext) {
 			return;
 		}
 		const lv = typeof peek.reasoning_effort === "string" && peek.reasoning_effort !== "" ? peek.reasoning_effort : "auto";
+		const sessionRaw = req.headers["x-dsh-router-session"];
+		const session = typeof sessionRaw === "string" && sessionRaw !== "" ? sessionRaw : void 0;
 		await router.chatCompletions({
 			rawBody: body,
 			stream: !!peek.stream,
 			model: typeof peek.model === "string" ? peek.model : "",
-			lv
+			lv,
+			...session === void 0 ? {} : { session }
 		}, res);
 	}));
 	route(`${ROUTER_API_BASE}/health`, (_req, res) => {
 		const { suppliers } = router.status();
 		writeJson(res, 200, {
 			ok: true,
+			hostVersion: hostVersion ?? "",
+			lastHitDock,
 			suppliers: suppliers.map((s) => {
 				const loaded = loadedSuppliers.find((l) => l.supplier.id === s.id);
 				return {
@@ -4107,7 +5012,8 @@ function apply(rawContext) {
 					icon: loaded?.supplier.icon,
 					apiKeyHint: loaded?.supplier.apiKeyHint,
 					capabilities: loaded ? [...loaded.capabilities] : [],
-					source: loaded?.source ?? "external"
+					source: loaded?.source ?? "external",
+					enabled: s.enabled
 				};
 			})
 		});
@@ -4143,6 +5049,33 @@ function apply(rawContext) {
 		store.setAccountName(body.supplier, body.uid, typeof body.name === "string" ? body.name : "");
 		writeJson(res, 200, { ok: true });
 	});
+	route(`${ROUTER_API_BASE}/last-hit`, (req, res) => {
+		const session = new URL(req.url ?? "/", "http://localhost").searchParams.get("session") ?? void 0;
+		const last = router.usage.lastHit(session);
+		if (last === void 0) {
+			writeJson(res, 200, {
+				ok: true,
+				hit: null
+			});
+			return;
+		}
+		const { suppliers } = router.status();
+		const acct = suppliers.find((s) => s.id === last.supplier)?.accounts.find((a) => a.uid === last.uid);
+		const named = last.uid === void 0 || last.uid === "" ? void 0 : store.getAccountName(last.supplier, last.uid);
+		writeJson(res, 200, {
+			ok: true,
+			hit: {
+				supplier: last.supplier,
+				model: last.model,
+				requested: last.requested,
+				uid: last.uid,
+				account: named ?? acct?.nickname ?? (last.uid === void 0 || last.uid === "" ? void 0 : last.uid),
+				credits: acct?.credits,
+				ok: last.ok,
+				ts: last.ts
+			}
+		});
+	});
 	route(`${ROUTER_API_BASE}/models`, async (_req, res) => {
 		try {
 			writeJson(res, 200, {
@@ -4176,7 +5109,7 @@ function apply(rawContext) {
 			});
 			return;
 		}
-		const result = router.createCombo(body.name ?? "", body.strategy ?? "fallback", body.models ?? []);
+		const result = router.createCombo(body.name ?? "", body.models ?? []);
 		writeJson(res, result.ok ? 200 : 400, result);
 	});
 	route(`${ROUTER_API_BASE}/combos/update`, async (req, res) => {
@@ -4190,7 +5123,7 @@ function apply(rawContext) {
 			});
 			return;
 		}
-		const result = router.updateCombo(body.id ?? "", body.name ?? "", body.strategy ?? "fallback", body.models ?? []);
+		const result = router.updateCombo(body.id ?? "", body.name ?? "", body.models ?? []);
 		writeJson(res, result.ok ? 200 : 400, result);
 	});
 	route(`${ROUTER_API_BASE}/combos/remove`, async (req, res) => {
@@ -4336,37 +5269,12 @@ function apply(rawContext) {
 					...e.icon !== void 0 ? { icon: e.icon } : {},
 					enabled: extStore.isEnabled(e.id),
 					ready: st?.ready === true,
+					...raw.source === "builtin" ? { source: "builtin" } : {},
 					...st?.detail !== void 0 ? { detail: st.detail } : {}
 				};
 			}).filter((e) => e !== void 0)
 		});
 	});
-	const extDispatch = ctx.webServer.register({
-		kind: "prefix",
-		path: `${ROUTER_API_BASE}/ext/`,
-		handler: async (req, res) => {
-			const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
-			const mount = `${ROUTER_API_BASE}/ext/`;
-			const rest = pathname.startsWith(mount) ? pathname.slice(mount.length) : "";
-			const slash = rest.indexOf("/");
-			const extId = slash < 0 ? rest : rest.slice(0, slash);
-			const subpath = slash < 0 ? "" : rest.slice(slash + 1);
-			if (extId === "") {
-				writeJson(res, 404, {
-					ok: false,
-					error: "extension not found"
-				});
-				return;
-			}
-			const ext = exts[extId];
-			if (ext !== void 0 && typeof ext.api === "function" && await ext.api(subpath, req, res)) return;
-			writeJson(res, 404, {
-				ok: false,
-				error: "extension api not found"
-			});
-		}
-	});
-	disposers.push(extDispatch);
 	/** 解析并校验周期参数（不接受任意字符串）。 */
 	const periodOf = (raw) => {
 		return raw === "24h" || raw === "7d" || raw === "30d" ? raw : "today";
@@ -4391,7 +5299,10 @@ function apply(rawContext) {
 			bySupplier: s.bySupplier,
 			byModel: s.byModel,
 			byRequested: s.byRequested,
-			recent: router.usage.recentList(20)
+			recent: router.usage.recentList(20).map((r) => ({
+				...r,
+				connection: r.uid === void 0 || r.uid === "" ? "" : store.getAccountName(r.supplier, r.uid) ?? r.uid
+			}))
 		});
 	});
 	route(`${ROUTER_API_BASE}/stats/chart`, (req, res) => {
@@ -4412,53 +5323,57 @@ function apply(rawContext) {
 		router.usage.clear();
 		writeJson(res, 200, { ok: true });
 	});
-	if (ctx.llm !== void 0) {
-		const LLM_NS = "llm-dsh-router";
-		try {
-			const providerReg = ctx.llm.registerConfigurableProviders([{
-				provider: "router",
-				displayName: "Router",
-				settingsNs: LLM_NS,
-				settingsPath: []
-			}]);
-			disposers.push(providerReg);
-			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})`);
+	const settingsNs = ctx.fiber?.entry?.options?.id ?? "dsh-router";
+	if (ctx.llm !== void 0) try {
+		const providerReg = ctx.llm.registerConfigurableProviders([{
+			provider: "router",
+			displayName: "Router",
+			settingsNs,
+			settingsPath: []
+		}]);
+		disposers.push(providerReg);
+		disposers.push(ctx.llm.registerModelDiscovery(settingsNs, async () => {
+			return (await router.combos()).map((c) => ({ id: c.name }));
+		}));
+		const routerSettingsSchema = Schema.object({});
+		if (isHost017Plus(ctx.baseUrl)) log(`settings section driven by exported Config (${settingsNs})`);
+		else ctx.inject(["settings"], (sctx) => {
+			const settings = sctx.settings;
+			if (settings === void 0) {
+				log("settings service absent — skip Router settings-section registration");
+				return;
+			}
+			if (settings.installSection === void 0) {
+				log(`settings.installSection absent despite 0.1.5 host (${settingsNs})`);
+				return;
+			}
+			settings.installSection(rawContext, settingsNs, routerSettingsSchema, {}, {
+				setSource: () => {},
+				onChange: () => {}
 			});
-			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) {
-					const at = ref.indexOf(",");
-					if (at < 0) continue;
-					try {
-						await router.modelsOf(ref.slice(0, at));
-					} catch {}
-				}
-			})().catch(() => {});
-		} catch (err) {
-			ctx.logger.warn(`[dsh-router] llm registration failed: ${err.message}`);
-		}
-	} else log("llm service NOT available — skip 设置-模型 registration");
+			log(`Router settings section registered (${settingsNs})`);
+		});
+		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"), void 0, (msg) => ctx.logger.warn(`[dsh-router] ${msg}`))));
+		log("llm provider (Router) + discovery + adapter registered ok");
+		(async () => {
+			for (const c of await router.combos()) for (const ref of c.models) {
+				const at = ref.indexOf(",");
+				if (at < 0) continue;
+				try {
+					await router.modelsOf(ref.slice(0, at));
+				} catch {}
+			}
+		})().catch(() => {});
+	} catch (err) {
+		ctx.logger.warn(`[dsh-router] llm registration failed: ${err.message}`);
+	}
+	else log("llm service NOT available — skip 设置-模型 registration");
 	route(`${ROUTER_API_BASE}/debug/llm`, async (_req, res) => {
 		let directory = "n/a";
 		let registeredProviders = "n/a";
@@ -4485,7 +5400,7 @@ function apply(rawContext) {
 			directory,
 			registeredProviders,
 			settingsNamespaces,
-			routerNamespaceRegistered: Array.isArray(settingsNamespaces) && settingsNamespaces.includes("llm-dsh-router")
+			routerNamespaceRegistered: Array.isArray(settingsNamespaces) && settingsNamespaces.includes(settingsNs)
 		});
 	});
 	ctx.effect(() => () => {
@@ -4497,4 +5412,4 @@ function apply(rawContext) {
 	}, "dsh-router: teardown");
 }
 //#endregion
-export { apply, inject, name };
+export { Config, apply, inject, name };