dsh-router-core 0.1.0 → 0.3.0

package/lib/index.js

@@ -10,12 +10,880 @@ const ROUTER_API_BASE = "/router/api";
 /** Bearer key env / credential reference protecting /v1/*. */
 const API_KEY_REF = "TW2A_API_KEY";
 //#endregion
+//#region src/router/account-pool.ts
+const MINUTE = 6e4;
+/**
+* 状态 → 处置表。**核心策略就在这一张表里**，插件只报状态不做决策。
+* 时长参考 9router 的 errorConfig（限流类短冷却、额度类长冷却），
+* 但 9router 按文本/状态匹配，这里按插件解读后的语义状态匹配，更准。
+*/
+const RULES = {
+	ok: {
+		cooldownMs: 0,
+		disable: false,
+		counts: false
+	},
+	rate_limit: {
+		cooldownMs: 1 * MINUTE,
+		disable: false,
+		counts: false
+	},
+	quota: {
+		cooldownMs: 10 * MINUTE,
+		disable: false,
+		counts: false
+	},
+	session_dead: {
+		cooldownMs: 0,
+		disable: true,
+		counts: false
+	},
+	unavailable: {
+		cooldownMs: 0,
+		disable: false,
+		counts: true
+	},
+	transport: {
+		cooldownMs: 0,
+		disable: false,
+		counts: true
+	},
+	unknown: {
+		cooldownMs: 0,
+		disable: false,
+		counts: true
+	},
+	no_such_model: {
+		cooldownMs: 0,
+		disable: false,
+		counts: false
+	}
+};
+/** 连续错误攒够这么多次就自动冷却（防止坏号被反复重试）。 */
+const ERR_THRESHOLD = 3;
+/** 攒够后的冷却时长。 */
+const ERR_COOLDOWN_MS = 10 * MINUTE;
+var AccountPool = class {
+	entries = /* @__PURE__ */ new Map();
+	rrCursor = 0;
+	entry(uid) {
+		let e = this.entries.get(uid);
+		if (!e) {
+			e = {
+				until: 0,
+				disabled: false,
+				errCount: 0,
+				reason: ""
+			};
+			this.entries.set(uid, e);
+		}
+		return e;
+	}
+	/** 是否可服务：未禁用且不在冷却中。 */
+	healthy(uid, now) {
+		const e = this.entries.get(uid);
+		if (!e) return true;
+		if (e.disabled) return false;
+		return e.until <= now;
+	}
+	/**
+	* 按策略选一个健康账号。
+	* @param accounts 插件报告的「现在状态」（顺序即插件的自然顺序）
+	* @param poolOrder 用户在面板拖出来的顺序（核心管）
+	* @returns 选中的 uid；无健康账号返回 undefined
+	*/
+	pick(accounts, poolOrder, strategy) {
+		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, now));
+		if (healthy.length === 0) return void 0;
+		if (strategy !== "round-robin") return healthy[0];
+		const uid = healthy[this.rrCursor % healthy.length];
+		this.rrCursor = (this.rrCursor + 1) % healthy.length;
+		return uid;
+	}
+	/** 记录一次失败：按状态处置（冷却/禁用/错误累计）。 */
+	noteFailure(uid, state, message) {
+		const rule = RULES[state];
+		const e = this.entry(uid);
+		if (rule.disable) {
+			e.disabled = true;
+			e.reason = message;
+			return;
+		}
+		if (rule.cooldownMs > 0) {
+			e.until = Math.max(e.until, Date.now() + rule.cooldownMs);
+			e.reason = message;
+			e.errCount = 0;
+			return;
+		}
+		if (rule.counts) {
+			e.errCount += 1;
+			e.reason = message;
+			if (e.errCount >= ERR_THRESHOLD) {
+				e.until = Date.now() + ERR_COOLDOWN_MS;
+				e.errCount = 0;
+			}
+		}
+	}
+	/** 记录一次成功：清零连续错误。 */
+	noteSuccess(uid) {
+		const e = this.entries.get(uid);
+		if (e) e.errCount = 0;
+	}
+	/** 手动冷却（面板/管理用途）。 */
+	cooldown(uid, ms, reason) {
+		const e = this.entry(uid);
+		e.until = Date.now() + ms;
+		e.reason = reason;
+		e.errCount = 0;
+	}
+	/** 把核心的冷却/禁用/错误累计叠加到插件报告的「现在状态」上，产出面板态。 */
+	decorate(accounts) {
+		const now = Date.now();
+		return accounts.map((a) => {
+			const e = this.entries.get(a.uid);
+			const cooling = e !== void 0 && !e.disabled && e.until > now;
+			return {
+				...a,
+				cooling,
+				disabled: e?.disabled ?? false,
+				err_count: e?.errCount ?? 0,
+				until: cooling && e ? new Date(e.until).toISOString() : void 0,
+				reason: e?.reason !== "" ? e?.reason : void 0
+			};
+		});
+	}
+};
+//#endregion
+//#region src/supplier-config.ts
+/**
+* 通用供应商配置 —— dsh-router 核心能力,按供应商 id 存储。
+*
+* 通用能力(所有供应商共享,供应商 js 不需要实现)：
+*   - 别名 alias(前缀,模型全名 = alias/id)
+*   - 模型管理:启用/禁用 disabled、自定义 custom
+*   - 连接池:poolOrder(拖动排序)、poolStrategy(回退/轮询)
+*
+* 持久化到 data/supplier-config.json。
+*/
+/** 通用供应商配置存储。 */
+var SupplierConfigStore = class {
+	fp = "";
+	bySupplier = /* @__PURE__ */ new Map();
+	/** 全部供应商 id（加载时同步），用于别名唯一性校验。 */
+	knownIds = /* @__PURE__ */ new Set();
+	constructor(stateFile) {
+		this.fp = stateFile ? join(dirname(stateFile), "supplier-config.json") : "";
+		this.load();
+	}
+	/** 同步已知供应商 id 集合（加载供应商后调用）。 */
+	sync(supplierIds) {
+		this.knownIds = new Set(supplierIds);
+	}
+	/** 各供应商当前生效的别名（未设置别名的用供应商 id）。 */
+	effectiveAliases() {
+		const out = /* @__PURE__ */ new Map();
+		for (const id of this.knownIds) out.set(id, this.bySupplier.get(id)?.alias || id);
+		return out;
+	}
+	/** 读取某供应商配置(不存在则返回默认并注册)。 */
+	get(supplierId) {
+		let cfg = this.bySupplier.get(supplierId);
+		if (!cfg) {
+			cfg = {
+				alias: "",
+				disabled: [],
+				custom: [],
+				poolOrder: [],
+				poolStrategy: "fallback"
+			};
+			this.bySupplier.set(supplierId, cfg);
+		}
+		return cfg;
+	}
+	/**
+	* 设置别名。别名必须唯一——它是对外模型全名的前缀（alias/model），
+	* 请求时用别名反查供应商，重复就会指错人。空别名表示用供应商 id（默认值）。
+	* @returns 冲突时返回占用的供应商 id
+	*/
+	setAlias(supplierId, alias) {
+		const clean = alias.trim();
+		const effective = clean === "" ? supplierId : clean;
+		for (const [id, cur] of this.effectiveAliases()) if (id !== supplierId && cur === effective) return {
+			ok: false,
+			conflictWith: id
+		};
+		this.get(supplierId).alias = clean;
+		this.saveLocked();
+		return { ok: 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])];
+		this.saveLocked();
+	}
+	setAllModelsEnabled(supplierId, enabled, allModelIds) {
+		const cfg = this.get(supplierId);
+		cfg.disabled = enabled ? [] : [...new Set(allModelIds)];
+		this.saveLocked();
+	}
+	addCustomModel(supplierId, modelId) {
+		const cfg = this.get(supplierId);
+		if (!cfg.custom.includes(modelId)) cfg.custom.push(modelId);
+		this.saveLocked();
+	}
+	removeCustomModel(supplierId, modelId) {
+		const cfg = this.get(supplierId);
+		cfg.custom = cfg.custom.filter((m) => m !== modelId);
+		cfg.disabled = cfg.disabled.filter((m) => m !== modelId);
+		this.saveLocked();
+	}
+	setPoolOrder(supplierId, uids) {
+		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();
+	}
+	load() {
+		if (this.fp === "") return;
+		let f;
+		try {
+			f = JSON.parse(readFileSync(this.fp, "utf8"));
+		} catch {
+			return;
+		}
+		for (const [id, c] of Object.entries(f.suppliers ?? {})) this.bySupplier.set(id, {
+			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"
+		});
+	}
+	saveLocked() {
+		if (this.fp === "") return;
+		const f = { suppliers: {} };
+		for (const [id, cfg] of this.bySupplier) f.suppliers[id] = {
+			alias: cfg.alias,
+			disabled: [...cfg.disabled],
+			custom: [...cfg.custom],
+			poolOrder: [...cfg.poolOrder],
+			poolStrategy: cfg.poolStrategy
+		};
+		try {
+			const dir = dirname(this.fp);
+			if (dir !== "" && dir !== ".") mkdirSync(dir, { recursive: true });
+			const raw = JSON.stringify(f, null, 2);
+			const tmp = this.fp + ".tmp";
+			writeFileSync(tmp, raw, { mode: 384 });
+			renameSync(tmp, this.fp);
+		} catch {}
+	}
+};
+//#endregion
+//#region src/router/usage-store.ts
+/**
+* 用量落盘与聚合 —— 概览看板的数据源。
+*
+* 结构照 9router `usageRepo` 的双表思路（按天聚合 + 最近明细），但用 **JSON
+* 落盘**而不是 SQLite：dsh-router 现有持久化全是 JSON（supplier-config.json /
+* keys.json），不为一个看板引入数据库依赖。
+*
+* 两条查询路径（照 9router `getUsageStats` 的 `useDailySummary` 分叉）：
+*   - `today` / `24h` → 走**明细环**（滚动窗口，天桶是自然日，对不上）
+*   - `7d` / `30d`   → 走**天桶**（长期精确，不受明细环容量限制）
+*
+* 天花板（JSON 的代价，刻意接受）：
+*   - 明细环只留最近 `RING_CAP` 条。超量时 today/24h 会**少算**（天桶不会，
+*     所以 7d/30d 永远准）。要彻底准就把明细也落盘成按小时的桶，届时
+*     `chart()` 的小时桶直接读它即可，接口不用变。
+*   - 天桶保留 30 天（9router 有 SQLite 不 prune，JSON 撑不住，得自己限）
+*   - 落盘防抖 2s：进程被 kill 最多丢 2s 的计数。看板不是账本，可接受；
+*     要严格就改成立即写，代价是每个请求一次磁盘写。
+*/
+/** 明细环容量：够 today/24h 看，又不至于让 JSON 无限长。 */
+const RING_CAP = 500;
+/** 天桶保留天数。 */
+const KEEP_DAYS = 30;
+/** 落盘防抖。 */
+const SAVE_DEBOUNCE_MS = 2e3;
+const emptyDay = () => ({
+	requests: 0,
+	ok: 0,
+	failed: 0,
+	promptTokens: 0,
+	completionTokens: 0,
+	cachedTokens: 0,
+	durationMs: 0,
+	ttfbMs: 0,
+	ttfbCount: 0,
+	estimatedInputs: 0,
+	estimatedOutputs: 0,
+	bySupplier: {},
+	byModel: {},
+	byRequested: {}
+});
+const emptyEntry = () => ({
+	requests: 0,
+	ok: 0,
+	failed: 0,
+	promptTokens: 0,
+	completionTokens: 0,
+	cachedTokens: 0,
+	lastTs: 0
+});
+/** 本地日期键 `YYYY-MM-DD`（照 9router getLocalDateKey，不按 UTC 切天）。 */
+function localDateKey(ts) {
+	const d = new Date(ts);
+	const p = (n) => String(n).padStart(2, "0");
+	return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+/** 用量存储。stateFile 为空时纯内存（测试用），不落盘。 */
+var UsageStore = class {
+	fp = "";
+	days = /* @__PURE__ */ new Map();
+	recent = [];
+	lifetime = 0;
+	timer = null;
+	constructor(stateFile) {
+		this.fp = stateFile ? join(dirname(stateFile), "usage.json") : "";
+		this.load();
+	}
+	/**
+	* 记一次请求。
+	*
+	* **成功的零 token 请求不记**（照 9router `saveUsageStats` 的闸门：
+	* `in === 0 && out === 0` 直接 return，空请求混进来只会稀释统计）。
+	* **失败请求一定记** —— 不管有没有 token。成功率全靠它，挡掉的话
+	* 失败永远是 0 条，面板会显示 100% 成功，这个数字是骗人的。
+	*/
+	record(r, usage) {
+		const promptTokens = usage.promptTokens;
+		const completionTokens = usage.completionTokens;
+		if (r.ok && promptTokens === 0 && completionTokens === 0) return;
+		const ts = r.ts ?? Date.now();
+		const rec = {
+			...r,
+			ts,
+			promptTokens,
+			completionTokens,
+			cachedTokens: usage.cachedTokens,
+			inputEstimated: usage.inputEstimated,
+			outputEstimated: usage.outputEstimated
+		};
+		const key = localDateKey(ts);
+		let day = this.days.get(key);
+		if (day === void 0) {
+			day = emptyDay();
+			this.days.set(key, day);
+		}
+		day.requests += 1;
+		if (rec.ok) day.ok += 1;
+		else day.failed += 1;
+		day.promptTokens += promptTokens;
+		day.completionTokens += completionTokens;
+		day.cachedTokens += rec.cachedTokens;
+		day.durationMs += rec.durationMs;
+		if (rec.ttfbMs > 0) {
+			day.ttfbMs += rec.ttfbMs;
+			day.ttfbCount += 1;
+		}
+		if (rec.inputEstimated) day.estimatedInputs += 1;
+		if (rec.outputEstimated) day.estimatedOutputs += 1;
+		this.bump(day.bySupplier, rec.supplier, rec);
+		this.bump(day.byModel, rec.model, rec);
+		this.bump(day.byRequested, rec.requested, rec);
+		this.recent.unshift(rec);
+		if (this.recent.length > RING_CAP) this.recent.length = RING_CAP;
+		this.lifetime += 1;
+		this.scheduleSave();
+	}
+	bump(map, key, rec) {
+		if (key === "") return;
+		const e = map[key] ?? emptyEntry();
+		e.requests += 1;
+		if (rec.ok) e.ok += 1;
+		else e.failed += 1;
+		e.promptTokens += rec.promptTokens;
+		e.completionTokens += rec.completionTokens;
+		e.cachedTokens += rec.cachedTokens;
+		e.lastTs = Math.max(e.lastTs, rec.ts);
+		map[key] = e;
+	}
+	/** 窗口内的明细（today/24h 路径）。 */
+	inWindow(period, now) {
+		const cutoff = period === "today" ? new Date(now).setHours(0, 0, 0, 0) : now - 864e5;
+		return this.recent.filter((r) => r.ts >= cutoff);
+	}
+	/** 汇总 + Top 榜。 */
+	stats(period, now = Date.now()) {
+		if (period === "today" || period === "24h") {
+			const rows = this.inWindow(period, now);
+			const acc = emptyAcc();
+			const bySupplier = {};
+			const byModel = {};
+			const byRequested = {};
+			for (const rec of rows) {
+				addRec(acc, rec);
+				bumpInto(bySupplier, rec.supplier, rec);
+				bumpInto(byModel, rec.model, rec);
+				bumpInto(byRequested, rec.requested, rec);
+			}
+			return finish(acc, bySupplier, byModel, byRequested, this.lifetime);
+		}
+		const days = period === "7d" ? 7 : 30;
+		const acc = emptyAcc();
+		const bySupplier = {};
+		const byModel = {};
+		const byRequested = {};
+		for (let i = days - 1; i >= 0; i -= 1) {
+			const d = this.days.get(localDateKey(now - i * 864e5));
+			if (d === void 0) continue;
+			acc.requests += d.requests;
+			acc.ok += d.ok;
+			acc.failed += d.failed;
+			acc.promptTokens += d.promptTokens;
+			acc.completionTokens += d.completionTokens;
+			acc.cachedTokens += d.cachedTokens;
+			acc.durationMs += d.durationMs;
+			acc.ttfbMs += d.ttfbMs;
+			acc.ttfbCount += d.ttfbCount;
+			acc.estimatedInputs += d.estimatedInputs;
+			acc.estimatedOutputs += d.estimatedOutputs;
+			mergeInto(bySupplier, d.bySupplier);
+			mergeInto(byModel, d.byModel);
+			mergeInto(byRequested, d.byRequested);
+		}
+		return finish(acc, bySupplier, byModel, byRequested, this.lifetime);
+	}
+	/** 柱状图数据：today/24h = 24 个小时桶（走明细环），7d/30d = 天桶。 */
+	chart(period, now = Date.now()) {
+		if (period === "today" || period === "24h") {
+			const rows = this.inWindow(period, now);
+			const start = period === "today" ? Math.floor(new Date(now).setHours(0, 0, 0, 0) / 36e5) * 36e5 : Math.floor((now - 828e5) / 36e5) * 36e5;
+			const buckets = Array.from({ length: 24 }, (_, i) => ({
+				label: `${String(new Date(start + i * 36e5).getHours()).padStart(2, "0")}:00`,
+				requests: 0,
+				tokens: 0
+			}));
+			for (const rec of rows) {
+				const b = buckets[Math.floor((rec.ts - start) / 36e5)];
+				if (b === void 0) continue;
+				b.requests += 1;
+				b.tokens += rec.promptTokens + rec.completionTokens;
+			}
+			return buckets;
+		}
+		const days = period === "7d" ? 7 : 30;
+		const out = [];
+		for (let i = days - 1; i >= 0; i -= 1) {
+			const ts = now - i * 864e5;
+			const d = this.days.get(localDateKey(ts));
+			out.push({
+				label: localDateKey(ts).slice(5),
+				requests: d?.requests ?? 0,
+				tokens: (d?.promptTokens ?? 0) + (d?.completionTokens ?? 0)
+			});
+		}
+		return out;
+	}
+	/** 最近请求明细。 */
+	recentList(limit = 20) {
+		return this.recent.slice(0, limit);
+	}
+	clear() {
+		this.days.clear();
+		this.recent = [];
+		this.lifetime = 0;
+		this.save();
+	}
+	/** 进程退出前把防抖中的写入落盘。 */
+	flush() {
+		if (this.timer !== null) {
+			clearTimeout(this.timer);
+			this.timer = null;
+		}
+		this.save();
+	}
+	scheduleSave() {
+		if (this.fp === "" || this.timer !== null) return;
+		this.timer = setTimeout(() => {
+			this.timer = null;
+			this.save();
+		}, SAVE_DEBOUNCE_MS);
+		this.timer.unref?.();
+	}
+	load() {
+		if (this.fp === "") return;
+		try {
+			const f = JSON.parse(readFileSync(this.fp, "utf8"));
+			this.days = new Map(Object.entries(f.days ?? {}));
+			this.recent = Array.isArray(f.recent) ? f.recent.slice(0, RING_CAP) : [];
+			this.lifetime = typeof f.lifetime === "number" ? f.lifetime : 0;
+			for (const [k, d] of this.days) this.days.set(k, {
+				...emptyDay(),
+				...d
+			});
+		} catch {}
+	}
+	save() {
+		if (this.fp === "") return;
+		const cutoff = localDateKey(Date.now() - KEEP_DAYS * 864e5);
+		for (const k of [...this.days.keys()]) if (k < cutoff) this.days.delete(k);
+		const f = {
+			days: Object.fromEntries(this.days),
+			recent: this.recent,
+			lifetime: this.lifetime
+		};
+		try {
+			const dir = dirname(this.fp);
+			if (dir !== "" && dir !== ".") mkdirSync(dir, { recursive: true });
+			const tmp = `${this.fp}.tmp`;
+			writeFileSync(tmp, JSON.stringify(f), { mode: 384 });
+			renameSync(tmp, this.fp);
+		} catch {}
+	}
+};
+const emptyAcc = () => ({
+	requests: 0,
+	ok: 0,
+	failed: 0,
+	promptTokens: 0,
+	completionTokens: 0,
+	cachedTokens: 0,
+	durationMs: 0,
+	ttfbMs: 0,
+	ttfbCount: 0,
+	estimatedInputs: 0,
+	estimatedOutputs: 0
+});
+function addRec(acc, rec) {
+	acc.requests += 1;
+	if (rec.ok) acc.ok += 1;
+	else acc.failed += 1;
+	acc.promptTokens += rec.promptTokens;
+	acc.completionTokens += rec.completionTokens;
+	acc.cachedTokens += rec.cachedTokens;
+	acc.durationMs += rec.durationMs;
+	if (rec.ttfbMs > 0) {
+		acc.ttfbMs += rec.ttfbMs;
+		acc.ttfbCount += 1;
+	}
+	if (rec.inputEstimated) acc.estimatedInputs += 1;
+	if (rec.outputEstimated) acc.estimatedOutputs += 1;
+}
+function bumpInto(map, key, rec) {
+	if (key === "") return;
+	const e = map[key] ?? emptyEntry();
+	e.requests += 1;
+	if (rec.ok) e.ok += 1;
+	else e.failed += 1;
+	e.promptTokens += rec.promptTokens;
+	e.completionTokens += rec.completionTokens;
+	e.cachedTokens += rec.cachedTokens;
+	e.lastTs = Math.max(e.lastTs, rec.ts);
+	map[key] = e;
+}
+function finish(acc, bySupplier, byModel, byRequested, lifetime) {
+	return {
+		requests: acc.requests,
+		ok: acc.ok,
+		failed: acc.failed,
+		promptTokens: acc.promptTokens,
+		completionTokens: acc.completionTokens,
+		cachedTokens: acc.cachedTokens,
+		avgDurationMs: acc.requests > 0 ? Math.round(acc.durationMs / acc.requests) : 0,
+		avgTtfbMs: acc.ttfbCount > 0 ? Math.round(acc.ttfbMs / acc.ttfbCount) : 0,
+		estimatedInputs: acc.estimatedInputs,
+		estimatedOutputs: acc.estimatedOutputs,
+		lifetime,
+		bySupplier: top(bySupplier),
+		byModel: top(byModel),
+		byRequested: top(byRequested)
+	};
+}
+function mergeInto(target, src) {
+	for (const [k, v] of Object.entries(src)) {
+		const t = target[k];
+		if (t === void 0) {
+			target[k] = {
+				...emptyEntry(),
+				...v
+			};
+			continue;
+		}
+		t.requests += v.requests;
+		t.ok += v.ok;
+		t.failed += v.failed;
+		t.promptTokens += v.promptTokens;
+		t.completionTokens += v.completionTokens;
+		t.cachedTokens += v.cachedTokens;
+		t.lastTs = Math.max(t.lastTs, v.lastTs);
+	}
+}
+/** Top 榜：按请求数降序，取前 10。 */
+function top(map) {
+	return Object.entries(map).map(([name, e]) => ({
+		name,
+		requests: e.requests,
+		ok: e.ok,
+		failed: e.failed,
+		promptTokens: e.promptTokens,
+		completionTokens: e.completionTokens,
+		lastTs: e.lastTs
+	})).sort((a, b) => b.requests - a.requests || b.lastTs - a.lastTs).slice(0, 10);
+}
+//#endregion
+//#region src/router/usage-tokens.ts
+/** 取有限数，其余当 0（NaN 会毒穿整个累加：`Math.max(x, NaN) === NaN`）。 */
+function num(v) {
+	const n = Number(v);
+	return Number.isFinite(n) ? n : 0;
+}
+/**
+* 从上游任意形态的 usage 对象提取归一用量。
+*
+* `cached_tokens` 口径照 9router 的 `canonicalizeUsage`：OpenAI 系报的
+* prompt_tokens **已含**缓存，直接透传；Claude 系报的是**不含**缓存的
+* prompt + 单独的 cache_read，要折进来，否则总输入偏小。
+* 判别式就是「有没有 cache_read_input_tokens」。
+*
+* @returns 归一用量；一个非零字段都没有时返回 null（= 没拿到 usage）
+*/
+function normalizeUsage(raw) {
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const u = raw;
+	const cached = num(u.cached_tokens) + num(u.cache_read_input_tokens) + num(u.cachedContentTokenCount) + num(u.prompt_tokens_details?.cached_tokens);
+	let prompt = num(u.prompt_tokens) + num(u.input_tokens) + num(u.promptTokenCount);
+	if (u.cache_read_input_tokens !== void 0) prompt += num(u.cache_read_input_tokens);
+	const completion = num(u.completion_tokens) + num(u.output_tokens) + num(u.candidatesTokenCount);
+	if (prompt === 0 && completion === 0 && cached === 0) return null;
+	return {
+		promptTokens: prompt,
+		completionTokens: completion,
+		cachedTokens: cached
+	};
+}
+/** 字段级 max 合并：后来的同名字段取大者（Claude 把 usage 拆在多个事件里）。 */
+function mergeUsage(prev, next) {
+	if (prev === null) return next;
+	if (next === null) return prev;
+	return {
+		promptTokens: Math.max(prev.promptTokens, next.promptTokens),
+		completionTokens: Math.max(prev.completionTokens, next.completionTokens),
+		cachedTokens: Math.max(prev.cachedTokens, next.cachedTokens)
+	};
+}
+/**
+* 从流式上游的一帧 JSON 里取 usage。
+* 覆盖 OpenAI(Chat/Responses)、Claude、Gemini 三种事件形状，照 9router
+* `extractUsage` 的形态判断（dsh-router 的上游多是 OpenAI SSE，但供应商
+* 插件可能有直通的原生流，多认几种不亏）。
+*/
+function extractFrameUsage(chunk) {
+	if (chunk === null || typeof chunk !== "object" || Array.isArray(chunk)) return null;
+	const c = chunk;
+	if (c.type === "response.completed" || c.type === "response.done") {
+		const r = c.response;
+		if (r !== void 0) return normalizeUsage(r.usage);
+	}
+	if (c.type === "message_start") {
+		const m = c.message;
+		if (m !== void 0) return normalizeUsage(m.usage);
+	}
+	if (c.type === "message_delta") return normalizeUsage(c.usage);
+	if (c.usage !== void 0) return normalizeUsage(c.usage);
+	if (c.usageMetadata !== void 0) return normalizeUsage(c.usageMetadata);
+	const wrapped = c.response;
+	if (wrapped?.usageMetadata !== void 0) return normalizeUsage(wrapped.usageMetadata);
+	return null;
+}
+/** 估算：~4 字符/token（照 9router 的 estimateInputTokens/estimateOutputTokens）。 */
+function estimateTokens(chars) {
+	if (!Number.isFinite(chars) || chars <= 0) return 0;
+	return Math.ceil(chars / 4);
+}
+/**
+* 非流式响应体取 usage。
+*
+* 正常是纯 JSON；但个别供应商客户端要 JSON 却回 SSE（核心会聚合成一次响应，
+* 见 `aggregateSSE`），所以顺手扫尾部几帧——只扫尾部，不多做。
+*/
+function usageFromJsonBody(body) {
+	try {
+		return normalizeUsage(JSON.parse(body).usage);
+	} catch {}
+	let merged = null;
+	for (const frame of body.split("\n\n").slice(-3)) for (const line of frame.split("\n")) {
+		if (!line.startsWith("data:")) continue;
+		const payload = line.slice(5).trim();
+		if (payload === "" || payload === "[DONE]") continue;
+		let obj;
+		try {
+			obj = JSON.parse(payload);
+		} catch {
+			continue;
+		}
+		merged = mergeUsage(merged, extractFrameUsage(obj));
+	}
+	return merged;
+}
+/**
+* 归一用量 → DSH 的 `TokenUsage`（**必须**走这一步再交给 dsh-llm）。
+*
+* 为什么不能把上游 usage 原样透传：dsh-llm 的 `TokenUsage` 有两条硬性约定，
+* 上游的 OpenAI 形态两条都踩：
+*   1. 字段名是 `inputTokens` / `outputTokens`，不是 `prompt_tokens`；
+*      名字对不上 → 下游读 `usage.inputTokens` 得 `undefined` → 累加出 `NaN`。
+*   2. **DISJOINT 口径**：`inputTokens` 只算**未缓存**输入，缓存单列
+*      `cacheReadTokens`/`cacheWriteTokens`（计费输入 = 三者之和）。
+*      OpenAI 的 `prompt_tokens` 是**含**缓存的总量，直接当 inputTokens
+*      就是重复计费。
+*
+* 后果不只是「数字不好看」：token-meter 的投影 schema 是
+* `z.number().int().nonnegative()`，`NaN` 一进去校验就抛，整条
+* `session.history` RPC 失败 —— 表现为「历史加载失败：history unavailable
+* for session ... expected number, received NaN」。所以这里是**写入侧**
+* 的防线：宁可丢掉这一帧 usage，也不能往会话日志里写 NaN。
+*
+* 天花板（刻意不做）：不区分 cacheRead/cacheWrite。上游多数只报读不报写，
+* 拆不开的字段硬拆只会更错；哪天上游稳定给 `cache_creation_input_tokens`
+* 再补 `cacheWriteTokens`（升级路径就在这）。
+*
+* @returns DSH 契约用量；三个数全为 0 时返回 null（= 这一帧没真数据）
+*/
+function toTokenUsage(tokens) {
+	if (tokens === null) return null;
+	const input = finiteInt(tokens.promptTokens - tokens.cachedTokens);
+	const output = finiteInt(tokens.completionTokens);
+	const cachedTokens = finiteInt(tokens.cachedTokens);
+	if (input === 0 && output === 0 && cachedTokens === 0) return null;
+	return {
+		inputTokens: input,
+		outputTokens: output,
+		...cachedTokens > 0 ? { cacheReadTokens: cachedTokens } : {}
+	};
+}
+/** 取非负有限整数：NaN / Infinity / 负数一律归 0，小数取整。 */
+function finiteInt(v) {
+	if (!Number.isFinite(v)) return 0;
+	return Math.max(0, Math.round(v));
+}
+/** 一帧 SSE 里的可见文本内容（用于输出字符数估算）。 */
+function frameText(chunk) {
+	const choices = chunk.choices;
+	if (choices === void 0) return "";
+	let out = "";
+	for (const ch of choices) {
+		const delta = ch.delta;
+		if (delta !== void 0) {
+			if (typeof delta.content === "string") out += delta.content;
+			if (typeof delta.reasoning_content === "string") out += delta.reasoning_content;
+			continue;
+		}
+		const msg = ch.message;
+		if (msg !== void 0) {
+			if (typeof msg.content === "string") out += msg.content;
+			if (typeof msg.reasoning_content === "string") out += msg.reasoning_content;
+		}
+	}
+	return out;
+}
+/**
+* 边透传边统计：原流**原样**出去，统计在旁边做。
+*
+* 为什么不用 `source.tee()`：tee 的两条分支互相牵制，慢的一边会把 buffer 憋住；
+* 而统计这条分支得读完整个流才出得了 usage，客户端那边却要尽快拿到首字节。
+* 手动转发是把上游 chunk **即刻**交给下游，统计只攒几个数字，零缓冲、
+* 首字节延迟不受影响。
+*
+* @param source 上游流（插件已转成 OpenAI SSE）
+* @param startedAt 请求开始时间（`Date.now()`），TTFB 以此为基准
+*/
+function tapStreamUsage(source, startedAt) {
+	const dec = new TextDecoder();
+	let buf = "";
+	let merged = null;
+	let outputChars = 0;
+	let firstAt = 0;
+	const parseFrame = (frame) => {
+		for (const line of frame.split("\n")) {
+			if (!line.startsWith("data:")) continue;
+			const payload = line.slice(5).trim();
+			if (payload === "" || payload === "[DONE]") continue;
+			let obj;
+			try {
+				obj = JSON.parse(payload);
+			} catch {
+				continue;
+			}
+			if (obj === null || typeof obj !== "object" || Array.isArray(obj)) continue;
+			merged = mergeUsage(merged, extractFrameUsage(obj));
+			outputChars += frameText(obj).length;
+		}
+	};
+	return {
+		stream: new ReadableStream({ start: async (ctrl) => {
+			const reader = source.getReader();
+			try {
+				for (;;) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					if (firstAt === 0) firstAt = Date.now();
+					buf += dec.decode(value, { stream: true });
+					let sep;
+					while ((sep = buf.indexOf("\n\n")) >= 0) {
+						const frame = buf.slice(0, sep + 2);
+						buf = buf.slice(sep + 2);
+						parseFrame(frame);
+					}
+					ctrl.enqueue(value);
+				}
+				if (buf !== "") parseFrame(buf);
+			} finally {
+				reader.releaseLock();
+			}
+			ctrl.close();
+		} }),
+		done: async () => ({
+			usage: merged,
+			outputChars,
+			ttfbMs: firstAt === 0 ? 0 : firstAt - startedAt
+		})
+	};
+}
+/**
+* 补齐估算：上游没给的字段用字符数估，并打标记。
+*
+* `requestChars` = 请求体字符数（估输入），`outputChars` = 输出字符数（估输出）。
+* 上游给了的字段**不覆盖**——估算只填空，不抢真数据。
+*/
+function withEstimates(usage, requestChars, outputChars) {
+	const prompt = usage?.promptTokens ?? 0;
+	const completion = usage?.completionTokens ?? 0;
+	const inputEstimated = prompt === 0;
+	const outputEstimated = completion === 0;
+	return {
+		promptTokens: inputEstimated ? estimateTokens(requestChars) : prompt,
+		completionTokens: outputEstimated ? estimateTokens(outputChars) : completion,
+		cachedTokens: usage?.cachedTokens ?? 0,
+		inputEstimated,
+		outputEstimated
+	};
+}
+//#endregion
 //#region src/router/index.ts
 /**
 * dsh-router 路由器本体：供应商注册表 + OpenAI 兼容 /v1/* 处理。
 * 仿 9router：组合 = 一组模型，请求 model 命中组合名时，按策略
 * （fallback 顺序尝试 / round-robin 轮转）选中一个模型路由。
 */
