dsh-router-core 0.2.0 → 0.3.1

package/lib/index.js

@@ -171,10 +171,22 @@ var AccountPool = class {
 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);
@@ -190,9 +202,21 @@ var SupplierConfigStore = class {
 		}
 		return cfg;
 	}
+	/**
+	* 设置别名。别名必须唯一——它是对外模型全名的前缀（alias/model），
+	* 请求时用别名反查供应商，重复就会指错人。空别名表示用供应商 id（默认值）。
+	* @returns 冲突时返回占用的供应商 id
+	*/
 	setAlias(supplierId, alias) {
-		this.get(supplierId).alias = 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);
@@ -261,6 +285,597 @@ var SupplierConfigStore = class {
 	}
 };
 //#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/* 处理。
@@ -309,39 +924,252 @@ function sinkRes() {
 	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) {
-	if (!r.ok) return;
+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;
+		return true;
 	}
-	res.writeHead(200, {
-		"Content-Type": "text/event-stream",
-		"Cache-Control": "no-cache",
-		Connection: "keep-alive",
-		"X-Accel-Buffering": "no"
+	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);
 	});
-	if (typeof res.flushHeaders === "function") res.flushHeaders();
 	const onError = () => {
 		res.destroy();
 	};
 	res.once("error", onError);
 	try {
-		await r.stream.pipeTo(new WritableStream({ write: (chunk) => new Promise((resolve) => {
-			if (res.write(chunk)) resolve();
-			else res.once("drain", resolve);
-		}) }));
+		await normalizeSSEStream(tapped?.stream ?? r.stream).pipeTo(new WritableStream({ write: writeChunk }));
 	} catch {} finally {
 		res.removeListener("error", onError);
-		res.end();
+		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) {
@@ -364,11 +1192,25 @@ var Router = class {
 	store;
 	/** 模型列表缓存（supplierId → 模型 + 拉取时间）。插件只管拉，不缓存。 */
 	modelsCache = /* @__PURE__ */ new Map();
-	constructor(stateFile = "", store) {
+	/** 请求日志出口（面板/宿主 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 {
@@ -376,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) => {
+					if (m.indexOf(",") > 0) return m;
 					const slash = m.indexOf("/");
-					return slash >= 0 ? m.slice(slash + 1) : m;
+					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,
@@ -402,6 +1249,7 @@ 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) {
@@ -521,11 +1369,20 @@ var Router = class {
 	*  只剥「已知 alias + /」开头的前缀——模型 id 本身可以含斜杠
 	*  （如 nvidia 的 `deepseek-ai/deepseek-v4-flash-0731`），用 lastIndexOf 会把
 	*  命名空间一起吃掉，后面请求必然 404。 */
+	/**
+	* 归一组合模型名为存储格式 `supplierId,modelId`。
+	* 面板提交的是「供应商 id + 模型 id」两两组合（或旧数据的裸 id），
+	* 这里只做清理与校验，不再剥掉前缀——精准调用靠的就是供应商 id。
+	*/
 	normalizeModelIds(models) {
-		const aliases = this.suppliers.map((s) => s.getAlias()).filter((a) => a !== "");
-		return models.map((m) => {
-			const prefix = aliases.find((a) => m.startsWith(`${a}/`));
-			return prefix === void 0 ? m : m.slice(prefix.length + 1);
+		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）。 */
@@ -624,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;
@@ -631,39 +1516,91 @@ 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;
 		}
-		if (await this.chatWithModel(req, res, req.model)) 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 this.chatWithSupplier(s, 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 处置 → 失败换号；写响应只在成功后发生。
 	*
-	* 流式一旦写出响应头就绑死（上游协议如此，9router 同样如此），所以
-	* 「拿到 ok:true 的流」即视为该账号成功，之后出错不再换号——要能回退
-	* 就得在写头前缓冲判定，代价是首字节延迟，目前未做。
+	* 流式**推迟到第一个字节才写响应头**，所以「上游刚连上就断」这种情况
+	* 还能换号重试；一旦写出第一个字节就绑死（HTTP 语义，9router 同样如此），
+	* 之后出错不再换号——要彻底能回退就得在写头前缓冲判定，代价是首字节
+	* 延迟，目前未做。
 	*/
-	async chatWithSupplier(s, req, res) {
+	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) {
@@ -673,8 +1610,13 @@ var Router = class {
 				pool.noteFailure("", r.state, r.message);
 				return false;
 			}
-			await writeChatResult(res, r);
-			return true;
+			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 (;;) {
@@ -683,13 +1625,30 @@ var Router = class {
 			tried.add(uid);
 			const r = await s.chatOnce(uid, req);
 			if (!r.ok) {
-				if (r.state === "no_such_model") return false;
+				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);
-			await writeChatResult(res, r);
-			return true;
+			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";
+			}
 		}
 	}
 	/** 测试某供应商的某模型是否可用。
@@ -735,6 +1694,7 @@ var Router = class {
 	dispose() {
 		for (const s of this.suppliers) s.dispose();
 		this.suppliers = [];
+		this.usage.flush();
 	}
 };
 //#endregion
@@ -834,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++,
@@ -859,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",
@@ -945,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");
 }
@@ -1039,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
@@ -1236,7 +2200,7 @@ 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],
 		accounts: () => instance.status().accounts,
 		chatOnce: (uid, req) => instance.chatOnce(uid, req),
@@ -1377,14 +2341,21 @@ function supplierRoutes(base, loaded, store, router) {
 		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 });
 		}
 	});
@@ -1762,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, store);
+	const router = new Router(stateFile, store, log);
 	const keys = new KeysStore(stateFile);
 	const disposers = [];
 	const route = (path, handler) => {
@@ -2071,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 {