dsh-router-core 0.3.21 → 0.4.0

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
@@ -471,7 +565,6 @@ var SupplierConfigStore = class {
 				disabled: [],
 				custom: [],
 				poolOrder: [],
-				poolStrategy: "fallback",
 				credits: {},
 				accountNames: {}
 			};
@@ -520,11 +613,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];
@@ -582,7 +670,6 @@ var SupplierConfigStore = class {
 			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)
 		});
@@ -595,7 +682,6 @@ var SupplierConfigStore = class {
 			disabled: [...cfg.disabled],
 			custom: [...cfg.custom],
 			poolOrder: [...cfg.poolOrder],
-			poolStrategy: cfg.poolStrategy,
 			credits: { ...cfg.credits },
 			accountNames: { ...cfg.accountNames }
 		};
@@ -889,6 +975,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 +1398,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）。
 */
 /**
 * 模型列表缓存有效期。
@@ -1753,9 +1849,7 @@ var Router = class {
 	suppliers = [];
 	combosFp = "";
 	customCombos = [];
-	/** round-robin 轮转游标（按组合 id 记忆）。 */
-	rrCursors = /* @__PURE__ */ new Map();
-	/** 通用供应商配置（连接池顺序/策略、模型启用、别名）。 */
+	/** 通用供应商配置（连接池顺序、模型启用、别名）。 */
 	store;
 	/** 模型列表缓存（supplierId → 模型 + 拉取时间）。插件只管拉，不缓存。 */
 	modelsCache = /* @__PURE__ */ new Map();
@@ -1801,7 +1895,6 @@ var Router = class {
 				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);
@@ -1998,9 +2091,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 会把
@@ -2021,8 +2111,8 @@ var Router = class {
 			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 +2130,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 +2143,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 +2166,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,15 +2223,14 @@ 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)) {
@@ -2234,7 +2313,7 @@ var Router = class {
 			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）。别名唯一，故最多命中一个。 */
@@ -2271,9 +2350,11 @@ var Router = class {
 		}
 		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);
+			const uid = pool.pick(s.accounts().filter((a) => !tried.has(a.uid)), cfg.poolOrder, req.model, messages, req.session);
 			if (uid === void 0) return false;
+			pickWhy = pool.lastWhy;
 			tried.add(uid);
 			const r = await s.chatOnce(uid, req.lv ?? "auto", req);
 			if (!r.ok) {
@@ -2294,14 +2375,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);
+				pool.noteCache(uid, req.model, probe?.tokens?.cachedTokens ?? 0, req.session);
 				return true;
 			}
 			pool.noteFailure(uid, req.model, "transport", "stream failed before first byte");
@@ -2390,6 +2474,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";
@@ -2461,6 +2549,19 @@ async function wireMessages(options, system, attachments) {
 			});
 			continue;
 		}
+		if (message.role === "tool") {
+			const toolCallId = message.toolCallId;
+			const parts = await contentParts(message.content, attachments, options.signal);
+			const imageParts = parts.filter((p) => p.type !== "text");
+			const text = parts.filter((p) => p.type === "text").map((p) => p.text ?? "").join("");
+			out.push({
+				role: "tool",
+				tool_call_id: 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);
 		if (ownParts.length > 0 || toolResults.length === 0) {
@@ -2913,7 +3014,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
@@ -3512,29 +3614,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`,
@@ -3795,6 +3874,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 +4084,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 +4141,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);
@@ -4088,17 +4288,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 {
@@ -4143,6 +4348,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 +4408,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 +4422,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) => {
@@ -4341,32 +4573,6 @@ function apply(rawContext) {
 			}).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 +4597,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 +4621,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"))));
+		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 +4698,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 +4710,4 @@ function apply(rawContext) {
 	}, "dsh-router: teardown");
 }
 //#endregion
-export { apply, inject, name };
+export { Config, apply, inject, name };