+/** 模型列表缓存有效期。 */
+const MODELS_TTL_MS = 6e4;
 function openAIError(code, msg) {
 	return { error: {
 		message: msg,
@@ -23,12 +891,295 @@ function openAIError(code, msg) {
 		code
 	} };
 }
-function writeJson$2(res, status, body) {
-	res.writeHead(status, {
-		"Content-Type": "application/json; charset=utf-8",
-		"Cache-Control": "no-store"
+function writeJson$2(res, status, body) {
+	res.writeHead(status, {
+		"Content-Type": "application/json; charset=utf-8",
+		"Cache-Control": "no-store"
+	});
+	res.end(JSON.stringify(body));
+}
+/** 丢弃响应的假 ServerResponse（测试模型用：记录状态+内容，用于判定成败）。 */
+function sinkRes() {
+	let status = 200;
+	let text = "";
+	const self = {
+		headersSent: false,
+		writableEnded: false,
+		writeHead: (code) => {
+			status = code;
+			return self;
+		},
+		write: (chunk) => {
+			if (chunk !== void 0) text += String(chunk);
+			return true;
+		},
+		end: (chunk) => {
+			if (chunk !== void 0) text += String(chunk);
+			return self;
+		},
+		flushHeaders: () => {},
+		status: () => status,
+		body: () => text
+	};
+	return self;
+}
+/**
+* 把 OpenAI SSE 流聚合成一次非流式响应体。
+*
+* 为什么核心要做这个：有些供应商**只支持流式**（如 codebuddy 强制 stream:true），
+* 于是客户端要 JSON 时也会拿到流。核心独占响应写入权，就得把这个错配吸收掉——
+* 否则客户端按 JSON 解析 `choices[0].message.tool_calls[].function.name`，
+* 而名字藏在 SSE 的 `delta` 里，解析结果就是 name 为空（下游报
+* `unknown tool ""`）。这是协议错配，不是丢数据。
+*/
+async function aggregateSSE(stream) {
+	const dec = new TextDecoder();
+	let id = "";
+	let model = "";
+	let created = Math.floor(Date.now() / 1e3);
+	let content = "";
+	let reasoning = "";
+	let finish = null;
+	let usage;
+	const calls = /* @__PURE__ */ new Map();
+	const reader = stream.getReader();
+	let buf = "";
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		buf += dec.decode(value, { stream: true });
+		let sep;
+		while ((sep = buf.indexOf("\n\n")) >= 0) {
+			const frame = buf.slice(0, sep);
+			buf = buf.slice(sep + 2);
+			for (const line of frame.split("\n")) {
+				if (!line.startsWith("data:")) continue;
+				const payload = line.slice(5).trim();
+				if (payload === "" || payload === "[DONE]") continue;
+				let obj;
+				try {
+					obj = JSON.parse(payload);
+				} catch {
+					continue;
+				}
+				if (typeof obj.id === "string" && obj.id !== "") id = obj.id;
+				if (typeof obj.model === "string" && obj.model !== "") model = obj.model;
+				if (typeof obj.created === "number") created = obj.created;
+				if (obj.usage !== void 0) usage = obj.usage;
+				const ch = obj.choices?.[0];
+				if (ch === void 0) continue;
+				if (typeof ch.finish_reason === "string") finish = ch.finish_reason;
+				const delta = ch.delta;
+				if (delta === void 0) {
+					const msg = ch.message;
+					if (msg !== void 0) {
+						if (typeof msg.content === "string") content += msg.content;
+						if (typeof msg.reasoning_content === "string") reasoning += msg.reasoning_content;
+					}
+					continue;
+				}
+				if (typeof delta.content === "string") content += delta.content;
+				if (typeof delta.reasoning_content === "string") reasoning += delta.reasoning_content;
+				const tcs = delta.tool_calls;
+				if (!Array.isArray(tcs)) continue;
+				for (const tc of tcs) {
+					const idx = typeof tc.index === "number" ? tc.index : 0;
+					const fn = tc.function;
+					const prev = calls.get(idx) ?? {
+						name: "",
+						args: ""
+					};
+					if (typeof tc.id === "string" && tc.id !== "") prev.id = tc.id;
+					if (typeof tc.type === "string") prev.type = tc.type;
+					if (typeof fn?.name === "string" && fn.name !== "") prev.name = fn.name;
+					if (typeof fn?.arguments === "string") prev.args += fn.arguments;
+					calls.set(idx, prev);
+				}
+			}
+		}
+	}
+	const toolCalls = [...calls.entries()].sort((a, b) => a[0] - b[0]).filter(([, c]) => c.name !== "").map(([, c]) => ({
+		id: c.id ?? `call_${c.name}`,
+		type: c.type ?? "function",
+		function: {
+			name: c.name,
+			arguments: c.args
+		}
+	}));
+	const message = {
+		role: "assistant",
+		content
+	};
+	if (reasoning !== "") message.reasoning_content = reasoning;
+	if (toolCalls.length > 0) message.tool_calls = toolCalls;
+	const body = {
+		id: id !== "" ? id : `chatcmpl-${Date.now()}`,
+		object: "chat.completion",
+		created,
+		model,
+		choices: [{
+			index: 0,
+			message,
+			finish_reason: finish ?? "stop",
+			logprobs: null
+		}]
+	};
+	if (usage !== void 0) body.usage = usage;
+	return JSON.stringify(body);
+}
+/**
+* 流式 SSE 逐帧归一化：剥掉上游多发一次的**空** tool_call 字段。
+*
+* 为什么必须做：CodeBuddy 上游的工具调用第二个 delta 会**显式发空串**
+*   `{"function":{"name":"","arguments":"{...}"},"index":0}`（以及 `"id":""`）。
+* OpenAI 规范里后续 delta 应当**省略**这些字段，客户端沿用首帧的名字；
+* 而客户端（dsh）判空用的是 `name !== void 0`，空串过不了这个判断，于是首帧
+* 的 "bash" 被第二帧的 "" 冲掉 —— 工具名变空，下游报 `unknown tool ""`，
+* 而 arguments 是独立累积的，所以现象是「参数对、名字空」。
+*
+* 核心是流式响应的唯一写入方，这个上游不合规得核心吸收：把空串字段**删掉**
+* （而不是留着空串），客户端看到的就是 undefined，不会覆盖。
+*
+* 只动 tool_calls 的空 name/id，其余原样透传；逐帧流式处理，不缓冲整条流
+* （首字节延迟不受影响）。解析失败一律原样透传——宁可不改，也不能改坏。
+*/
+function normalizeSSEStream(stream) {
+	const enc = new TextEncoder();
+	const dec = new TextDecoder();
+	let buf = "";
+	return new ReadableStream({ start: async (ctrl) => {
+		const reader = stream.getReader();
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				buf += dec.decode(value, { stream: true });
+				let sep;
+				while ((sep = buf.indexOf("\n\n")) >= 0) {
+					const frame = buf.slice(0, sep + 2);
+					buf = buf.slice(sep + 2);
+					ctrl.enqueue(enc.encode(fixFrame(frame)));
+				}
+			}
+			if (buf !== "") ctrl.enqueue(enc.encode(fixFrame(buf)));
+		} finally {
+			reader.releaseLock();
+		}
+		ctrl.close();
+	} });
+}
+/** 修一帧 SSE：只剥空的 name/id，出任何问题都原样返回。 */
+function fixFrame(frame) {
+	if (!frame.includes("tool_calls")) return frame;
+	return frame.split("\n").map((line) => {
+		if (!line.startsWith("data: ")) return line;
+		const payload = line.slice(6).trim();
+		if (payload === "" || payload === "[DONE]") return line;
+		let obj;
+		try {
+			obj = JSON.parse(payload);
+		} catch {
+			return line;
+		}
+		let changed = false;
+		const tcs = (obj.choices?.[0]?.delta)?.tool_calls;
+		if (Array.isArray(tcs)) for (const tc of tcs) {
+			if (tc.id === "") {
+				delete tc.id;
+				changed = true;
+			}
+			const fn = tc.function;
+			if (fn !== null && typeof fn === "object" && fn.name === "") {
+				delete fn.name;
+				changed = true;
+			}
+		}
+		return changed ? `data: ${JSON.stringify(obj)}` : line;
+	}).join("\n");
+}
+/**
+* 把 chatOnce 的结果写进 res（核心独占响应写入权）。
+* 流式：SSE 头 + pipe 上游已转好的 OpenAI SSE；非流式：原样写 JSON。
+*
+* @returns true = 响应已提交（客户端拿到东西了）；false = **一个字节都没写**
+*   （响应头也还没发），调用方可以换账号/换模型重试。
+*
+* 流式**故意推迟到第一个字节才写响应头**：上游常见「连上了但立刻断」的情况，
+* 先写头就等于把自己锁死在这一个账号上，组合就没法回退了——而客户端只拿到
+* 一个空/截断的 SSE，表现为工具调用名是空串（`unknown tool ""`）。
+*
+* 天花板：一旦写出第一个字节就绑死（HTTP 语义），中途断流只能截断，
+* 不能回退。要彻底解决得在写头前缓冲判定，代价是首字节延迟——未做。
+*/
+async function writeChatResult(res, r, wantsStream, probe, startedAt = 0) {
+	if (!r.ok) return false;
+	if (!("stream" in r)) {
+		if (probe !== void 0) probe.tokens = usageFromJsonBody(r.body);
+		res.writeHead(r.status, {
+			"Content-Type": "application/json; charset=utf-8",
+			"Cache-Control": "no-store"
+		});
+		res.end(r.body);
+		return true;
+	}
+	if (!wantsStream) {
+		let body;
+		try {
+			body = await aggregateSSE(r.stream);
+		} catch {
+			return false;
+		}
+		if (probe !== void 0) probe.tokens = usageFromJsonBody(body);
+		res.writeHead(200, {
+			"Content-Type": "application/json; charset=utf-8",
+			"Cache-Control": "no-store"
+		});
+		res.end(body);
+		return true;
+	}
+	const tapped = probe === void 0 ? void 0 : tapStreamUsage(r.stream, startedAt);
+	let wroteAny = false;
+	const writeChunk = (chunk) => new Promise((resolve) => {
+		if (!wroteAny) {
+			res.writeHead(200, {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache",
+				Connection: "keep-alive",
+				"X-Accel-Buffering": "no"
+			});
+			if (typeof res.flushHeaders === "function") res.flushHeaders();
+			wroteAny = true;
+		}
+		if (res.write(chunk)) resolve();
+		else res.once("drain", resolve);
 	});
-	res.end(JSON.stringify(body));
+	const onError = () => {
+		res.destroy();
+	};
+	res.once("error", onError);
+	try {
+		await normalizeSSEStream(tapped?.stream ?? r.stream).pipeTo(new WritableStream({ write: writeChunk }));
+	} catch {} finally {
+		res.removeListener("error", onError);
+		if (wroteAny) res.end();
+		if (probe !== void 0 && tapped !== void 0) {
+			const got = await tapped.done();
+			probe.tokens = got.usage;
+			probe.outputChars = got.outputChars;
+			probe.ttfbMs = got.ttfbMs;
+		}
+	}
+	return wroteAny;
+}
+/** 从上游响应体提取错误信息（OpenAI {error:{message}} 或 {code,msg}/{message}）。 */
+function extractUpstreamError(body) {
+	try {
+		const j = JSON.parse(body);
+		if (typeof j.error?.message === "string") return j.error.message;
+		if (typeof j.message === "string") return j.message;
+		if (typeof j.msg === "string") return j.msg;
+	} catch {}
+	return body.slice(0, 200);
 }
 /** 路由器。 */
 var Router = class {
@@ -37,10 +1188,29 @@ var Router = class {
 	customCombos = [];
 	/** round-robin 轮转游标（按组合 id 记忆）。 */
 	rrCursors = /* @__PURE__ */ new Map();
-	constructor(stateFile = "") {
+	/** 通用供应商配置（连接池顺序/策略、模型启用、别名）。 */
+	store;
+	/** 模型列表缓存（supplierId → 模型 + 拉取时间）。插件只管拉，不缓存。 */
+	modelsCache = /* @__PURE__ */ new Map();
+	/** 请求日志出口（面板/宿主 logger）。 */
+	log;
+	/** 用量统计（概览看板）。 */
+	usage;
+	constructor(stateFile = "", store, log) {
 		this.combosFp = stateFile ? join(dirname(stateFile), "combos.json") : "";
+		this.store = store ?? new SupplierConfigStore(stateFile);
+		this.log = log ?? (() => {});
+		this.usage = new UsageStore(stateFile);
 		this.loadCombos();
 	}
+	/**
+	* 请求追踪：每次 chat 记一行，回答「这个组合到底用的哪个模型和账号」。
+	* 排查「组合里某个模型不稳定」全靠它——没这个就只能猜。
+	* 格式刻意做成一行 grep 友好：`chat 请求model → supplier/model (uid) 结果 耗时`。
+	*/
+	logChat(reqModel, detail, ms) {
+		this.log(`chat ${JSON.stringify(reqModel)} → ${detail} ${ms}ms`);
+	}
 	loadCombos() {
 		if (this.combosFp === "") return;
 		try {
@@ -48,8 +1218,13 @@ var Router = class {
 			if (Array.isArray(f.combos)) this.customCombos = f.combos.filter((c) => typeof c.id === "string" && c.id !== "").map((c) => {
 				const old = c;
 				const models = (Array.isArray(c.models) ? c.models.filter((m) => typeof m === "string" && m !== "") : Array.isArray(old.steps) ? old.steps.map((s) => s.supplier).filter((m) => typeof m === "string" && m !== "") : []).map((m) => {
-					const slash = m.lastIndexOf("/");
-					return slash >= 0 ? m.slice(slash + 1) : m;
+					if (m.indexOf(",") > 0) return m;
+					const slash = m.indexOf("/");
+					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);
+					return s === void 0 ? modelId : `${s.id},${modelId}`;
 				});
 				return {
 					id: c.id,
@@ -74,12 +1249,14 @@ var Router = class {
 	add(supplier) {
 		this.suppliers.push(supplier);
 		this.suppliers.sort((a, b) => a.priority - b.priority);
+		this.store.sync(this.suppliers.map((s) => s.id));
 	}
 	/** 移除供应商（外部插件卸载时注销）。 */
 	removeSupplier(id) {
 		const i = this.suppliers.findIndex((s) => s.id === id);
 		if (i < 0) return false;
 		const [s] = this.suppliers.splice(i, 1);
+		this.modelsCache.delete(id);
 		s?.dispose();
 		return true;
 	}
@@ -120,21 +1297,67 @@ var Router = class {
 	async combos() {
 		return [...this.customCombos];
 	}
-	/** 可用模型（按供应商分组，仅启用），面板加模型用。 */
-	async supplierModels() {
-		const out = [];
-		for (const s of this.suppliers) try {
-			const models = (await s.modelsWithEnabled()).filter((m) => m.enabled);
-			out.push({
-				supplier: {
-					id: s.id,
-					name: s.name,
-					alias: s.getAlias()
-				},
-				models
+	/**
+	* 取某供应商的模型（核心统一缓存）。
+	*
+	* 模型列表只在这里缓存一次：`/suppliers/:id/models`（供应商详情）和
+	* `/combos`（组合加模型）共用。组合面板**不主动打上游**——它只是读缓存，
+	* 冷启动（缓存还没建）时才拉一次；真正刷新由详情页打开或「获取模型」
+	* 按钮（force）触发。
+	*
+	* 天花板：TTL 60s 是拍的。若上游模型列表变更很频繁，可调小；要彻底实时
+	* 就得让供应商暴露 etag/版本号，目前没有这个需求。
+	*/
+	async modelsOf(supplierId, force = false) {
+		const s = this.suppliers.find((x) => x.id === supplierId);
+		if (s === void 0) return [];
+		const hit = this.modelsCache.get(supplierId);
+		if (!force && hit !== void 0 && Date.now() - hit.fetchedAt < MODELS_TTL_MS) return hit.models;
+		const cfg = this.store.get(supplierId);
+		const custom = new Set(cfg.custom);
+		const disabled = new Set(cfg.disabled);
+		const models = (await Promise.resolve(s.listModels())).map((mm) => ({
+			...mm,
+			enabled: !disabled.has(mm.id),
+			custom: custom.has(mm.id) ? true : void 0
+		}));
+		const seen = new Set(models.map((mm) => mm.id));
+		for (const id of custom) if (!seen.has(id)) {
+			seen.add(id);
+			models.push({
+				id,
+				enabled: !disabled.has(id),
+				custom: true
 			});
-		} catch {}
-		return out;
+		}
+		this.modelsCache.set(supplierId, {
+			models,
+			fetchedAt: Date.now()
+		});
+		return models;
+	}
+	/** 失效某供应商的模型缓存（增删改模型后调用）。 */
+	invalidateModels(supplierId) {
+		this.modelsCache.delete(supplierId);
+	}
+	/** 可用模型（按供应商分组，仅启用），面板加模型用。
+	*  各供应商**并行**拉取——串行会把每个上游的延迟累加起来。 */
+	async supplierModels() {
+		return (await Promise.all(this.suppliers.map(async (s) => {
+			try {
+				const models = (await this.modelsOf(s.id)).filter((m) => m.enabled);
+				return {
+					supplier: {
+						id: s.id,
+						name: s.name,
+						alias: s.getAlias()
+					},
+					models
+				};
+			} catch {
+				return;
+			}
+		}))).filter((g) => g !== void 0);
 	}
 	validModels(models) {
 		return Array.isArray(models) && models.length > 0 && models.every((m) => typeof m === "string" && m !== "");
@@ -142,11 +1365,24 @@ var Router = class {
 	validStrategy(strategy) {
 		return strategy === "fallback" || strategy === "round-robin";
 	}
-	/** 组合模型统一存裸 id：剥掉 alias/ 前缀（前缀随供应商动态变）。 */
+	/** 组合模型统一存裸 id：剥掉 alias/ 前缀（前缀随供应商动态变）。
+	*  只剥「已知 alias + /」开头的前缀——模型 id 本身可以含斜杠
+	*  （如 nvidia 的 `deepseek-ai/deepseek-v4-flash-0731`），用 lastIndexOf 会把
+	*  命名空间一起吃掉，后面请求必然 404。 */
+	/**
+	* 归一组合模型名为存储格式 `supplierId,modelId`。
+	* 面板提交的是「供应商 id + 模型 id」两两组合（或旧数据的裸 id），
+	* 这里只做清理与校验，不再剥掉前缀——精准调用靠的就是供应商 id。
+	*/
 	normalizeModelIds(models) {
-		return models.map((m) => {
-			const slash = m.lastIndexOf("/");
-			return slash >= 0 ? m.slice(slash + 1) : m;
+		return models.map((m) => m.trim()).filter((m) => m !== "").map((m) => {
+			if (m.indexOf(",") > 0) return m;
+			const slash = m.indexOf("/");
+			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);
+			return s === void 0 ? modelId : `${s.id},${modelId}`;
 		});
 	}
 	/** 创建组合（name 唯一，非 default）。 */
@@ -245,6 +1481,34 @@ var Router = class {
 	* - 否则 → 依次尝试供应商，直到某个返回 true（已写响应）或全部返回 false。
 	*/
 	async chatCompletions(req, res) {
+		const probe = {
+			requested: req.model,
+			supplier: "",
+			model: "",
+			uid: "",
+			tokens: null,
+			outputChars: 0,
+			ttfbMs: 0,
+			startedAt: Date.now()
+		};
+		const settle = (ok, error) => {
+			const usage = ok ? withEstimates(probe.tokens, req.rawBody.length, probe.outputChars) : {
+				promptTokens: 0,
+				completionTokens: 0,
+				cachedTokens: 0,
+				inputEstimated: false,
+				outputEstimated: false
+			};
+			this.usage.record({
+				supplier: probe.supplier,
+				model: probe.model,
+				requested: probe.requested,
+				ok,
+				durationMs: Date.now() - probe.startedAt,
+				ttfbMs: probe.ttfbMs,
+				...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;
@@ -252,33 +1516,185 @@ var Router = class {
 			for (let i = 0; i < combo.models.length; i++) {
 				const model = combo.models[(start + i) % combo.models.length];
 				if (model === void 0) continue;
-				if (await this.chatWithModel(req, res, model)) return;
+				if (await this.chatWithModel(req, res, model, probe)) {
+					settle(true);
+					return;
+				}
 			}
+			settle(false, "combo: all models unavailable");
 			writeJson$2(res, 503, openAIError("no_healthy_supplier", `combo ${JSON.stringify(req.model)}: all models unavailable`));
 			return;
 		}
-		for (const s of this.suppliers) if (await s.chatCompletions(req, res)) return;
+		const slash = req.model.indexOf("/");
+		const alias = slash > 0 ? req.model.slice(0, slash) : "";
+		const target = alias === "" ? void 0 : this.supplierByAlias(alias);
+		if (target !== void 0) {
+			if (await this.chatWithTarget(target, req, res, probe)) {
+				settle(true);
+				return;
+			}
+			settle(false, `supplier ${target.id}: all accounts unavailable`);
+			writeJson$2(res, 503, openAIError("no_healthy_supplier", `supplier ${JSON.stringify(target.id)}: all accounts unavailable`));
+			return;
+		}
+		if (await this.chatWithModel(req, res, req.model, probe)) {
+			settle(true);
+			return;
+		}
+		settle(false, "all suppliers unavailable");
 		writeJson$2(res, 503, openAIError("no_healthy_supplier", "all suppliers unavailable"));
 	}
-	/** 把 model 改写为组合选中的模型名后尝试供应商。 */
-	async chatWithModel(req, res, model) {
+	/** 调指定供应商。
+	*  模型名**原样**传给插件（不在这剥 alias/）——插件自己认得自己的别名
+	*  （如 traework 会剥第一段）。核心在这剥就会剥两次，把模型 id 里的
+	*  命名空间（如 org/name）吃掉。 */
+	async chatWithTarget(s, req, res, probe) {
+		return await this.chatWithModel(req, res, `${s.id},${req.model}`, probe);
+	}
+	/** 把 model 改写为组合选中的模型名后，找对应的供应商 + 账号（策略全在核心）。
+	*
+	*  `model` 形如 `supplierId,modelId`（组合的存储格式）：直接用 supplierId 定位，
+	*  不再挨个问供应商「这是不是你的模型」——精准调用，也避免同名模型串台。
+	*  兼容旧的裸 `modelId`（没有逗号）：降级为遍历，行为同以前。
+	*/
+	async chatWithModel(req, res, model, probe) {
+		const comma = model.indexOf(",");
+		const supplierId = comma > 0 ? model.slice(0, comma) : void 0;
+		const modelId = comma > 0 ? model.slice(comma + 1) : model;
 		const clone = {
 			...req,
-			model
+			model: modelId
 		};
 		try {
 			const obj = JSON.parse(req.rawBody);
-			obj.model = model;
+			obj.model = modelId;
 			clone.rawBody = JSON.stringify(obj);
 		} catch {
 			clone.rawBody = req.rawBody;
 		}
-		for (const s of this.suppliers) if (await s.chatCompletions(clone, res)) return true;
+		if (supplierId !== void 0) {
+			const s = this.suppliers.find((x) => x.id === supplierId);
+			if (s === void 0) {
+				this.logChat(req.model, `supplier ${JSON.stringify(supplierId)} 不存在`, 0);
+				return false;
+			}
+			const t0 = Date.now();
+			const trace = { attempts: 0 };
+			const served = await this.chatWithSupplier(s, clone, res, trace, probe);
+			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);
+			return served;
+		}
+		for (const s of this.suppliers) if (await this.chatWithSupplier(s, clone, res, void 0, probe)) return true;
 		return false;
 	}
+	/** 按别名找供应商（对外模型全名 = alias/model）。别名唯一，故最多命中一个。 */
+	supplierByAlias(alias) {
+		return this.suppliers.find((s) => s.getAlias() === alias);
+	}
+	/**
+	* 单个供应商内遍历账号（核心策略）：选号 → 调 chatOnce → 按返回的
+	* AccountState 处置 → 失败换号；写响应只在成功后发生。
+	*
+	* 流式**推迟到第一个字节才写响应头**，所以「上游刚连上就断」这种情况
+	* 还能换号重试；一旦写出第一个字节就绑死（HTTP 语义，9router 同样如此），
+	* 之后出错不再换号——要彻底能回退就得在写头前缓冲判定，代价是首字节
+	* 延迟，目前未做。
+	*/
+	async chatWithSupplier(s, req, res, trace, probe) {
+		const pool = s.pool;
+		const cfg = this.store.get(s.id);
+		if (s.accounts !== void 0 && s.accounts().length === 0) {
+			const r = await s.chatOnce("", req);
+			if (!r.ok) {
+				if (r.state === "no_such_model") return false;
+				pool.noteFailure("", r.state, r.message);
+				return false;
+			}
+			if (trace !== void 0) trace.uid = "(no-account)";
+			if (probe !== void 0) {
+				probe.supplier = s.id;
+				probe.model = `${s.getAlias()}/${req.model}`;
+				probe.uid = "";
+			}
+			return await writeChatResult(res, r, req.stream, probe, probe?.startedAt ?? 0);
+		}
+		const tried = /* @__PURE__ */ new Set();
+		for (;;) {
+			const uid = pool.pick(s.accounts().filter((a) => !tried.has(a.uid)), cfg.poolOrder, cfg.poolStrategy);
+			if (uid === void 0) return false;
+			tried.add(uid);
+			const r = await s.chatOnce(uid, req);
+			if (!r.ok) {
+				if (r.state === "no_such_model") {
+					if (trace !== void 0) trace.lastError = "no_such_model";
+					return false;
+				}
+				pool.noteFailure(uid, r.state, r.message);
+				if (trace !== void 0) {
+					trace.attempts += 1;
+					trace.lastError = `${r.state}: ${r.message}`;
+				}
+				continue;
+			}
+			pool.noteSuccess(uid);
+			if (trace !== void 0) trace.uid = uid;
+			if (probe !== void 0) {
+				probe.supplier = s.id;
+				probe.model = `${s.getAlias()}/${req.model}`;
+				probe.uid = uid;
+			}
+			if (await writeChatResult(res, r, req.stream, probe, probe?.startedAt ?? 0)) return true;
+			pool.noteFailure(uid, "transport", "stream failed before first byte");
+			if (trace !== void 0) {
+				trace.attempts += 1;
+				trace.lastError = "stream failed before first byte";
+			}
+		}
+	}
+	/** 测试某供应商的某模型是否可用。
+	*  走真实的账号遍历 + chatOnce 路径：账号池回退/冷却由核心实现，自动生效；
+	*  响应丢弃到 sink，限定单一供应商（不跨供应商回退）。 */
+	async testModel(supplierId, model) {
+		const s = this.suppliers.find((x) => x.id === supplierId);
+		if (s === void 0) return {
+			ok: false,
+			error: `unknown supplier ${JSON.stringify(supplierId)}`
+		};
+		const sink = sinkRes();
+		const req = {
+			model,
+			stream: false,
+			rawBody: JSON.stringify({
+				model,
+				messages: [{
+					role: "user",
+					content: "ping"
+				}],
+				stream: false,
+				max_tokens: 1
+			})
+		};
+		let served = false;
+		try {
+			served = await this.chatWithSupplier(s, req, sink);
+		} catch (err) {
+			return {
+				ok: false,
+				error: err.message
+			};
+		}
+		if (served && sink.status() < 400) return { ok: true };
+		const fromSink = served && sink.status() >= 400 ? extractUpstreamError(sink.body()) : "";
+		const detail = fromSink !== "" ? fromSink : s.lastError?.();
+		return {
+			ok: false,
+			error: detail !== void 0 && detail !== "" ? `${detail}（账号/额度/限流问题，非模型问题）` : "所有账号都失败或账号都在冷却中（稍后重试）"
+		};
+	}
 	dispose() {
 		for (const s of this.suppliers) s.dispose();
 		this.suppliers = [];
+		this.usage.flush();
 	}
 };
 //#endregion
@@ -378,15 +1794,16 @@ function wireRequest(options) {
 function flattenText(blocks) {
 	return blocks.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
 }
-/** openai SSE payload → DSH StreamChunk 流。 */
-async function* translate(payloads) {
+/** openai SSE payload → DSH StreamChunk 流。导出以便单测锁死 usage 契约。 */
+async function* translateSse(payloads) {
 	let nextIndex = 0;
 	let textBlock;
 	let reasoningBlock;
 	const toolBlocks = /* @__PURE__ */ new Map();
 	const order = [];
 	let pendingFinish;
-	let pendingUsage;
+	/** 攒上游各帧的 usage（归一形态），[DONE] 时统一转成 DSH 契约。 */
+	let accumulated = null;
 	const open = (kind) => {
 		const block = {
 			index: nextIndex++,
@@ -403,10 +1820,13 @@ async function* translate(payloads) {
 				index: block.index,
 				block: closeBlock(block)
 			};
-			if (pendingUsage !== void 0) yield {
-				type: "usage",
-				usage: pendingUsage
-			};
+			if (accumulated !== null) {
+				const usage = toTokenUsage(accumulated);
+				if (usage !== null) yield {
+					type: "usage",
+					usage
+				};
+			}
 			const reason = pendingFinish ?? { kind: "stop" };
 			yield {
 				type: "finish",
@@ -489,7 +1909,7 @@ async function* translate(payloads) {
 			}
 			if (typeof choice.finish_reason === "string") pendingFinish = mapFinishReason(choice.finish_reason);
 		}
-		if (chunk.usage !== void 0) pendingUsage = chunk.usage;
+		if (chunk.usage !== void 0) accumulated = mergeUsage(accumulated, normalizeUsage(chunk.usage));
 	}
 	throw new LlmError("SSE payload stream ended without [DONE]", "STREAM_CLOSED");
 }
@@ -583,7 +2003,7 @@ var RouterAdapter = class extends LlmAdapter {
 			const detail = await resp.text().catch(() => "");
 			throw new LlmError(`dsh-router /v1 returned ${resp.status}: ${detail.slice(0, 200)}`, "TRANSPORT");
 		}
-		yield* translate(parseSseText(resp.body === null ? "" : await resp.text()));
+		yield* translateSse(parseSseText(resp.body === null ? "" : await resp.text()));
 	}
 };
 //#endregion
@@ -720,7 +2140,6 @@ function resolveModule(mod, file) {
 	if (typeof cand !== "object" || cand === null) throw new Error(`供应商模块无效: ${file}`);
 	if (typeof cand.id !== "string" || cand.id === "") throw new Error(`供应商缺少 id: ${file}`);
 	if (typeof cand.name !== "string" || cand.name === "") throw new Error(`供应商缺少 name: ${file}`);
-	if (typeof cand.testModel !== "function") throw new Error(`供应商 ${cand.id} 缺少 testModel（必要差异化能力）: ${file}`);
 	return cand;
 }
 /** 加载单个供应商文件，返回模块对象或抛错。 */
@@ -729,7 +2148,7 @@ async function importSupplierFile(file) {
 }
 /**
 * 差异化能力（供应商 js 实现；其余为通用能力由核心提供）。
-* testModel 是必要差异化能力（核心必须），不在此列。
+* testModel / 连接池 / 模型管理 / 别名 / 凭证存储均为核心通用能力，不在此列。
 */
 const DIFF_CAPS = [
 	"generateLoginUrl",
@@ -745,7 +2164,6 @@ async function loadOne(file, env, source) {
 	if (typeof mod === "function") {
 		instance = mod(env);
 		if (typeof instance !== "object" || instance === null || typeof instance.id !== "string" || instance.id === "") throw new Error(`供应商 factory 返回无效: ${file}`);
-		if (typeof instance.testModel !== "function") throw new Error(`供应商 ${instance.id} 缺少 testModel（必要差异化能力）: ${file}`);
 	} else instance = mod;
 	return wrapModule(instance, env, file, source);
 }
@@ -755,15 +2173,22 @@ async function loadOne(file, env, source) {
 */
 function wrapModule(instance, env, source, kind = "external") {
 	if (typeof instance !== "object" || instance === null || typeof instance.id !== "string" || instance.id === "") throw new Error(`供应商模块无效: ${source}`);
-	if (typeof instance.testModel !== "function") throw new Error(`供应商 ${instance.id} 缺少 testModel（必要差异化能力）: ${source}`);
 	const capabilities = /* @__PURE__ */ new Set();
 	for (const key of DIFF_CAPS) if (isFn(instance[key])) capabilities.add(key);
+	const pool = new AccountPool();
 	const supplier = {
 		id: instance.id,
 		name: instance.name,
 		priority: instance.priority ?? 0,
 		icon: instance.icon,
-		status: () => instance.status(),
+		status: () => {
+			const now = instance.status();
+			return {
+				id: now.id,
+				name: now.name,
+				accounts: pool.decorate(now.accounts)
+			};
+		},
 		listModels: (force) => instance.listModels(force),
 		modelsWithEnabled: (force) => {
 			const cfg = env.store.get(instance.id);
@@ -775,12 +2200,14 @@ function wrapModule(instance, env, source, kind = "external") {
 				custom: custom.has(mm.id) ? true : void 0
 			})));
 		},
-		getAlias: () => env.store.get(instance.id).alias || instance.getAlias(),
+		getAlias: () => env.store.get(instance.id).alias || instance.id,
 		customModelIds: () => [...env.store.get(instance.id).custom],
-		chatCompletions: (req, res) => instance.chatCompletions(req, res),
-		testModel: (id) => instance.testModel(id),
+		accounts: () => instance.status().accounts,
+		chatOnce: (uid, req) => instance.chatOnce(uid, req),
+		lastError: isFn(instance.lastError) ? () => instance.lastError() : void 0,
 		removeLink: isFn(instance.removeLink) ? (uid) => instance.removeLink(uid) : void 0,
-		dispose: () => instance.dispose()
+		dispose: () => instance.dispose(),
+		pool
 	};
 	supplier.__module = instance;
 	return {
@@ -862,41 +2289,36 @@ async function readBody$1(req, limit = 65536) {
 function cap(set, key) {
 	return set.has(key);
 }
-/** 模型列表统一缓存（dsh-router 核心管；插件只管拉取，不缓存）。 */
-const modelsCache = /* @__PURE__ */ new Map();
-const MODELS_TTL_MS = 6e4;
-/** 拉取并缓存某供应商模型（force 时强制刷新）。custom 模型并入显示。 */
-async function cachedModels(s, cfg, force = false) {
-	const hit = modelsCache.get(s.id);
-	if (!force && hit && Date.now() - hit.fetchedAt < MODELS_TTL_MS) return hit.models;
-	const list = await Promise.resolve(s.listModels());
-	const custom = new Set(cfg.custom);
-	const disabled = new Set(cfg.disabled);
-	const models = list.map((mm) => ({
-		...mm,
-		enabled: !disabled.has(mm.id),
-		custom: custom.has(mm.id) ? true : void 0
-	}));
-	const seen = new Set(models.map((mm) => mm.id));
-	for (const id of custom) if (!seen.has(id)) {
-		seen.add(id);
-		models.push({
-			id,
-			enabled: !disabled.has(id),
-			custom: true
-		});
+/** 账号状态指纹（积分 + 健康），用于判断刷新是否落地。 */
+function fingerprint(accounts) {
+	return accounts.map((a) => `${a.uid}:${a.credits}:${a.cooling}:${a.disabled}`).join("|");
+}
+/**
+* 反复调插件已有的 status()，直到快照稳定再返回（是否有变化 = changed）。
+* 插件的积分刷新是 fire-and-forget（status() 内部异步拉），核心拿不到句柄，
+* 只能按指纹变化等它落地。天花板：缓存未过期时插件不会真拉上游，此时按钮
+* 退化为「重读一次状态」（冷却/禁用这类健康状态仍是 status() 实时算的）。
+* 升级路径：插件暴露可 await 的刷新能力，这里就不用轮询了。
+*/
+async function settleStatus(s, timeoutMs = 3e3) {
+	const first = fingerprint(s.status().accounts);
+	const deadline = Date.now() + timeoutMs;
+	let last = first;
+	let stable = 0;
+	while (Date.now() < deadline) {
+		await new Promise((resolve) => setTimeout(resolve, 200));
+		const now = fingerprint(s.status().accounts);
+		stable = now === last ? stable + 1 : 0;
+		last = now;
+		if (stable >= 2) break;
 	}
-	modelsCache.set(s.id, {
-		models,
-		fetchedAt: Date.now()
-	});
-	return models;
+	return last !== first;
 }
 function mod(s) {
 	return s.supplier.__module ?? {};
 }
 /** 为一个供应商生成端点（通用 + 差异化，返回 route 列表）。 */
-function supplierRoutes(base, loaded, store) {
+function supplierRoutes(base, loaded, store, router) {
 	const s = loaded.supplier;
 	const m = mod(loaded);
 	const c = loaded.capabilities;
@@ -906,7 +2328,7 @@ function supplierRoutes(base, loaded, store) {
 		kind: "exact",
 		path: `${p}/models`,
 		handler: async (_req, res) => {
-			const models = await cachedModels(s, store.get(s.id));
+			const models = await router.modelsOf(s.id);
 			writeJson$1(res, 200, {
 				ok: true,
 				alias: s.getAlias(),
@@ -919,14 +2341,21 @@ function supplierRoutes(base, loaded, store) {
 		path: `${p}/alias`,
 		handler: async (req, res) => {
 			const clean = (JSON.parse(await readBody$1(req)).alias ?? "").trim();
-			if (clean === "" || !/^[A-Za-z0-9_-]+$/.test(clean)) {
+			if (clean !== "" && !/^[A-Za-z0-9_-]+$/.test(clean)) {
 				writeJson$1(res, 400, {
 					ok: false,
 					error: "前缀只能包含字母、数字、- 和 _"
 				});
 				return;
 			}
-			store.setAlias(s.id, clean);
+			const r = store.setAlias(s.id, clean);
+			if (!r.ok) {
+				writeJson$1(res, 400, {
+					ok: false,
+					error: `前缀已被供应商 ${JSON.stringify(r.conflictWith ?? "?")} 占用`
+				});
+				return;
+			}
 			writeJson$1(res, 200, { ok: true });
 		}
 	});
@@ -935,8 +2364,8 @@ function supplierRoutes(base, loaded, store) {
 		path: `${p}/models/toggle`,
 		handler: async (req, res) => {
 			const body = JSON.parse(await readBody$1(req));
-			const cfg = store.get(s.id);
-			const models = await cachedModels(s, cfg);
+			store.get(s.id);
+			const models = await router.modelsOf(s.id);
 			if (!body.id || !models.some((mm) => mm.id === body.id)) {
 				writeJson$1(res, 400, {
 					ok: false,
@@ -945,7 +2374,7 @@ function supplierRoutes(base, loaded, store) {
 				return;
 			}
 			store.setModelEnabled(s.id, body.id, !!body.enabled);
-			modelsCache.delete(s.id);
+			router.invalidateModels(s.id);
 			writeJson$1(res, 200, { ok: true });
 		}
 	});
@@ -961,7 +2390,7 @@ function supplierRoutes(base, loaded, store) {
 				});
 				return;
 			}
-			if ((await cachedModels(s, store.get(s.id))).some((mm) => mm.id === id)) {
+			if ((await router.modelsOf(s.id)).some((mm) => mm.id === id)) {
 				writeJson$1(res, 400, {
 					ok: false,
 					error: `模型 ${id} 已存在`
@@ -969,7 +2398,7 @@ function supplierRoutes(base, loaded, store) {
 				return;
 			}
 			store.addCustomModel(s.id, id);
-			modelsCache.delete(s.id);
+			router.invalidateModels(s.id);
 			writeJson$1(res, 200, { ok: true });
 		}
 	});
@@ -987,7 +2416,7 @@ function supplierRoutes(base, loaded, store) {
 				return;
 			}
 			store.removeCustomModel(s.id, body.id);
-			modelsCache.delete(s.id);
+			router.invalidateModels(s.id);
 			writeJson$1(res, 200, { ok: true });
 		}
 	});
@@ -996,9 +2425,9 @@ function supplierRoutes(base, loaded, store) {
 		path: `${p}/models/bulk`,
 		handler: async (req, res) => {
 			const body = JSON.parse(await readBody$1(req));
-			const models = await cachedModels(s, store.get(s.id));
+			const models = await router.modelsOf(s.id);
 			store.setAllModelsEnabled(s.id, !!body.enabled, models.map((mm) => mm.id));
-			modelsCache.delete(s.id);
+			router.invalidateModels(s.id);
 			writeJson$1(res, 200, { ok: true });
 		}
 	});
@@ -1054,7 +2483,7 @@ function supplierRoutes(base, loaded, store) {
 		handler: async (_req, res) => {
 			writeJson$1(res, 200, {
 				ok: true,
-				models: await cachedModels(s, store.get(s.id), true)
+				models: await router.modelsOf(s.id, true)
 			});
 		}
 	});
@@ -1063,7 +2492,7 @@ function supplierRoutes(base, loaded, store) {
 		path: `${p}/models/test`,
 		handler: async (req, res) => {
 			const body = JSON.parse(await readBody$1(req));
-			const result = await s.testModel(body.id ?? "");
+			const result = await router.testModel(s.id, body.id ?? "");
 			writeJson$1(res, result.ok ? 200 : 400, result);
 		}
 	});
@@ -1158,159 +2587,64 @@ function supplierRoutes(base, loaded, store) {
 	});
 	routes.push({
 		kind: "exact",
-		path: `${p}/checkin/rule`,
-		handler: async (req, res) => {
-			if (req.method === "GET") {
+		path: `${p}/links/refresh`,
+		handler: async (_req, res) => {
+			try {
 				writeJson$1(res, 200, {
 					ok: true,
-					rule: store.get(s.id).checkinRule
+					changed: await settleStatus(s),
+					accounts: s.status().accounts
 				});
-				return;
-			}
-			const body = JSON.parse(await readBody$1(req));
-			if (body.rule !== "all" && body.rule !== "first") {
-				writeJson$1(res, 400, {
+			} catch (err) {
+				writeJson$1(res, 500, {
 					ok: false,
-					error: "rule 必须是 all 或 first"
+					error: err.message
 				});
-				return;
 			}
-			store.setCheckinRule(s.id, body.rule);
-			writeJson$1(res, 200, { ok: true });
 		}
 	});
 	if (cap(c, "checkinNow")) routes.push({
 		kind: "exact",
 		path: `${p}/checkin`,
 		handler: async (_req, res) => {
-			try {
-				const result = await m.checkinNow.call(loaded.supplier);
-				writeJson$1(res, result.ok === false ? 400 : 200, result);
+			const checkinOne = m.checkinNow;
+			if (!checkinOne) {
+				writeJson$1(res, 400, {
+					ok: false,
+					error: "该供应商不支持签到"
+				});
+				return;
+			}
+			const uids = s.status().accounts.map((a) => a.uid);
+			const results = [];
+			for (const uid of uids) try {
+				results.push({
+					uid,
+					...await checkinOne.call(loaded.supplier, uid)
+				});
 			} catch (err) {
-				writeJson$1(res, 500, {
+				results.push({
+					uid,
 					ok: false,
-					error: err.message
+					status: "error",
+					message: err.message
 				});
 			}
+			const succeeded = results.filter((r) => r.status === "ok").length;
+			const already = results.filter((r) => r.status === "already").length;
+			const payload = {
+				ok: succeeded + already > 0,
+				total: uids.length,
+				succeeded,
+				already,
+				results
+			};
+			writeJson$1(res, payload.ok ? 200 : 400, payload);
 		}
 	});
 	return routes;
 }
 //#endregion
-//#region src/supplier-config.ts
-/**
-* 通用供应商配置 —— dsh-router 核心能力,按供应商 id 存储。
-*
-* 通用能力(所有供应商共享,供应商 js 不需要实现)：
-*   - 别名 alias(前缀,模型全名 = alias/id)
-*   - 模型管理:启用/禁用 disabled、自定义 custom
-*   - 连接池:poolOrder(拖动排序)、poolStrategy(回退/轮询)
-*   - 签到规则 checkinRule(所有链接 / 首个链接)
-*
-* 持久化到 data/supplier-config.json。
-*/
-/** 通用供应商配置存储。 */
-var SupplierConfigStore = class {
-	fp = "";
-	bySupplier = /* @__PURE__ */ new Map();
-	constructor(stateFile) {
-		this.fp = stateFile ? join(dirname(stateFile), "supplier-config.json") : "";
-		this.load();
-	}
-	/** 读取某供应商配置(不存在则返回默认并注册)。 */
-	get(supplierId) {
-		let cfg = this.bySupplier.get(supplierId);
-		if (!cfg) {
-			cfg = {
-				alias: "",
-				disabled: [],
-				custom: [],
-				poolOrder: [],
-				poolStrategy: "fallback",
-				checkinRule: "all"
-			};
-			this.bySupplier.set(supplierId, cfg);
-		}
-		return cfg;
-	}
-	setAlias(supplierId, alias) {
-		this.get(supplierId).alias = alias;
-		this.saveLocked();
-	}
-	setModelEnabled(supplierId, modelId, enabled) {
-		const cfg = this.get(supplierId);
-		cfg.disabled = enabled ? cfg.disabled.filter((m) => m !== modelId) : [.../* @__PURE__ */ new Set([...cfg.disabled, modelId])];
-		this.saveLocked();
-	}
-	setAllModelsEnabled(supplierId, enabled, allModelIds) {
-		const cfg = this.get(supplierId);
-		cfg.disabled = enabled ? [] : [...new Set(allModelIds)];
-		this.saveLocked();
-	}
-	addCustomModel(supplierId, modelId) {
-		const cfg = this.get(supplierId);
-		if (!cfg.custom.includes(modelId)) cfg.custom.push(modelId);
-		this.saveLocked();
-	}
-	removeCustomModel(supplierId, modelId) {
-		const cfg = this.get(supplierId);
-		cfg.custom = cfg.custom.filter((m) => m !== modelId);
-		cfg.disabled = cfg.disabled.filter((m) => m !== modelId);
-		this.saveLocked();
-	}
-	setPoolOrder(supplierId, uids) {
-		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();
-	}
-	setCheckinRule(supplierId, rule) {
-		if (rule !== "all" && rule !== "first") return;
-		this.get(supplierId).checkinRule = rule;
-		this.saveLocked();
-	}
-	load() {
-		if (this.fp === "") return;
-		let f;
-		try {
-			f = JSON.parse(readFileSync(this.fp, "utf8"));
-		} catch {
-			return;
-		}
-		for (const [id, c] of Object.entries(f.suppliers ?? {})) this.bySupplier.set(id, {
-			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",
-			checkinRule: c.checkinRule === "first" ? "first" : "all"
-		});
-	}
-	saveLocked() {
-		if (this.fp === "") return;
-		const f = { suppliers: {} };
-		for (const [id, cfg] of this.bySupplier) f.suppliers[id] = {
-			alias: cfg.alias,
-			disabled: [...cfg.disabled],
-			custom: [...cfg.custom],
-			poolOrder: [...cfg.poolOrder],
-			poolStrategy: cfg.poolStrategy,
-			checkinRule: cfg.checkinRule
-		};
-		try {
-			const dir = dirname(this.fp);
-			if (dir !== "" && dir !== ".") mkdirSync(dir, { recursive: true });
-			const raw = JSON.stringify(f, null, 2);
-			const tmp = this.fp + ".tmp";
-			writeFileSync(tmp, raw, { mode: 384 });
-			renameSync(tmp, this.fp);
-		} catch {}
-	}
-};
-//#endregion
 //#region src/credential-store.ts
 /**
 * 通用凭证存储 —— dsh-router 核心统一管账号凭证（SQLite，参考 9router 的
@@ -1399,7 +2733,7 @@ function apply(rawContext) {
 	const stateFile = process.env.TW2A_STATE_FILE ?? "data/state.json";
 	const store = new SupplierConfigStore(stateFile);
 	const credentials = new CredentialStore(process.env.TW2A_AUTH_DIR ?? join(dirname(stateFile), "auths"));
-	const router = new Router(stateFile);
+	const router = new Router(stateFile, store, log);
 	const keys = new KeysStore(stateFile);
 	const disposers = [];
 	const route = (path, handler) => {
@@ -1414,7 +2748,7 @@ function apply(rawContext) {
 	const supplierDisposers = /* @__PURE__ */ new Map();
 	const registerSupplierRoutes = (loaded) => {
 		const dis = [];
-		for (const r of supplierRoutes(ROUTER_API_BASE, loaded, store)) dis.push(ctx.webServer.register(r));
+		for (const r of supplierRoutes(ROUTER_API_BASE, loaded, store, router)) dis.push(ctx.webServer.register(r));
 		supplierDisposers.set(loaded.supplier.id, dis);
 		log(`supplier routes registered: ${loaded.supplier.id}`);
 	};
@@ -1708,6 +3042,51 @@ function apply(rawContext) {
 			requireApiKey: keys.requireApiKey
 		});
 	});
+	/** 解析并校验周期参数（不接受任意字符串）。 */
+	const periodOf = (raw) => {
+		return raw === "24h" || raw === "7d" || raw === "30d" ? raw : "today";
+	};
+	route(`${ROUTER_API_BASE}/stats`, (req, res) => {
+		const period = periodOf(new URL(req.url ?? "/", "http://localhost").searchParams.get("period"));
+		const s = router.usage.stats(period);
+		writeJson(res, 200, {
+			ok: true,
+			period,
+			requests: s.requests,
+			okCount: s.ok,
+			failed: s.failed,
+			promptTokens: s.promptTokens,
+			completionTokens: s.completionTokens,
+			cachedTokens: s.cachedTokens,
+			avgDurationMs: s.avgDurationMs,
+			avgTtfbMs: s.avgTtfbMs,
+			estimatedInputs: s.estimatedInputs,
+			estimatedOutputs: s.estimatedOutputs,
+			lifetime: s.lifetime,
+			bySupplier: s.bySupplier,
+			byModel: s.byModel,
+			byRequested: s.byRequested,
+			recent: router.usage.recentList(20)
+		});
+	});
+	route(`${ROUTER_API_BASE}/stats/chart`, (req, res) => {
+		const period = periodOf(new URL(req.url ?? "/", "http://localhost").searchParams.get("period"));
+		writeJson(res, 200, {
+			ok: true,
+			chart: router.usage.chart(period)
+		});
+	});
+	route(`${ROUTER_API_BASE}/stats/clear`, async (req, res) => {
+		if (req.method !== "POST") {
+			writeJson(res, 405, {
+				ok: false,
+				error: "method not allowed"
+			});
+			return;
+		}
+		router.usage.clear();
+		writeJson(res, 200, { ok: true });
+	});
 	if (ctx.llm !== void 0) {
 		const LLM_NS = "llm-dsh-router";
 		try {