dsh-router-core 0.3.2 → 0.3.4

package/lib/index.js

@@ -1,6 +1,6 @@
 import { basename, dirname, join } from "node:path";
 import { mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
-import { CallId, EMPTY_RESPONSE_CODE, LlmAdapter, LlmError } from "@deepseek-ai/dsh-llm";
+import { CallId, EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, attributionHeaders } from "@deepseek-ai/dsh-llm";
 import { randomBytes } from "node:crypto";
 import { pathToFileURL } from "node:url";
 import { DatabaseSync } from "node:sqlite";
@@ -14,159 +14,250 @@ const API_KEY_REF = "TW2A_API_KEY";
 const MINUTE = 6e4;
 /**
 * 状态 → 处置表。**核心策略就在这一张表里**，插件只报状态不做决策。
-* 时长参考 9router 的 errorConfig（限流类短冷却、额度类长冷却），
-* 但 9router 按文本/状态匹配，这里按插件解读后的语义状态匹配，更准。
+*
+* 冷却策略对齐 9router 的 accountFallback / errorConfig：
+*  - `rate_limit` 用**指数退避**（9router 的 `backoff: true`）：偶发限流只
+*    短冷，持续限流越退越久，比固定 1 分钟两头不讨好要准。
+*  - 未知/瞬时错误用**瞬时短冷却**（9router 默认分支 TRANSIENT_COOLDOWN_MS）：
+*    每次失败都冻结，坏号不会留在池里被下一个请求再选中。
+*
+* 与 9router 的差别：9router 按错误文本/HTTP 状态匹配，这里按插件解读后的
+* 语义状态匹配 —— 插件已经把 11133/11134 这类网关噪声归成 `rate_limit`，
+* 核心不必再猜文本，更准。
 */
 const RULES = {
 	ok: {
-		cooldownMs: 0,
+		cooldown: 0,
 		disable: false,
 		counts: false
 	},
 	rate_limit: {
-		cooldownMs: 1 * MINUTE,
+		cooldown: "backoff",
 		disable: false,
 		counts: false
 	},
 	quota: {
-		cooldownMs: 10 * MINUTE,
+		cooldown: 10 * MINUTE,
 		disable: false,
 		counts: false
 	},
 	session_dead: {
-		cooldownMs: 0,
+		cooldown: 0,
 		disable: true,
 		counts: false
 	},
 	unavailable: {
-		cooldownMs: 0,
+		cooldown: "transient",
 		disable: false,
-		counts: true
+		counts: false
 	},
 	transport: {
-		cooldownMs: 0,
+		cooldown: "transient",
 		disable: false,
-		counts: true
+		counts: false
 	},
 	unknown: {
-		cooldownMs: 0,
+		cooldown: "transient",
 		disable: false,
-		counts: true
+		counts: false
 	},
 	no_such_model: {
-		cooldownMs: 0,
+		cooldown: 0,
 		disable: false,
 		counts: false
 	}
 };
-/** 连续错误攒够这么多次就自动冷却（防止坏号被反复重试）。 */
-const ERR_THRESHOLD = 3;
-/** 攒够后的冷却时长。 */
-const ERR_COOLDOWN_MS = 10 * MINUTE;
+/**
+* 瞬时/未知错误的冷却时长 —— 对齐 9router 的 TRANSIENT_COOLDOWN_MS。
+* 取短值：这类错误大多是偶发的上游抖动，冷太久会把好号白白关掉；
+* 但**必须冷**，否则坏号留在池里，每个请求都要先撞一次才知道它坏了。
+* （现在按 (模型, 号) 记，只关这一个号在这个模型上的可用性。）
+*/
+const TRANSIENT_COOLDOWN_MS = 3e4;
+/** 限流退避：首次 2s，每次翻倍，上限 5 分钟（对齐 9router BACKOFF_CONFIG）。 */
+const BACKOFF_BASE_MS = 2e3;
+const BACKOFF_MAX_MS = 5 * MINUTE;
+const BACKOFF_MAX_LEVEL = 15;
+/** 指数退避：等级 1 = BACKOFF_BASE_MS，每级翻倍，封顶 BACKOFF_MAX_MS。 */
+function backoffMs(level) {
+	return Math.min(BACKOFF_BASE_MS * 2 ** Math.max(0, level - 1), BACKOFF_MAX_MS);
+}
+/** 冷却键分隔符：模型 id 本身可含 `/` `,`，用不可见控制符隔离最稳。 */
+const SEP = "\0";
 var AccountPool = class {
-	entries = /* @__PURE__ */ new Map();
+	/** 本池所属供应商（loader 每供应商一个实例；键里带上，跨供应商同名模型不串）。 */
+	supplierId;
+	/** (supplier, model, uid) → 冷却/退避。 */
+	cooldowns = /* @__PURE__ */ new Map();
+	/** uid → 连接级禁用 / 手动暂停。 */
+	byUid = /* @__PURE__ */ new Map();
 	rrCursor = 0;
-	entry(uid) {
-		let e = this.entries.get(uid);
+	constructor(supplierId = "") {
+		this.supplierId = supplierId;
+	}
+	key(model, uid) {
+		return `${this.supplierId}${SEP}${model}${SEP}${uid}`;
+	}
+	entry(model, uid) {
+		const k = this.key(model, uid);
+		let e = this.cooldowns.get(k);
+		if (!e) {
+			e = {
+				until: 0,
+				backoffLevel: 0,
+				reason: ""
+			};
+			this.cooldowns.set(k, e);
+		}
+		return e;
+	}
+	/** 某连接整体状态（禁用/手动暂停）。 */
+	uidState(uid) {
+		let e = this.byUid.get(uid);
 		if (!e) {
 			e = {
 				until: 0,
 				disabled: false,
-				errCount: 0,
 				reason: ""
 			};
-			this.entries.set(uid, e);
+			this.byUid.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;
+	/** 该连接是否被禁用 / 手动整连接暂停中（跨模型生效）。 */
+	uidBlocked(uid, now) {
+		const e = this.byUid.get(uid);
+		if (!e) return {
+			blocked: false,
+			disabled: false
+		};
+		if (e.disabled) return {
+			blocked: true,
+			disabled: true
+		};
+		if (e.until > now) return {
+			blocked: true,
+			disabled: false
+		};
+		return {
+			blocked: false,
+			disabled: false
+		};
 	}
 	/**
-	* 按策略选一个健康账号。
+	* 给定要试的模型，该连接是否可服务：
+	*  - 未被连接级禁用/手动暂停（跨模型）；
+	*  - 且此 (supplier, model, uid) 冷却单元不在冷却中。
+	*/
+	healthy(uid, model, now) {
+		if (this.uidBlocked(uid, now).blocked) return false;
+		const c = this.cooldowns.get(this.key(model, uid));
+		if (!c) return true;
+		return c.until <= now;
+	}
+	/**
+	* 按策略为「某个模型」选一个健康账号。
 	* @param accounts 插件报告的「现在状态」（顺序即插件的自然顺序）
 	* @param poolOrder 用户在面板拖出来的顺序（核心管）
+	* @param strategy fallback 取第一个健康 / round-robin 轮转健康号
+	* @param modelId 当前要路由的模型（决定查哪个 (model, uid) 冷却单元）
 	* @returns 选中的 uid；无健康账号返回 undefined
 	*/
-	pick(accounts, poolOrder, strategy) {
+	pick(accounts, poolOrder, strategy, modelId) {
 		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));
+		const healthy = [...poolOrder.filter((uid) => byUid.has(uid)), ...accounts.map((a) => a.uid).filter((uid) => !poolOrder.includes(uid))].filter((uid) => this.healthy(uid, modelId, now));
 		if (healthy.length === 0) return void 0;
 		if (strategy !== "round-robin") return healthy[0];
 		const uid = healthy[this.rrCursor % healthy.length];
 		this.rrCursor = (this.rrCursor + 1) % healthy.length;
 		return uid;
 	}
-	/** 记录一次失败：按状态处置（冷却/禁用/错误累计）。 */
-	noteFailure(uid, state, message) {
+	/** 记录一次失败：按状态处置（冷却/禁用/退避），落在「(模型, 连接)」这个冷却单元上。 */
+	noteFailure(uid, modelId, state, message) {
 		const rule = RULES[state];
-		const e = this.entry(uid);
 		if (rule.disable) {
+			const e = this.uidState(uid);
 			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;
+		if (rule.cooldown === 0) return;
+		const e = this.entry(modelId, uid);
+		e.reason = message;
+		if (rule.cooldown === "backoff") {
+			e.backoffLevel = Math.min(e.backoffLevel + 1, BACKOFF_MAX_LEVEL);
+			e.until = Math.max(e.until, Date.now() + backoffMs(e.backoffLevel));
 			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;
-			}
+		if (rule.cooldown === "transient") {
+			e.until = Math.max(e.until, Date.now() + TRANSIENT_COOLDOWN_MS);
+			return;
 		}
+		e.until = Math.max(e.until, Date.now() + rule.cooldown);
 	}
-	/** 记录一次成功：清零连续错误。 */
-	noteSuccess(uid) {
-		const e = this.entries.get(uid);
-		if (e) e.errCount = 0;
+	/** 记录一次成功：清零「该模型」的限流退避等级（好号不背历史惩罚）。不解除禁用。 */
+	noteSuccess(uid, modelId) {
+		const e = this.cooldowns.get(this.key(modelId, uid));
+		if (e) e.backoffLevel = 0;
 	}
-	/** 手动冷却（面板/管理用途）。 */
+	/** 手动暂停整连接（面板/管理用途，跨模型）。ms<=0 表示解除。 */
 	cooldown(uid, ms, reason) {
-		const e = this.entry(uid);
+		const e = this.uidState(uid);
 		e.until = Date.now() + ms;
 		e.reason = reason;
-		e.errCount = 0;
+		for (const [k, ce] of this.cooldowns) if (k.endsWith(`${SEP}${uid}`)) ce.backoffLevel = 0;
 	}
-	/** 把核心的冷却/禁用/错误累计叠加到插件报告的「现在状态」上，产出面板态。 */
-	decorate(accounts) {
+	/** 把核心的冷却/禁用叠加到插件报的「现在状态」上，产出面板态。
+	*
+	* 冷却现在是 (模型, 连接) 粒度的，而面板状态没有「当前模型」上下文，
+	* 这里默认**聚合**：只要该连接在任一模型上有活跃冷却，就显示 cooling=true
+	* （reason 带上具体模型），并在 `until` 给最长者。真实路由用 `pick` 的
+	* 模型级判定，不受此展示聚合影响。传 modelId 可只按该模型判定。
+	*/
+	decorate(accounts, modelId) {
 		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;
+			const u = this.byUid.get(a.uid);
+			const disabled = u?.disabled ?? false;
+			const manualCooling = u !== void 0 && !u.disabled && u.until > now;
+			let cooling = manualCooling;
+			let maxUntil = manualCooling ? u.until : 0;
+			let reason = manualCooling ? u.reason : void 0;
+			let err = 0;
+			for (const [k, ce] of this.cooldowns) {
+				if (!k.endsWith(`${SEP}${a.uid}`)) continue;
+				if (modelId !== void 0) {
+					const prefix = `${this.supplierId}${SEP}${modelId}${SEP}`;
+					if (!k.startsWith(prefix)) continue;
+				}
+				if (ce.until > now) {
+					cooling = true;
+					if (ce.until > maxUntil) {
+						maxUntil = ce.until;
+						reason = ce.reason;
+					}
+				}
+				if (ce.backoffLevel > err) err = ce.backoffLevel;
+			}
 			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
+				disabled,
+				err_count: err,
+				until: cooling && maxUntil > 0 ? new Date(maxUntil).toISOString() : void 0,
+				reason: reason !== void 0 && reason !== "" ? reason : void 0
 			};
 		});
 	}
 };
-//#endregion
-//#region src/supplier-config.ts
-/**
-* 通用供应商配置 —— dsh-router 核心能力,按供应商 id 存储。
-*
-* 通用能力(所有供应商共享,供应商 js 不需要实现)：
-*   - 别名 alias(前缀,模型全名 = alias/id)
-*   - 模型管理:启用/禁用 disabled、自定义 custom
-*   - 连接池:poolOrder(拖动排序)、poolStrategy(回退/轮询)
-*
-* 持久化到 data/supplier-config.json。
-*/
+/** 读盘时的积分字段校验：只留有限非负数（负数一律当没缓存过）。 */
+function readCredits(raw) {
+	const out = {};
+	if (typeof raw !== "object" || raw === null) return out;
+	for (const [uid, v] of Object.entries(raw)) if (typeof v === "number" && Number.isFinite(v) && v >= 0) out[uid] = v;
+	return out;
+}
 /** 通用供应商配置存储。 */
 var SupplierConfigStore = class {
 	fp = "";
@@ -196,7 +287,8 @@ var SupplierConfigStore = class {
 				disabled: [],
 				custom: [],
 				poolOrder: [],
-				poolStrategy: "fallback"
+				poolStrategy: "fallback",
+				credits: {}
 			};
 			this.bySupplier.set(supplierId, cfg);
 		}
@@ -248,6 +340,32 @@ var SupplierConfigStore = class {
 		this.get(supplierId).poolStrategy = strategy;
 		this.saveLocked();
 	}
+	/**
+	* 读缓存的积分。没缓存过返回 `CREDITS_UNKNOWN`(-1),让调用方自己决定
+	* 显示什么——不要把 -1 当 0 展示。
+	*/
+	getCredits(supplierId, uid) {
+		const v = this.get(supplierId).credits[uid];
+		return typeof v === "number" && Number.isFinite(v) ? v : -1;
+	}
+	/**
+	* 合并插件报的积分:非 -1 就写入并返回它;-1(未知)则回落到上次缓存值。
+	* @returns 面板该显示的积分(仍可能是 -1 = 从来没拿到过)
+	*/
+	putCredits(supplierId, uid, reported) {
+		if (typeof reported !== "number" || !Number.isFinite(reported) || reported < 0) return this.getCredits(supplierId, uid);
+		if (this.getCredits(supplierId, uid) === reported) return reported;
+		this.get(supplierId).credits[uid] = reported;
+		this.saveLocked();
+		return reported;
+	}
+	/** 删除链接时清掉它的积分缓存(不写盘:下一行 removeLink 会带出保存)。 */
+	clearCredits(supplierId, uid) {
+		const credits = this.get(supplierId).credits;
+		if (credits[uid] === void 0) return;
+		delete credits[uid];
+		this.saveLocked();
+	}
 	load() {
 		if (this.fp === "") return;
 		let f;
@@ -261,7 +379,8 @@ var SupplierConfigStore = class {
 			disabled: Array.isArray(c.disabled) ? c.disabled.filter((m) => typeof m === "string") : [],
 			custom: Array.isArray(c.custom) ? c.custom.filter((m) => typeof m === "string") : [],
 			poolOrder: Array.isArray(c.poolOrder) ? c.poolOrder.filter((u) => typeof u === "string") : [],
-			poolStrategy: c.poolStrategy === "round-robin" ? "round-robin" : "fallback"
+			poolStrategy: c.poolStrategy === "round-robin" ? "round-robin" : "fallback",
+			credits: readCredits(c.credits)
 		});
 	}
 	saveLocked() {
@@ -272,7 +391,8 @@ var SupplierConfigStore = class {
 			disabled: [...cfg.disabled],
 			custom: [...cfg.custom],
 			poolOrder: [...cfg.poolOrder],
-			poolStrategy: cfg.poolStrategy
+			poolStrategy: cfg.poolStrategy,
+			credits: { ...cfg.credits }
 		};
 		try {
 			const dir = dirname(this.fp);
@@ -293,24 +413,46 @@ var SupplierConfigStore = class {
 * 落盘**而不是 SQLite：dsh-router 现有持久化全是 JSON（supplier-config.json /
 * keys.json），不为一个看板引入数据库依赖。
 *
-* 两条查询路径（照 9router `getUsageStats` 的 `useDailySummary` 分叉）：
-*   - `today` / `24h` → 走**明细环**（滚动窗口，天桶是自然日，对不上）
-*   - `7d` / `30d`   → 走**天桶**（长期精确，不受明细环容量限制）
+* 统计口径（不再走明细环 —— 见下面「天花板」）：
+*   - `today`      → 走**天桶**（今天这一桶就是答案，天然精确）
+*   - `24h`        → 走**小时桶**（滚动窗口，天桶是自然日，对不上）
+*   - `7d` / `30d` → 走**天桶**（长期精确）
 *
 * 天花板（JSON 的代价，刻意接受）：
-*   - 明细环只留最近 `RING_CAP` 条。超量时 today/24h 会**少算**（天桶不会，
-*     所以 7d/30d 永远准）。要彻底准就把明细也落盘成按小时的桶，届时
-*     `chart()` 的小时桶直接读它即可，接口不用变。
+*   - 明细环 `recent[]` 只留最近 `RING_CAP` 条，**只服务「最近请求列表」**，
+*     不参与任何统计。历史上 today/24h 直接扫它，单日超 500 条就被静默截断，
+*     于是出现「今日 500 / 7 天 1621」这种自相矛盾的数字——现在不会了。
+*   - **小时桶只从新数据开始累积**：升级前落的盘没有小时粒度，而明细环只剩
+*     最近 500 条、回溯不回去，所以那段历史的**天内分布是永久缺失的**。
+*     影响面：①`24h` 遇到「小时粒度不齐」的自然日 → 整桶计入（宁可多算，
+*     也不显示一个比「今日」还小的荒唐数字）；②`today`/`24h` 的小时柱状图
+*     那几格是空的（不编数据）。天桶口径（today/7d/30d）完全不受影响，
+*     新数据立刻就有小时粒度，隔天起图表全正常。
 *   - 天桶保留 30 天（9router 有 SQLite 不 prune，JSON 撑不住，得自己限）
 *   - 落盘防抖 2s：进程被 kill 最多丢 2s 的计数。看板不是账本，可接受；
 *     要严格就改成立即写，代价是每个请求一次磁盘写。
 */
-/** 明细环容量：够 today/24h 看，又不至于让 JSON 无限长。 */
+/** 明细环容量：只喂「最近请求列表」，跟统计口径无关了。 */
 const RING_CAP = 500;
+/** 一天几格（小时桶定长；要更细的精度就把这个值放大）。 */
+const HOURS = 24;
 /** 天桶保留天数。 */
 const KEEP_DAYS = 30;
 /** 落盘防抖。 */
 const SAVE_DEBOUNCE_MS = 2e3;
+const emptyHour = () => ({
+	requests: 0,
+	ok: 0,
+	failed: 0,
+	promptTokens: 0,
+	completionTokens: 0,
+	cachedTokens: 0,
+	durationMs: 0,
+	ttfbMs: 0,
+	ttfbCount: 0,
+	estimatedInputs: 0,
+	estimatedOutputs: 0
+});
 const emptyDay = () => ({
 	requests: 0,
 	ok: 0,
@@ -323,6 +465,7 @@ const emptyDay = () => ({
 	ttfbCount: 0,
 	estimatedInputs: 0,
 	estimatedOutputs: 0,
+	hours: Array.from({ length: HOURS }, () => emptyHour()),
 	bySupplier: {},
 	byModel: {},
 	byRequested: {}
@@ -343,7 +486,7 @@ function localDateKey(ts) {
 	return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
 }
 /** 用量存储。stateFile 为空时纯内存（测试用），不落盘。 */
-var UsageStore = class {
+var UsageStore = class UsageStore {
 	fp = "";
 	days = /* @__PURE__ */ new Map();
 	recent = [];
@@ -394,6 +537,22 @@ var UsageStore = class {
 		}
 		if (rec.inputEstimated) day.estimatedInputs += 1;
 		if (rec.outputEstimated) day.estimatedOutputs += 1;
+		const h = day.hours[new Date(ts).getHours()];
+		if (h !== void 0) {
+			h.requests += 1;
+			if (rec.ok) h.ok += 1;
+			else h.failed += 1;
+			h.promptTokens += promptTokens;
+			h.completionTokens += completionTokens;
+			h.cachedTokens += rec.cachedTokens;
+			h.durationMs += rec.durationMs;
+			if (rec.ttfbMs > 0) {
+				h.ttfbMs += rec.ttfbMs;
+				h.ttfbCount += 1;
+			}
+			if (rec.inputEstimated) h.estimatedInputs += 1;
+			if (rec.outputEstimated) h.estimatedOutputs += 1;
+		}
 		this.bump(day.bySupplier, rec.supplier, rec);
 		this.bump(day.byModel, rec.model, rec);
 		this.bump(day.byRequested, rec.requested, rec);
@@ -414,24 +573,71 @@ var UsageStore = class {
 		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);
+	/**
+	* 从 `first` 起的 24 个小时格：每格带整点时间戳、所属自然日、那天的数据。
+	*
+	* `today` 传今天 00:00，`24h` 传「当前整点往前 23 格」。
+	* 跨天一律靠 `localDateKey(start)` 现算，不用「减 N 小时」去猜天数：
+	* 本地时区（尤其 DST）下小时偏移和自然日不是一回事，算错就漏一整天。
+	*/
+	hourSlots(first) {
+		const out = [];
+		for (let i = 0; i < HOURS; i += 1) {
+			const start = first + i * 36e5;
+			const dayKey = localDateKey(start);
+			const day = this.days.get(dayKey);
+			out.push({
+				dayKey,
+				start,
+				day,
+				b: day?.hours[new Date(start).getHours()]
+			});
+		}
+		return out;
+	}
+	/** 今天的小时格起点（自然日零点）。 */
+	static dayStartOf(now) {
+		return new Date(now).setHours(0, 0, 0, 0);
+	}
+	/** 24h 滚动窗口的小时格起点（当前整点往前 23 格）。 */
+	static rollingStartOf(now) {
+		const c = new Date(now);
+		c.setMinutes(0, 0, 0);
+		return c.getTime() - 828e5;
+	}
+	/**
+	* 一整天的小时桶是否齐（各格之和 >= 天桶计数）。
+	*
+	* 不齐 = 这天是升级前落的盘（没有小时粒度）→ 24h 窗口踩到它就只能整桶计入。
+	* 宁可多算窗口外那截，也不能报一个比「今日」还小的数。
+	*/
+	static hoursComplete(d) {
+		return d.hours.reduce((n, h) => n + h.requests, 0) >= d.requests;
 	}
 	/** 汇总 + Top 榜。 */
 	stats(period, now = Date.now()) {
-		if (period === "today" || period === "24h") {
-			const rows = this.inWindow(period, now);
+		if (period === "today") {
+			const d = this.days.get(localDateKey(now));
+			const acc = emptyAcc();
+			if (d === void 0) return finish(acc, {}, {}, {}, this.lifetime);
+			addDay(acc, d);
+			return finish(acc, d.bySupplier, d.byModel, d.byRequested, this.lifetime);
+		}
+		if (period === "24h") {
+			const slots = this.hourSlots(UsageStore.rollingStartOf(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);
+			for (const key of new Set(slots.map((s) => s.dayKey))) {
+				const d = this.days.get(key);
+				if (d === void 0) continue;
+				if (UsageStore.hoursComplete(d)) {
+					for (const s of slots) if (s.dayKey === key && s.b !== void 0) addHour(acc, s.b);
+				} else addDay(acc, d);
+				mergeInto(bySupplier, d.bySupplier);
+				mergeInto(byModel, d.byModel);
+				mergeInto(byRequested, d.byRequested);
 			}
 			return finish(acc, bySupplier, byModel, byRequested, this.lifetime);
 		}
@@ -443,40 +649,23 @@ var UsageStore = class {
 		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;
+			addDay(acc, d);
 			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 = 天桶。 */
+	/** 柱状图数据：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
+			const p = (n) => String(n).padStart(2, "0");
+			const first = period === "today" ? UsageStore.dayStartOf(now) : UsageStore.rollingStartOf(now);
+			return this.hourSlots(first).map((s) => ({
+				label: `${p(new Date(s.start).getHours())}:00`,
+				requests: s.b?.requests ?? 0,
+				tokens: (s.b?.promptTokens ?? 0) + (s.b?.completionTokens ?? 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 = [];
@@ -524,10 +713,17 @@ var UsageStore = class {
 			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
-			});
+			for (const [k, d] of this.days) {
+				const day = {
+					...emptyDay(),
+					...d
+				};
+				day.hours = Array.from({ length: HOURS }, (_, i) => ({
+					...emptyHour(),
+					...d.hours?.[i]
+				}));
+				this.days.set(k, day);
+			}
 		} catch {}
 	}
 	save() {
@@ -561,32 +757,33 @@ const emptyAcc = () => ({
 	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;
+/** 天桶累加（today / 7d / 30d 路径，以及 24h 的「老数据整桶兜底」）。 */
+function addDay(acc, d) {
+	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;
 }
-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;
+/** 小时桶累加（24h 路径）。 */
+function addHour(acc, h) {
+	acc.requests += h.requests;
+	acc.ok += h.ok;
+	acc.failed += h.failed;
+	acc.promptTokens += h.promptTokens;
+	acc.completionTokens += h.completionTokens;
+	acc.cachedTokens += h.cachedTokens;
+	acc.durationMs += h.durationMs;
+	acc.ttfbMs += h.ttfbMs;
+	acc.ttfbCount += h.ttfbCount;
+	acc.estimatedInputs += h.estimatedInputs;
+	acc.estimatedOutputs += h.estimatedOutputs;
 }
 function finish(acc, bySupplier, byModel, byRequested, lifetime) {
 	return {
@@ -882,8 +1079,15 @@ function withEstimates(usage, requestChars, outputChars) {
 * 仿 9router：组合 = 一组模型，请求 model 命中组合名时，按策略
 * （fallback 顺序尝试 / round-robin 轮转）选中一个模型路由。
 */
-/** 模型列表缓存有效期。 */
-const MODELS_TTL_MS = 6e4;
+/**
+* 模型列表缓存有效期。
+*
+* 取 10 分钟而不是 60s：模型列表本来很少变（上游上新/下线才动），而每次
+* TTL 过期都会穿透到插件真打一次上游——实测冷路径 0.3~1.0s/供应商，组合页
+* 取最慢那家就是 1s+ 的白屏。拉长 TTL 直接把这个穿透频率降一个量级；真要
+* 立刻看新模型，点「获取模型」走 force 即可。
+*/
+const MODELS_TTL_MS = 6e5;
 function openAIError(code, msg) {
 	return { error: {
 		message: msg,
@@ -898,6 +1102,33 @@ function writeJson$2(res, status, body) {
 	});
 	res.end(JSON.stringify(body));
 }
+/**
+* 剥掉本供应商自己的 alias 前缀（只剥一层，且只认完整 `alias/` 开头）。
+*
+* 为什么不能用 lastIndexOf：模型 id 本身可以含斜杠（nvidia 的
+* `deepseek-ai/deepseek-v4-flash-0731`），剥最后一段会把命名空间吃掉，
+* 后面请求必然 404。只认「已知 alias + /」开头，其他原样返回。
+*
+* 注意：核心**只在记统计名时**用它。传给插件的 model 全名保持原样——
+* 剥前缀是插件自己的事（各供应商插件都有一份同名实现）。
+*/
+function stripAlias(model, alias) {
+	return alias !== "" && model.startsWith(`${alias}/`) ? model.slice(alias.length + 1) : model;
+}
+/**
+* 组合降级前的「喘口气」等待：瞬时故障给上游一个恢复窗口再换下一个模型。
+*
+* 学 9router combo.js 的同名处理（注释原话：fixes: combo falls through on
+* transient 503）—— 过载的上游往往几百毫秒内就恢复，立刻换下一个模型会
+* 让整个组合在几毫秒内被打穿，最后全灭返回 503。
+*
+* 只对**瞬时**故障等：连接层失败 / 上游不可用（对应 9router 的 502/503/504）。
+* 模型不属于本供应商（no_such_model）绝不能等 —— 它不是故障，等纯属浪费。
+*/
+const TRANSIENT_SETTLE_MS = 2e3;
+function isTransient(state) {
+	return state === "transport" || state === "unavailable";
+}
 /** 丢弃响应的假 ServerResponse（测试模型用：记录状态+内容，用于判定成败）。 */
 function sinkRes() {
 	let status = 200;
@@ -1028,7 +1259,9 @@ async function aggregateSSE(stream) {
 	return JSON.stringify(body);
 }
 /**
-* 流式 SSE 逐帧归一化：剥掉上游多发一次的**空** tool_call 字段。
+* 流式 SSE 逐帧归一化：剥掉上游多发一次的**空** tool_call 字段，
+* 并记住上游有没有发终止帧（`data: [DONE]`）—— 断流时核心要据此补发，
+* 见 `writeChatResult`。
 *
 * 为什么必须做：CodeBuddy 上游的工具调用第二个 delta 会**显式发空串**
 *   `{"function":{"name":"","arguments":"{...}"},"index":0}`（以及 `"id":""`）。
@@ -1047,26 +1280,38 @@ 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)));
+	let sawDone = false;
+	return {
+		stream: 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);
+						if (isDoneFrame(frame)) sawDone = true;
+						ctrl.enqueue(enc.encode(fixFrame(frame)));
+					}
+				}
+				if (buf !== "") {
+					if (isDoneFrame(buf)) sawDone = true;
+					ctrl.enqueue(enc.encode(fixFrame(buf)));
 				}
+			} finally {
+				reader.releaseLock();
 			}
-			if (buf !== "") ctrl.enqueue(enc.encode(fixFrame(buf)));
-		} finally {
-			reader.releaseLock();
-		}
-		ctrl.close();
-	} });
+			ctrl.close();
+		} }),
+		sawDone: () => sawDone
+	};
+}
+/** 一帧 SSE 里有没有终止帧（宽松匹配：跨 chunk 的残留尾帧也认）。 */
+function isDoneFrame(frame) {
+	return /(^|\n)data:[ \t]*\[DONE\][ \t]*(\n|$)/.test(frame);
 }
 /** 修一帧 SSE：只剥空的 name/id，出任何问题都原样返回。 */
 function fixFrame(frame) {
@@ -1108,6 +1353,9 @@ function fixFrame(frame) {
 * 先写头就等于把自己锁死在这一个账号上，组合就没法回退了——而客户端只拿到
 * 一个空/截断的 SSE，表现为工具调用名是空串（`unknown tool ""`）。
 *
+* 截断时**补发终止帧**（见末尾 finally）：客户端严格等 `[DONE]`，缺了就
+* 整轮判失败，已流式吐出的内容全废。
+*
 * 天花板：一旦写出第一个字节就绑死（HTTP 语义），中途断流只能截断，
 * 不能回退。要彻底解决得在写头前缓冲判定，代价是首字节延迟——未做。
 */
@@ -1139,7 +1387,13 @@ async function writeChatResult(res, r, wantsStream, probe, startedAt = 0) {
 	}
 	const tapped = probe === void 0 ? void 0 : tapStreamUsage(r.stream, startedAt);
 	let wroteAny = false;
+	/** 响应已死（客户端断开/res 已销毁）：等 drain 的写入要立刻放弃，别吊死。 */
+	let dead = false;
 	const writeChunk = (chunk) => new Promise((resolve) => {
+		if (dead) {
+			resolve();
+			return;
+		}
 		if (!wroteAny) {
 			res.writeHead(200, {
 				"Content-Type": "text/event-stream",
@@ -1151,16 +1405,25 @@ async function writeChatResult(res, r, wantsStream, probe, startedAt = 0) {
 			wroteAny = true;
 		}
 		if (res.write(chunk)) resolve();
-		else res.once("drain", resolve);
+		else {
+			const onDrain = () => {
+				res.removeListener("error", onDrain);
+				resolve();
+			};
+			res.once("drain", onDrain);
+		}
 	});
 	const onError = () => {
+		dead = true;
 		res.destroy();
 	};
 	res.once("error", onError);
+	const norm = normalizeSSEStream(tapped?.stream ?? r.stream);
 	try {
-		await normalizeSSEStream(tapped?.stream ?? r.stream).pipeTo(new WritableStream({ write: writeChunk }));
+		await norm.stream.pipeTo(new WritableStream({ write: writeChunk }));
 	} catch {} finally {
 		res.removeListener("error", onError);
+		if (wroteAny && !norm.sawDone() && !dead && !res.writableEnded && !res.destroyed) await writeChunk(DONE_FRAME);
 		if (wroteAny) res.end();
 		if (probe !== void 0 && tapped !== void 0) {
 			const got = await tapped.done();
@@ -1171,6 +1434,8 @@ async function writeChatResult(res, r, wantsStream, probe, startedAt = 0) {
 	}
 	return wroteAny;
 }
+/** SSE 终止帧（断流兜底补发用）。 */
+const DONE_FRAME = new TextEncoder().encode("data: [DONE]\n\n");
 /** 从上游响应体提取错误信息（OpenAI {error:{message}} 或 {code,msg}/{message}）。 */
 function extractUpstreamError(body) {
 	try {
@@ -1192,6 +1457,11 @@ var Router = class {
 	store;
 	/** 模型列表缓存（supplierId → 模型 + 拉取时间）。插件只管拉，不缓存。 */
 	modelsCache = /* @__PURE__ */ new Map();
+	/**
+	* 正在拉模型的供应商 → in-flight promise。
+	* 组合页会同时从多个入口触发同一个供应商的刷新，不去重上游就被按 N 倍打。
+	*/
+	modelsInflight = /* @__PURE__ */ new Map();
 	/** 请求日志出口（面板/宿主 logger）。 */
 	log;
 	/** 用量统计（概览看板）。 */
@@ -1301,40 +1571,74 @@ var Router = class {
 	* 取某供应商的模型（核心统一缓存）。
 	*
 	* 模型列表只在这里缓存一次：`/suppliers/:id/models`（供应商详情）和
-	* `/combos`（组合加模型）共用。组合面板**不主动打上游**——它只是读缓存，
-	* 冷启动（缓存还没建）时才拉一次；真正刷新由详情页打开或「获取模型」
-	* 按钮（force）触发。
+	* `/combos`（组合加模型）共用。
+	*
+	* **过期后走 stale-while-revalidate**:先返回旧值让面板立刻有内容,后台
+	* 重新拉,拉完下次请求就是新的。为什么必须这样:插件的 `listModels` 大多
+	* 无条件打上游(实测冷路径 0.3~1.0s/供应商),而组合页要拉全部供应商、
+	* 取最慢那家——同步等就是 1s+ 的白屏。旧值只可能「少列了新模型」,
+	* 比白屏划算;想立刻看新模型点「获取模型」(force)即可。
 	*
-	* 天花板：TTL 60s 是拍的。若上游模型列表变更很频繁，可调小；要彻底实时
-	* 就得让供应商暴露 etag/版本号，目前没有这个需求。
+	* 只有两种情况会真的等:`force`(用户主动刷新)和**从来没有过缓存值**
+	* (冷启动,没有旧值可给)。后者只发生一次。
 	*/
 	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
-			});
+		const fresh = hit !== void 0 && Date.now() - hit.fetchedAt < MODELS_TTL_MS;
+		if (!force && fresh) return hit.models;
+		if (!force && hit !== void 0) {
+			this.refreshModels(supplierId, s).catch(() => {});
+			return hit.models;
 		}
-		this.modelsCache.set(supplierId, {
-			models,
-			fetchedAt: Date.now()
+		return await this.refreshModels(supplierId, s);
+	}
+	/**
+	* 真拉一次上游并写缓存。并发调用共享同一个 in-flight promise——
+	* 组合页会同时触发多个入口,不去重会把上游按 N 倍打(各家插件自己没做这层)。
+	*
+	* 失败时:**有旧值就退回旧值**(宁可显示几分钟前的列表,也别让面板空掉),
+	* **没旧值就把错误抛回去**——调用方(`supplierModels`)据此把该供应商整个
+	* 剔除,而不是显示一个「有 0 个模型」的空壳。
+	*/
+	refreshModels(supplierId, s) {
+		const inflight = this.modelsInflight.get(supplierId);
+		if (inflight !== void 0) return inflight;
+		const p = (async () => {
+			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
+				});
+			}
+			const stale = this.modelsCache.get(supplierId);
+			if (models.length === 0 && stale !== void 0 && stale.models.length > 0) return stale.models;
+			this.modelsCache.set(supplierId, {
+				models,
+				fetchedAt: Date.now()
+			});
+			return models;
+		})().catch((err) => {
+			const stale = this.modelsCache.get(supplierId);
+			if (stale !== void 0) return stale.models;
+			throw err instanceof Error ? err : new Error(String(err));
+		}).finally(() => {
+			this.modelsInflight.delete(supplierId);
 		});
-		return models;
+		this.modelsInflight.set(supplierId, p);
+		return p;
 	}
 	/** 失效某供应商的模型缓存（增删改模型后调用）。 */
 	invalidateModels(supplierId) {
@@ -1516,10 +1820,12 @@ 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, probe)) {
+				const trace = { attempts: 0 };
+				if (await this.chatWithModel(req, res, model, probe, trace)) {
 					settle(true);
 					return;
 				}
+				if (trace.lastState !== void 0 && isTransient(trace.lastState) && i < combo.models.length - 1) await new Promise((r) => setTimeout(r, TRANSIENT_SETTLE_MS));
 			}
 			settle(false, "combo: all models unavailable");
 			writeJson$2(res, 503, openAIError("no_healthy_supplier", `combo ${JSON.stringify(req.model)}: all models unavailable`));
@@ -1557,7 +1863,12 @@ var Router = class {
 	*  不再挨个问供应商「这是不是你的模型」——精准调用，也避免同名模型串台。
 	*  兼容旧的裸 `modelId`（没有逗号）：降级为遍历，行为同以前。
 	*/
-	async chatWithModel(req, res, model, probe) {
+	/**
+	* @param outTrace 可选出参：把这次调用的追踪信息带回去（组合据此判断
+	*   要不要「喘口气」再降级）。裸 id 遍历路径不填（多供应商混在一起，
+	*   失败状态没有单一归属）。
+	*/
+	async chatWithModel(req, res, model, probe, outTrace) {
 		const comma = model.indexOf(",");
 		const supplierId = comma > 0 ? model.slice(0, comma) : void 0;
 		const modelId = comma > 0 ? model.slice(comma + 1) : model;
@@ -1572,20 +1883,26 @@ var Router = class {
 		} catch {
 			clone.rawBody = req.rawBody;
 		}
-		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;
+		if (supplierId === void 0) {
+			const msg = `model ${JSON.stringify(model)} 缺供应商前缀（应为 supplierId,modelId）`;
+			this.logChat(req.model, msg, 0);
+			return false;
 		}
-		for (const s of this.suppliers) if (await this.chatWithSupplier(s, clone, res, void 0, probe)) return true;
-		return false;
+		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);
+		if (outTrace !== void 0) {
+			outTrace.attempts = trace.attempts;
+			outTrace.lastError = trace.lastError;
+			outTrace.lastState = trace.lastState;
+		}
+		this.logChat(req.model, served ? `${s.id}/${modelId} (${trace.uid ?? "?"}) ok${trace.attempts > 0 ? ` 重试${trace.attempts}次` : ""}` : `${s.id}/${modelId} 失败 ${trace.lastError ?? "no account"}`, Date.now() - t0);
+		return served;
 	}
 	/** 按别名找供应商（对外模型全名 = alias/model）。别名唯一，故最多命中一个。 */
 	supplierByAlias(alias) {
@@ -1607,20 +1924,21 @@ var Router = class {
 			const r = await s.chatOnce("", req);
 			if (!r.ok) {
 				if (r.state === "no_such_model") return false;
-				pool.noteFailure("", r.state, r.message);
+				if (trace !== void 0) trace.lastState = r.state;
+				pool.noteFailure("", req.model, 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.model = `${s.getAlias()}/${stripAlias(req.model, s.getAlias())}`;
 				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);
+			const uid = pool.pick(s.accounts().filter((a) => !tried.has(a.uid)), cfg.poolOrder, cfg.poolStrategy, req.model);
 			if (uid === void 0) return false;
 			tried.add(uid);
 			const r = await s.chatOnce(uid, req);
@@ -1629,24 +1947,26 @@ var Router = class {
 					if (trace !== void 0) trace.lastError = "no_such_model";
 					return false;
 				}
-				pool.noteFailure(uid, r.state, r.message);
+				pool.noteFailure(uid, req.model, r.state, r.message);
 				if (trace !== void 0) {
 					trace.attempts += 1;
+					trace.lastState = r.state;
 					trace.lastError = `${r.state}: ${r.message}`;
 				}
 				continue;
 			}
-			pool.noteSuccess(uid);
+			pool.noteSuccess(uid, req.model);
 			if (trace !== void 0) trace.uid = uid;
 			if (probe !== void 0) {
 				probe.supplier = s.id;
-				probe.model = `${s.getAlias()}/${req.model}`;
+				probe.model = `${s.getAlias()}/${stripAlias(req.model, s.getAlias())}`;
 				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");
+			pool.noteFailure(uid, req.model, "transport", "stream failed before first byte");
 			if (trace !== void 0) {
 				trace.attempts += 1;
+				trace.lastState = "transport";
 				trace.lastError = "stream failed before first byte";
 			}
 		}
@@ -1675,8 +1995,9 @@ var Router = class {
 			})
 		};
 		let served = false;
+		const trace = { attempts: 0 };
 		try {
-			served = await this.chatWithSupplier(s, req, sink);
+			served = await this.chatWithSupplier(s, req, sink, trace);
 		} catch (err) {
 			return {
 				ok: false,
@@ -1685,7 +2006,7 @@ var Router = class {
 		}
 		if (served && sink.status() < 400) return { ok: true };
 		const fromSink = served && sink.status() >= 400 ? extractUpstreamError(sink.body()) : "";
-		const detail = fromSink !== "" ? fromSink : s.lastError?.();
+		const detail = fromSink !== "" ? fromSink : trace.lastError;
 		return {
 			ok: false,
 			error: detail !== void 0 && detail !== "" ? `${detail}（账号/额度/限流问题，非模型问题）` : "所有账号都失败或账号都在冷却中（稍后重试）"
@@ -1707,26 +2028,21 @@ var Router = class {
 *
 * 纯文本流：组合为文本模型，本 adapter 不处理图片附件。
 */
-/** 解析 SSE 文本，产出 `data:` 载荷（含结尾 [DONE]）。 */
-function* parseSseText(text) {
-	let data = "";
-	for (const line of text.split("\n")) {
-		if (line.startsWith("data:")) {
-			const value = line.slice(5).trimStart();
-			if (data.length > 0) data += "\n";
-			data += value;
-			continue;
-		}
-		if (line === "" && data.length > 0) {
-			yield data;
-			data = "";
-		}
-	}
-	if (data.length > 0) yield data;
-}
-/** 把 DSH 消息序列化成 openai 兼容 wire 消息（纯文本 + tool）。 */
-function wireMessages(options) {
+/**
+* 把 DSH 消息序列化成 openai 兼容 wire 消息（纯文本 + tool）。
+*
+* `system` 必须由调用方从 `options.system` 传进来：agent-loop 把系统提示词
+* 放在 **options.system 这个独立槽位**，不放进 messages（见 dsh-llm
+* types.d.ts 的 `system?: string` —— 注释原话 "adapters map to the
+* provider's system slot"）。不读这个槽位，模型每一轮都拿不到身份/规则/
+* 工具用法约束，且**不会报错**，只是行为悄悄降级。
+*/
+function wireMessages(options, system) {
 	const out = [];
+	if (typeof system === "string" && system !== "") out.push({
+		role: "system",
+		content: system
+	});
 	for (const message of options.messages) {
 		if (message.role === "system") {
 			out.push({
@@ -1763,14 +2079,14 @@ function wireMessages(options) {
 		for (const result of toolResults) out.push({
 			role: "tool",
 			tool_call_id: result.toolCallId,
-			content: flattenText(result.content) || "(no output)"
+			content: flattenText(result.content)
 		});
 	}
 	return out;
 }
 /** 组装 wire 请求体。 */
 function wireRequest(options) {
-	const messages = wireMessages(options);
+	const messages = wireMessages(options, options.system);
 	const body = {
 		model: options.model,
 		messages,
@@ -1789,12 +2105,41 @@ function wireRequest(options) {
 	if (options.temperature !== void 0) body.temperature = options.temperature;
 	if (options.maxTokens !== void 0) body.max_tokens = options.maxTokens;
 	if (options.stop !== void 0) body.stop = options.stop;
+	applyReasoning(body, options.reasoningEffort);
 	return body;
 }
+/**
+* 推理强度 → CodeBuddy 的 OpenAI 风格参数。
+*
+* 照 9router `executors/codebuddy-cn.js` 的处理：CodeBuddy 只有同时收到
+* `reasoning_effort` + `reasoning_summary:"auto"` 才吐推理内容，而 harness
+* 只给 `reasoning_effort`，从不下发 `reasoning_summary`。
+*
+* 关键陷阱（9router 注释里的 #2071）：**不能无条件加**。对没要推理的普通
+* 请求强行加 `reasoning_effort:"medium"` + `reasoning_summary`，会让
+* CodeBuddy 触发内容过滤直接报错。`none`/`off` 也必须是**删字段**而不是传
+* `"none"` —— 网关没有这个值。
+*/
+function applyReasoning(body, effort) {
+	if (effort === void 0 || effort === "") return;
+	if (effort === "none" || effort === "off") {
+		delete body.reasoning_effort;
+		delete body.reasoning_summary;
+		return;
+	}
+	body.reasoning_effort = effort;
+	body.reasoning_summary = "auto";
+}
 function flattenText(blocks) {
 	return blocks.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
 }
 /** openai SSE payload → DSH StreamChunk 流。导出以便单测锁死 usage 契约。 */
+/**
+* 把上游 SSE 的 `data:` 载荷流翻译成 DSH 的 StreamChunk 事件流。
+*
+* 吃 `AsyncIterable`（真流式：边收边吐）或 `Iterable`（测试用数组）。
+* 用 `for await` 是因为它天然兼容两者 —— 不必为流式再写一份。
+*/
 async function* translateSse(payloads) {
 	let nextIndex = 0;
 	let textBlock;
@@ -1804,6 +2149,8 @@ async function* translateSse(payloads) {
 	let pendingFinish;
 	/** 攒上游各帧的 usage（归一形态），[DONE] 时统一转成 DSH 契约。 */
 	let accumulated = null;
+	/** 解析失败的帧数（坏帧跳过，不硬抛；全是坏帧才当断流处理）。 */
+	let malformed = 0;
 	const open = (kind) => {
 		const block = {
 			index: nextIndex++,
@@ -1813,13 +2160,35 @@ async function* translateSse(payloads) {
 		order.push(block);
 		return block;
 	};
-	for (const payload of payloads) {
+	for await (const payload of payloads) {
 		if (payload === "[DONE]") {
-			for (const block of order) yield {
+			const complete = order.filter((block) => block.kind !== "tool-call" || completeJson(block.text));
+			const dropped = order.length - complete.length;
+			for (const block of complete) yield {
 				type: "block-end",
 				index: block.index,
 				block: closeBlock(block)
 			};
+			for (const block of order) {
+				if (block.kind !== "tool-call" || completeJson(block.text)) continue;
+				yield {
+					type: "block-end",
+					index: block.index,
+					block: {
+						type: "tool-call",
+						id: CallId(block.callId ?? ""),
+						name: "",
+						arguments: "{}"
+					}
+				};
+			}
+			if (dropped > 0) pendingFinish = {
+				kind: "error",
+				failure: {
+					message: `upstream closed the stream before ${dropped} tool call argument${dropped > 1 ? "s were" : " was"} complete`,
+					code: EMPTY_RESPONSE_CODE
+				}
+			};
 			if (accumulated !== null) {
 				const usage = toTokenUsage(accumulated);
 				if (usage !== null) yield {
@@ -1844,7 +2213,8 @@ async function* translateSse(payloads) {
 		try {
 			chunk = JSON.parse(payload);
 		} catch {
-			throw new LlmError(`malformed SSE payload: ${payload.slice(0, 120)}`, "MALFORMED_RESPONSE");
+			malformed += 1;
+			continue;
 		}
 		for (const choice of chunk.choices ?? []) {
 			const delta = choice.delta ?? {};
@@ -1907,24 +2277,33 @@ async function* translateSse(payloads) {
 					argumentsDelta: fragment
 				};
 			}
-			if (typeof choice.finish_reason === "string") pendingFinish = mapFinishReason(choice.finish_reason);
+			if (typeof choice.finish_reason === "string") {
+				const mapped = mapFinishReason(choice.finish_reason);
+				if (mapped !== void 0) pendingFinish = mapped;
+			}
 		}
 		if (chunk.usage !== void 0) accumulated = mergeUsage(accumulated, normalizeUsage(chunk.usage));
 	}
-	throw new LlmError("SSE payload stream ended without [DONE]", "STREAM_CLOSED");
+	const detail = malformed > 0 ? ` (${malformed} frame(s) unparseable)` : "";
+	throw new LlmError(`SSE payload stream ended without [DONE]${detail}`, "TRANSPORT");
 }
+/** 上游 finish_reason → DSH finish reason；空串（「未终止」）返回 undefined。 */
 function mapFinishReason(reason) {
 	switch (reason) {
+		case "": return;
 		case "stop": return { kind: "stop" };
 		case "tool_calls": return { kind: "tool-calls" };
 		case "length": return { kind: "max-tokens" };
-		default: return {
-			kind: "error",
-			failure: {
-				message: `model stopped: ${reason}`,
-				code: reason.toUpperCase()
-			}
-		};
+		default: {
+			const code = reason.trim().toUpperCase();
+			return {
+				kind: "error",
+				failure: {
+					message: `model stopped: ${reason}`,
+					code: code === "" ? "UNKNOWN_FINISH_REASON" : code
+				}
+			};
+		}
 	}
 }
 function closeBlock(block) {
@@ -1941,11 +2320,27 @@ function closeBlock(block) {
 			type: "tool-call",
 			id: CallId(block.callId ?? ""),
 			name: block.name ?? "",
-			arguments: block.text
+			arguments: block.text === "" ? "{}" : block.text
 		};
 	}
 }
 /**
+* 工具调用的 arguments 是否已经收完整（能解析成一个 JSON 对象）。
+*
+* 判断口径刻意简单：只看能不能 `JSON.parse` 出对象。不校验 schema——
+* 那是工具自己的活，adapter 只负责「别把半成品交出去」。
+* 空串视为完整（无参工具），因为上游不发参数分片是合法的。
+*/
+function completeJson(text) {
+	if (text.trim() === "") return true;
+	try {
+		const v = JSON.parse(text);
+		return typeof v === "object" && v !== null && !Array.isArray(v);
+	} catch {
+		return false;
+	}
+}
+/**
 * DSH adapter：provider `router`。模型目录 = 组合；stream 转发到本插件
 * /v1/chat/completions（组合路由在 /v1 内完成）。
 */
@@ -1988,6 +2383,7 @@ var RouterAdapter = class extends LlmAdapter {
 			resp = await fetch(`${this.baseURL}/chat/completions`, {
 				method: "POST",
 				headers: {
+					...attributionHeaders(),
 					"content-type": "application/json",
 					accept: "text/event-stream"
 				},
@@ -2003,9 +2399,77 @@ 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* translateSse(parseSseText(resp.body === null ? "" : await resp.text()));
+		if (resp.body === null) return;
+		yield* translateSse(ssePayloads(resp.body));
 	}
 };
+/**
+* 已攒的 payload 是否已经是完整的（`[DONE]` 或一个能解析的 JSON 对象）。
+*
+* 只用于「缺空行分隔」时的前瞻回退，不校验业务结构 —— 那是 translateSse 的事。
+*/
+function looksComplete(payload) {
+	if (payload === "[DONE]") return true;
+	try {
+		JSON.parse(payload);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 从上游响应体**增量**产出 SSE 的 `data:` 载荷。
+*
+* 为什么必须逐块读：曾经这里写 `await resp.text()` 攒完整串再解析，等于
+* 把流式降级成批处理 —— 首字节延迟等于整个响应耗时；更糟的是中途断流时
+* resp.text() 只拿到半截文本，最后一帧是半截 JSON（`{"command": "cd`），
+* 表现为「工具参数残缺」。短响应连接不断，所以本地抓包复现不了。
+*
+* 跨块边界：一个 `data:` 行可能横跨两次 read()，所以留 `buffer` 接住
+* 最后一段未完整的行（9router 的 pipeTransformedSSE 同样处理）。
+*/
+async function* ssePayloads(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder("utf-8", { fatal: false });
+	let buffer = "";
+	/** 攒一帧内的多行 data（SSE 规范：多行用 \n 连起来）。**必须**是局部
+	*  状态 —— 放模块级会让并发请求互相串数据。 */
+	let payload = "";
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) {
+				const t = line.trim();
+				if (t.startsWith("data:")) {
+					if (payload.length > 0 && looksComplete(payload)) {
+						yield payload;
+						payload = "";
+					}
+					payload += (payload.length > 0 ? "\n" : "") + t.slice(5).trimStart();
+					continue;
+				}
+				if (t === "" && payload.length > 0) {
+					yield payload;
+					payload = "";
+				}
+			}
+		}
+		if (buffer.length > 0) {
+			const t = buffer.trim();
+			if (t.startsWith("data:")) payload += (payload.length > 0 ? "\n" : "") + t.slice(5).trimStart();
+		}
+		if (payload.length > 0) yield payload;
+	} finally {
+		try {
+			reader.releaseLock();
+		} catch {}
+		await body.cancel().catch(() => {});
+	}
+}
 //#endregion
 //#region src/keys.ts
 /**
@@ -2133,6 +2597,26 @@ var KeysStore = class {
 function isFn(v) {
 	return typeof v === "function";
 }
+/**
+* 积分回灌（核心统一持久化，插件不落盘）。
+*
+* 插件的积分是异步拉的：重启后第一次 status() 拿不到真值，报 `CREDITS_UNKNOWN`
+* (-1)。这里做两件事：
+*   - 报了真值 → 写入 supplier-config.json（下次重启还在）
+*   - 报了 -1 → 用上次存的顶上，面板不会闪 0
+*
+* 插件不该自己把 0 当「未知」报上来 —— 0 是真值（用完了），核心分不清，
+* 会把缓存冲成 0。这条是本层存在的理由（2026-09-03）。
+*/
+function hydrateCredits(supplierId, store, accounts) {
+	return accounts.map((a) => {
+		const merged = store.putCredits(supplierId, a.uid, a.credits);
+		return merged === a.credits ? a : {
+			...a,
+			credits: merged
+		};
+	});
+}
 /** 从模块导出解析出供应商模块对象（支持 export default / 命名导出 / factory）。 */
 function resolveModule(mod, file) {
 	const cand = mod.default ?? mod;
@@ -2175,7 +2659,7 @@ function wrapModule(instance, env, source, kind = "external") {
 	if (typeof instance !== "object" || instance === null || typeof instance.id !== "string" || instance.id === "") throw new Error(`供应商模块无效: ${source}`);
 	const capabilities = /* @__PURE__ */ new Set();
 	for (const key of DIFF_CAPS) if (isFn(instance[key])) capabilities.add(key);
-	const pool = new AccountPool();
+	const pool = new AccountPool(instance.id);
 	const supplier = {
 		id: instance.id,
 		name: instance.name,
@@ -2186,7 +2670,7 @@ function wrapModule(instance, env, source, kind = "external") {
 			return {
 				id: now.id,
 				name: now.name,
-				accounts: pool.decorate(now.accounts)
+				accounts: pool.decorate(hydrateCredits(instance.id, env.store, now.accounts))
 			};
 		},
 		listModels: (force) => instance.listModels(force),
@@ -2204,7 +2688,6 @@ function wrapModule(instance, env, source, kind = "external") {
 		customModelIds: () => [...env.store.get(instance.id).custom],
 		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(),
 		pool
@@ -2577,8 +3060,9 @@ function supplierRoutes(base, loaded, store, router) {
 				});
 				return;
 			}
-			const body = JSON.parse(await readBody$1(req));
-			const ok = await s.removeLink(body.uid ?? "");
+			const uid = JSON.parse(await readBody$1(req)).uid ?? "";
+			const ok = await s.removeLink(uid);
+			if (ok) store.clearCredits(s.id, uid);
 			writeJson$1(res, ok ? 200 : 404, ok ? { ok: true } : {
 				ok: false,
 				error: "link not found"
@@ -2632,14 +3116,17 @@ function supplierRoutes(base, loaded, store, router) {
 			}
 			const succeeded = results.filter((r) => r.status === "ok").length;
 			const already = results.filter((r) => r.status === "already").length;
+			const failed = results.length - succeeded - already;
+			const ok = failed === 0 && results.length > 0;
 			const payload = {
-				ok: succeeded + already > 0,
+				ok,
 				total: uids.length,
 				succeeded,
 				already,
+				failed,
 				results
 			};
-			writeJson$1(res, payload.ok ? 200 : 400, payload);
+			writeJson$1(res, ok ? 200 : 400, payload);
 		}
 	});
 	return routes;