@lancecheney/dsh-deepseek-balance 0.1.0 → 0.1.2

package/lib/index.js

@@ -1,6 +1,10 @@
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import { settingsNamespace } from "@deepseek-ai/dsh-settings";
 import { z } from "zod";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { zstdDecompressSync } from "node:zlib";
 
 /**
  * @lancecheney/dsh-deepseek-balance — host half.
@@ -11,6 +15,9 @@ import { z } from "zod";
 
 const name = "deepseek-balance";
 const inject = ["webServer", "credentials", "settings"];
+const Config = z.object({
+	tokenName: z.string().default("API key")
+});
 
 const DEFAULT_BASE_URL = "https://api.deepseek.com";
 const DEFAULT_KEY_ENV = "DEEPSEEK_API_KEY";
@@ -22,6 +29,7 @@ const PRICING_FETCH_TIMEOUT_MS = 15000;
 /** Last-known-good prices: legacy + the 2026-08-17 peak/off-peak table, per currency. */
 const FALLBACK_PRICING = {
 	effectiveFrom: "2026-08-17T00:00:00+08:00",
+	weekendFrom: "2026-08-23T00:00:00+08:00",
 	currencies: {
 		CNY: {
 			symbol: "¥",
@@ -35,6 +43,11 @@ const FALLBACK_PRICING = {
 					legacy: { hit: 0.025, miss: 3.0, output: 6.0 },
 					peak: { hit: 0.30, miss: 9.0, output: 27.0 },
 					offPeak: { hit: 0.15, miss: 4.5, output: 13.5 }
+				},
+				"deepseek-v4-flash-vision-exp": {
+					legacy: { hit: 0.02, miss: 1.0, output: 2.0 },
+					peak: { hit: 0.10, miss: 3.0, output: 9.0 },
+					offPeak: { hit: 0.05, miss: 1.5, output: 4.5 }
 				}
 			}
 		},
@@ -50,6 +63,11 @@ const FALLBACK_PRICING = {
 					legacy: { hit: 0.003625, miss: 0.435, output: 0.87 },
 					peak: { hit: 0.044, miss: 1.32, output: 3.96 },
 					offPeak: { hit: 0.022, miss: 0.66, output: 1.98 }
+				},
+				"deepseek-v4-flash-vision-exp": {
+					legacy: { hit: 0.0028, miss: 0.14, output: 0.28 },
+					peak: { hit: 0.014, miss: 0.44, output: 1.32 },
+					offPeak: { hit: 0.007, miss: 0.22, output: 0.66 }
 				}
 			}
 		}
@@ -129,81 +147,84 @@ const number = (match, index) => {
 	return Number.isFinite(value) ? value : void 0;
 };
 
-/** Parse the zh-CN docs page: CNY prices + the effective date. */
+/** Parse the zh-CN docs page: CNY peak/off-peak table (3 columns). */
 function parseCnPricing(html) {
 	const text = stripTags(html);
-	const parseModel = (id) => {
-		const re = new RegExp(id + "\\s+空闲时段\\s+([\\d.]+)元\\s+([\\d.]+)元\\s+([\\d.]+)元\\s+高峰时段\\s+([\\d.]+)元\\s+([\\d.]+)元\\s+([\\d.]+)元");
+	const grab = (label) => {
+		const re = new RegExp(label + "\\s*空闲时段\\s*([\\d.]+)元\\s*([\\d.]+)元\\s*([\\d.]+)元\\s*高峰时段\\s*([\\d.]+)元\\s*([\\d.]+)元\\s*([\\d.]+)元");
 		const m = text.match(re);
 		if (!m) return void 0;
 		return {
-			offPeak: { hit: number(m, 1), miss: number(m, 2), output: number(m, 3) },
-			peak: { hit: number(m, 4), miss: number(m, 5), output: number(m, 6) }
+			offPeak: [number(m, 1), number(m, 2), number(m, 3)],
+			peak: [number(m, 4), number(m, 5), number(m, 6)]
 		};
 	};
-	const flash = parseModel("deepseek-v4-flash");
-	const pro = parseModel("deepseek-v4-pro");
-	if (!flash || !pro) throw new Error("CNY peak/off-peak table not found");
-
-	let effectiveFrom = FALLBACK_PRICING.effectiveFrom;
-	const dm = text.match(/北京时间\s*(\d{4})\s*年\s*(\d{1,2})\s*月\s*(\d{1,2})\s*日\s*(\d{1,2}):(\d{2})/);
-	if (dm) {
-		const [y, mo, d, h, mi] = [1, 2, 3, 4, 5].map((i) => Number(dm[i]));
-		effectiveFrom = `${y}-${String(mo).padStart(2, "0")}-${String(d).padStart(2, "0")}T${String(h).padStart(2, "0")}:${String(mi).padStart(2, "0")}:00+08:00`;
-	}
-
-	let legacy;
-	const lm = text.match(/百万tokens输入（缓存命中）\s*([\d.]+)元\s*([\d.]+)元\s*百万tokens输入（缓存未命中）\s*([\d.]+)元\s*([\d.]+)元\s*百万tokens输出\s*([\d.]+)元\s*([\d.]+)元/);
-	if (lm) {
-		legacy = {
-			flash: { hit: number(lm, 1), miss: number(lm, 3), output: number(lm, 5) },
-			pro: { hit: number(lm, 2), miss: number(lm, 4), output: number(lm, 6) }
-		};
-	}
+	const hit = grab("百万tokens输入\\s*（缓存命中）");
+	const miss = grab("百万tokens输入\\s*（缓存未命中）");
+	const out = grab("百万tokens输出");
+	if (!hit || !miss || !out) throw new Error("CNY peak/off-peak table not found");
+
+	const mk = (i) => ({
+		offPeak: { hit: hit.offPeak[i], miss: miss.offPeak[i], output: out.offPeak[i] },
+		peak: { hit: hit.peak[i], miss: miss.peak[i], output: out.peak[i] }
+	});
 
 	return {
-		effectiveFrom,
 		models: {
-			"deepseek-v4-flash": { ...(legacy?.flash ? { legacy: legacy.flash } : {}), peak: flash.peak, offPeak: flash.offPeak },
-			"deepseek-v4-pro": { ...(legacy?.pro ? { legacy: legacy.pro } : {}), peak: pro.peak, offPeak: pro.offPeak }
+			"deepseek-v4-flash": mk(0),
+			"deepseek-v4-pro": mk(1),
+			"deepseek-v4-flash-vision-exp": mk(2)
 		}
 	};
 }
 
-/** Parse the English docs page: USD prices. */
+/** Parse the English docs page: USD peak/off-peak table (3 columns). */
 function parseUsModels(html) {
 	const text = stripTags(html);
-	const parseModel = (id) => {
-		const re = new RegExp(id + "\\s+OFF-PEAK\\s+\\$([\\d.]+)\\s+\\$([\\d.]+)\\s+\\$([\\d.]+)\\s+PEAK\\s+\\$([\\d.]+)\\s+\\$([\\d.]+)\\s+\\$([\\d.]+)", "i");
+	const grab = (label) => {
+		const re = new RegExp(label + "\\s+OFF-PEAK\\s+\\$([\\d.]+)\\s+\\$([\\d.]+)\\s+\\$([\\d.]+)\\s+PEAK\\s+\\$([\\d.]+)\\s+\\$([\\d.]+)\\s+\\$([\\d.]+)", "i");
 		const m = text.match(re);
 		if (!m) return void 0;
 		return {
-			offPeak: { hit: number(m, 1), miss: number(m, 2), output: number(m, 3) },
-			peak: { hit: number(m, 4), miss: number(m, 5), output: number(m, 6) }
+			offPeak: [number(m, 1), number(m, 2), number(m, 3)],
+			peak: [number(m, 4), number(m, 5), number(m, 6)]
 		};
 	};
-	const flash = parseModel("deepseek-v4-flash");
-	const pro = parseModel("deepseek-v4-pro");
-	if (!flash || !pro) throw new Error("USD peak/off-peak table not found");
-
-	let legacy;
-	const lm = text.match(/1M INPUT TOKENS \(CACHE HIT\)\s+\$([\d.]+)\s+\$([\d.]+)\s+1M INPUT TOKENS \(CACHE MISS\)\s+\$([\d.]+)\s+\$([\d.]+)\s+1M OUTPUT TOKENS\s+\$([\d.]+)\s+\$([\d.]+)/i);
-	if (lm) {
-		legacy = {
-			flash: { hit: number(lm, 1), miss: number(lm, 3), output: number(lm, 5) },
-			pro: { hit: number(lm, 2), miss: number(lm, 4), output: number(lm, 6) }
-		};
-	}
+	const hit = grab("1M INPUT TOKENS\\s*\\(CACHE HIT\\)");
+	const miss = grab("1M INPUT TOKENS\\s*\\(CACHE MISS\\)");
+	const out = grab("1M OUTPUT TOKENS");
+	if (!hit || !miss || !out) throw new Error("USD peak/off-peak table not found");
+
+	const mk = (i) => ({
+		offPeak: { hit: hit.offPeak[i], miss: miss.offPeak[i], output: out.offPeak[i] },
+		peak: { hit: hit.peak[i], miss: miss.peak[i], output: out.peak[i] }
+	});
 
 	return {
-		"deepseek-v4-flash": { ...(legacy?.flash ? { legacy: legacy.flash } : {}), peak: flash.peak, offPeak: flash.offPeak },
-		"deepseek-v4-pro": { ...(legacy?.pro ? { legacy: legacy.pro } : {}), peak: pro.peak, offPeak: pro.offPeak }
+		models: {
+			"deepseek-v4-flash": mk(0),
+			"deepseek-v4-pro": mk(1),
+			"deepseek-v4-flash-vision-exp": mk(2)
+		}
 	};
 }
 
 const pricing = { data: FALLBACK_PRICING, fetchedAt: 0, source: "fallback" };
 let pricingRefresh = null;
 
+function mergeLegacy(models, fallbackModels) {
+	const result = {};
+	for (const [id, m] of Object.entries(models)) {
+		const fb = fallbackModels[id];
+		result[id] = {
+			...(fb && fb.legacy ? { legacy: fb.legacy } : {}),
+			peak: m.peak,
+			offPeak: m.offPeak
+		};
+	}
+	return result;
+}
+
 async function refreshPricing(ctx) {
 	if (pricingRefresh) return pricingRefresh;
 	pricingRefresh = (async () => {
@@ -211,6 +232,7 @@ async function refreshPricing(ctx) {
 			if (ctx?.logger?.warn) ctx.logger.warn(`deepseek-balance: ${message}`);
 		};
 		let effectiveFrom = FALLBACK_PRICING.effectiveFrom;
+		let weekendFrom = FALLBACK_PRICING.weekendFrom;
 		let cnModels = FALLBACK_PRICING.currencies.CNY.models;
 		let usModels = FALLBACK_PRICING.currencies.USD.models;
 		try {
@@ -221,8 +243,7 @@ async function refreshPricing(ctx) {
 			if (cnRes.ok) {
 				try {
 					const parsed = parseCnPricing(await cnRes.text());
-					effectiveFrom = parsed.effectiveFrom;
-					cnModels = parsed.models;
+					cnModels = mergeLegacy(parsed.models, FALLBACK_PRICING.currencies.CNY.models);
 				} catch (error) {
 					warn(`CNY pricing parse failed: ${error instanceof Error ? error.message : String(error)}`);
 				}
@@ -231,7 +252,8 @@ async function refreshPricing(ctx) {
 			}
 			if (usRes.ok) {
 				try {
-					usModels = parseUsModels(await usRes.text());
+					const parsed = parseUsModels(await usRes.text());
+					usModels = mergeLegacy(parsed.models, FALLBACK_PRICING.currencies.USD.models);
 				} catch (error) {
 					warn(`USD pricing parse failed: ${error instanceof Error ? error.message : String(error)}`);
 				}
@@ -240,6 +262,7 @@ async function refreshPricing(ctx) {
 			}
 			pricing.data = {
 				effectiveFrom,
+				weekendFrom,
 				currencies: {
 					CNY: { symbol: "¥", models: cnModels },
 					USD: { symbol: "$", models: usModels }
@@ -268,27 +291,6 @@ function msUntilNextHourBeijing(hour) {
 	return deltaHours * 3600 * 1000 - bMinute * 60 * 1000 - bSecond * 1000 - bMs;
 }
 
-/** Beijing hour of a timestamp (UTC+8, no DST). */
-function beijingHourOf(time) {
-	return new Date(time + 8 * 3600 * 1000).getUTCHours();
-}
-
-function isPeakHour(hour) {
-	return (hour >= 9 && hour < 12) || (hour >= 14 && hour < 18);
-}
-
-const bucketSchema = z.object({
-	uncachedInputTokens: z.number().int().nonnegative(),
-	outputTokens: z.number().int().nonnegative(),
-	cacheReadTokens: z.number().int().nonnegative(),
-	cacheWriteTokens: z.number().int().nonnegative()
-});
-
-const tokenUsageByPeriodSchema = z.object({
-	peak: bucketSchema,
-	offPeak: bucketSchema
-});
-
 const zeroBucket = () => ({ uncachedInputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 });
 
 const bucketsFrom = (usage) => ({
@@ -298,12 +300,6 @@ const bucketsFrom = (usage) => ({
 	cacheWriteTokens: usage.cacheWriteTokens ?? 0
 });
 
-const bucketsEqual = (a, b) =>
-	a.uncachedInputTokens === b.uncachedInputTokens &&
-	a.outputTokens === b.outputTokens &&
-	a.cacheReadTokens === b.cacheReadTokens &&
-	a.cacheWriteTokens === b.cacheWriteTokens;
-
 const addBucket = (total, delta) => ({
 	uncachedInputTokens: total.uncachedInputTokens + delta.uncachedInputTokens,
 	outputTokens: total.outputTokens + delta.outputTokens,
@@ -311,53 +307,330 @@ const addBucket = (total, delta) => ({
 	cacheWriteTokens: total.cacheWriteTokens + delta.cacheWriteTokens
 });
 
-const subtractBucket = (total, delta) => ({
-	uncachedInputTokens: total.uncachedInputTokens - delta.uncachedInputTokens,
-	outputTokens: total.outputTokens - delta.outputTokens,
-	cacheReadTokens: total.cacheReadTokens - delta.cacheReadTokens,
-	cacheWriteTokens: total.cacheWriteTokens - delta.cacheWriteTokens
-});
+const ZSTD_MAGIC = 4247762216;
+
+function scanZstdFrames(buffer) {
+	const frames = [];
+	let offset = 0;
+	while (offset < buffer.length) {
+		const start = offset;
+		if (buffer.length - offset < 4) break;
+		if (buffer.readUInt32LE(offset) !== ZSTD_MAGIC) break;
+		offset += 4;
+		const descriptor = buffer.readUInt8(offset);
+		offset += 1;
+		const contentSizeFlag = descriptor >>> 6;
+		const singleSegment = (descriptor & 32) !== 0;
+		const checksum = (descriptor & 4) !== 0;
+		const dictionaryFlag = descriptor & 3;
+		const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag;
+		const contentSizeBytes = contentSizeFlag === 0 ? (singleSegment ? 1 : 0) : (1 << contentSizeFlag);
+		offset += (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes;
+		for (;;) {
+			const blockHeader = buffer.readUIntLE(offset, 3);
+			offset += 3;
+			const lastBlock = (blockHeader & 1) !== 0;
+			const blockType = (blockHeader >>> 1) & 3;
+			const blockSize = blockHeader >>> 3;
+			offset += blockType === 1 ? 1 : blockSize;
+			if (lastBlock) break;
+		}
+		if (checksum) offset += 4;
+		frames.push({ start, end: offset });
+	}
+	return frames;
+}
 
-/**
- * Whole-log token usage bucketed by Beijing-time peak/off-peak hour, so the
- * client can price each hour at its own rate. Replacement semantics mirror the
- * token-meter `tokenUsage` projection: an assistant/message finalizes the usage
- * for its turn/step, replacing an earlier usage chunk instead of double counting.
- */
-const tokenUsageByPeriodProjection = {
-	key: "tokenUsageByPeriod",
-	schema: tokenUsageByPeriodSchema,
-	init: () => ({ totals: { peak: zeroBucket(), offPeak: zeroBucket() }, last: null }),
-	apply: (state, event) => {
-		let turn;
-		let step;
-		let usage;
-		if (event.type === "assistant/chunk" && event.data.chunk.type === "usage") {
-			({ turn, step } = event.data);
-			usage = event.data.chunk.usage;
-		} else if (event.type === "assistant/message" && event.data.usage !== void 0) {
-			({ turn, step, usage } = event.data);
+function dshHome() {
+	return process.env.DSH_HOME || join(homedir(), ".dsh");
+}
+
+function beijingDayKey(ms) {
+	return new Date(ms + 8 * 3600 * 1000).toISOString().slice(0, 10);
+}
+
+function periodOfUsage(time, effectiveFromMs, weekendFromMs) {
+	if (time < effectiveFromMs) return "flat";
+	const d = new Date(time + 8 * 3600 * 1000);
+	const day = d.getUTCDay();
+	if ((day === 0 || day === 6) && Number.isFinite(weekendFromMs) && time >= weekendFromMs) return "offPeak";
+	const hour = d.getUTCHours();
+	return (hour >= 9 && hour < 12) || (hour >= 14 && hour < 18) ? "peak" : "offPeak";
+}
+
+function readSessionRecords(path) {
+	const buf = readFileSync(path);
+	let text;
+	if (path.endsWith(".zstd")) {
+		const parts = [];
+		for (const frame of scanZstdFrames(buf)) parts.push(zstdDecompressSync(buf.subarray(frame.start, frame.end)).toString("utf8"));
+		text = parts.join("");
+	} else {
+		text = buf.toString("utf8");
+	}
+	const records = [];
+	for (const line of text.split("\n")) {
+		const t = line.trim();
+		if (t === "") continue;
+		try { records.push(JSON.parse(t)); } catch {}
+	}
+	return records;
+}
+
+function aggregateSessions(archivedIds = []) {
+	const archivedSet = new Set(archivedIds);
+	const root = join(dshHome(), "sessions");
+	const summary = {
+		totalTokens: 0,
+		peakTokens: 0,
+		offPeakTokens: 0,
+		flatTokens: 0,
+		dailyPeakTokens: 0,
+		longestChatMs: 0,
+		currentStreak: 0,
+		longestStreak: 0,
+		days: {},
+		sessions: [],
+		modelEffort: {},
+		byModel: {}
+	};
+	if (!existsSync(root)) return summary;
+	const effectiveFromMs = Date.parse(pricing.data.effectiveFrom || FALLBACK_PRICING.effectiveFrom);
+	if (!Number.isFinite(effectiveFromMs)) return summary;
+	const weekendFromMs = Date.parse(pricing.data.weekendFrom || FALLBACK_PRICING.weekendFrom);
+
+	let wsDirs = [];
+	try { wsDirs = readdirSync(root); } catch { return summary; }
+	for (const wsDir of wsDirs) {
+		const wsPath = join(root, wsDir);
+		let sDirs = [];
+		try { sDirs = readdirSync(wsPath); } catch { continue; }
+		for (const sDir of sDirs) {
+			const sPath = join(wsPath, sDir);
+			const zstd = join(sPath, "session.jsonl.zstd");
+			const plain = join(sPath, "session.jsonl");
+			const path = existsSync(zstd) ? zstd : existsSync(plain) ? plain : null;
+			if (path === null) continue;
+			let records;
+			try { records = readSessionRecords(path); } catch { continue; }
+			let header = null;
+			let title = null;
+			let model = null;
+			let effort = null;
+			let firstTime = null;
+			let lastTime = null;
+			let tokens = 0;
+			let peakTokens = 0;
+			let offPeakTokens = 0;
+			let flatTokens = 0;
+			const dayTokens = {};
+			const sessionByModel = {};
+			const dedupe = new Set();
+			{
+				const last = new Map();
+				for (const r of records) {
+					let key = null;
+					if (r.type === "assistant/message" && r.data?.usage) {
+						const t = r.data?.turn;
+						const s = r.data?.step;
+						if (t !== void 0 && s !== void 0) key = t + "|" + s;
+					} else if (r.type === "assistant/chunk" && r.data?.chunk?.type === "usage") {
+						const t = r.data?.turn;
+						const s = r.data?.step;
+						if (t !== void 0 && s !== void 0) key = t + "|" + s;
+					}
+					if (key !== null) last.set(key, r);
+				}
+				for (const r of last.values()) dedupe.add(r);
+			}
+			for (const r of records) {
+				if (r.type === "session" && header === null) { header = r; continue; }
+				if (r.type === "session/title" && r.data?.title) title = r.data.title;
+				if (r.type === "request/header") {
+					model = r.data?.header?.config?.model ?? model;
+					effort = r.data?.header?.config?.reasoningEffort ?? effort;
+				}
+				const time = typeof r.time === "number" ? r.time : null;
+				if (time !== null) {
+					if (firstTime === null || time < firstTime) firstTime = time;
+					if (lastTime === null || time > lastTime) lastTime = time;
+				}
+				let usage = null;
+				if (r.type === "assistant/message" && r.data?.usage) usage = r.data.usage;
+				else if (r.type === "assistant/chunk" && r.data?.chunk?.type === "usage") usage = r.data.chunk.usage;
+				if (usage && time !== null && dedupe.has(r)) {
+					const t = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0) + (usage.cacheReadTokens ?? 0);
+					const period = periodOfUsage(time, effectiveFromMs, weekendFromMs);
+					const dayKey = beijingDayKey(time);
+					tokens += t;
+					if (period === "peak") peakTokens += t;
+					else if (period === "offPeak") offPeakTokens += t;
+					else flatTokens += t;
+					const mkModel = model ?? "";
+					const b = bucketsFrom(usage);
+					dayTokens[dayKey] = dayTokens[dayKey] || {};
+					dayTokens[dayKey][mkModel] = dayTokens[dayKey][mkModel] || { flat: zeroBucket(), peak: zeroBucket(), offPeak: zeroBucket() };
+					dayTokens[dayKey][mkModel][period] = addBucket(dayTokens[dayKey][mkModel][period], b);
+					summary.byModel[mkModel] = summary.byModel[mkModel] || { flat: zeroBucket(), peak: zeroBucket(), offPeak: zeroBucket() };
+					summary.byModel[mkModel][period] = addBucket(summary.byModel[mkModel][period], b);
+					sessionByModel[mkModel] = sessionByModel[mkModel] || { flat: zeroBucket(), peak: zeroBucket(), offPeak: zeroBucket() };
+					sessionByModel[mkModel][period] = addBucket(sessionByModel[mkModel][period], b);
+					const mk = `${model ?? ""}|${effort ?? ""}`;
+					summary.modelEffort[mk] = summary.modelEffort[mk] || { tokens: 0 };
+					summary.modelEffort[mk].tokens += t;
+				}
+			}
+			summary.totalTokens += tokens;
+			summary.peakTokens += peakTokens;
+			summary.offPeakTokens += offPeakTokens;
+			summary.flatTokens += flatTokens;
+			for (const [dayKey, d] of Object.entries(dayTokens)) {
+				summary.days[dayKey] = summary.days[dayKey] || { tokens: 0, peak: 0, offPeak: 0, flat: 0, byModel: {} };
+				const day = summary.days[dayKey];
+				const byModel = day.byModel;
+				const bucketTotal = (bucket) => bucket.uncachedInputTokens + bucket.outputTokens + bucket.cacheReadTokens;
+				let dayTotal = 0;
+				let dayPeak = 0;
+				let dayOff = 0;
+				let dayFlat = 0;
+				for (const [m, b] of Object.entries(d)) {
+					byModel[m] = byModel[m] || { flat: zeroBucket(), peak: zeroBucket(), offPeak: zeroBucket() };
+					byModel[m].flat = addBucket(byModel[m].flat, b.flat);
+					byModel[m].peak = addBucket(byModel[m].peak, b.peak);
+					byModel[m].offPeak = addBucket(byModel[m].offPeak, b.offPeak);
+					dayPeak += bucketTotal(b.peak);
+					dayOff += bucketTotal(b.offPeak);
+					dayFlat += bucketTotal(b.flat);
+					dayTotal += bucketTotal(b.peak) + bucketTotal(b.offPeak) + bucketTotal(b.flat);
+				}
+				day.tokens += dayTotal;
+				day.peak += dayPeak;
+				day.offPeak += dayOff;
+				day.flat += dayFlat;
+				if (day.tokens > summary.dailyPeakTokens) summary.dailyPeakTokens = day.tokens;
+			}
+			const duration = (lastTime ?? 0) - (firstTime ?? 0);
+			if (duration > summary.longestChatMs) summary.longestChatMs = duration;
+
+			const sid = header?.id ?? sDir.replace(/^session-/, "");
+			summary.sessions.push({
+				id: sid,
+				title: title ?? header?.id ?? sDir,
+				cwd: header?.cwd ?? wsDir,
+				tokens,
+				peakTokens,
+				byModel: sessionByModel,
+				createdAt: header?.createdAt ?? firstTime,
+				endedAt: lastTime,
+				archived: archivedSet.has(sid)
+			});
+		}
+	}
+
+	summary.sessions.sort((a, b) => b.tokens - a.tokens);
+
+	const dayKeys = Object.keys(summary.days).sort();
+	let longest = 0;
+	let run = 0;
+	let prev = null;
+	for (const d of dayKeys) {
+		if (prev === null) run = 1;
+		else {
+			const diff = Math.round((Date.parse(d) - Date.parse(prev)) / 86400000);
+			run = diff === 1 ? run + 1 : 1;
+		}
+		if (run > longest) longest = run;
+		prev = d;
+	}
+	summary.longestStreak = longest;
+
+	const daySet = new Set(dayKeys);
+	let cur = 0;
+	let cursor = Date.parse(beijingDayKey(Date.now()));
+	while (daySet.has(beijingDayKey(cursor))) {
+		cur++;
+		cursor -= 86400000;
+	}
+	summary.currentStreak = cur;
+
+	return summary;
+}
+
+const DEFAULT_MODEL = "deepseek-v4-pro";
+
+/** Compute spend (CNY/USD) from an aggregated usage summary, using the live pricing table. */
+function computeSpend(summary, currency = "CNY") {
+	const pricingSet =
+		(pricing.data.currencies && pricing.data.currencies[currency]) ||
+		pricing.data.currencies?.CNY ||
+		FALLBACK_PRICING.currencies.CNY;
+	const models = pricingSet.models || {};
+	const defaultModel = models[DEFAULT_MODEL] || { legacy: null, peak: { miss: 0, hit: 0, output: 0 }, offPeak: { miss: 0, hit: 0, output: 0 } };
+	const priceOf = (tokens, price) => (tokens || 0) * (price || 0) / 1e6;
+	const bucketCost = (b, mm) => {
+		if (!mm) return 0;
+		const cost = (bucket, price) => {
+			if (!price) return 0;
+			return priceOf(bucket.uncachedInputTokens, price.miss)
+				+ priceOf(bucket.cacheWriteTokens, price.miss)
+				+ priceOf(bucket.cacheReadTokens, price.hit)
+				+ priceOf(bucket.outputTokens, price.output);
+		};
+		return (mm.legacy ? cost(b.flat, mm.legacy) : 0) + cost(b.peak, mm.peak) + cost(b.offPeak, mm.offPeak);
+	};
+	let total = 0;
+	for (const [k, b] of Object.entries(summary.byModel || {})) {
+		const [m] = k.split("|");
+		total += bucketCost(b, models[m] || defaultModel);
+	}
+	const day = (summary.days || {})[beijingDayKey(Date.now())];
+	let today = null;
+	if (day) {
+		if (day.byModel) {
+			today = 0;
+			for (const [m, b] of Object.entries(day.byModel)) today += bucketCost(b, models[m] || defaultModel);
 		} else {
-			return state;
+			today = bucketCost(day, defaultModel);
 		}
-		const period = isPeakHour(beijingHourOf(event.time)) ? "peak" : "offPeak";
-		const buckets = bucketsFrom(usage);
-		const previous = state.last !== null && state.last.turn === turn && state.last.step === step ? state.last : void 0;
-		if (previous !== void 0 && previous.period === period && bucketsEqual(previous.buckets, buckets)) return state;
-		const totals = { peak: state.totals.peak, offPeak: state.totals.offPeak };
-		if (previous !== void 0) totals[previous.period] = subtractBucket(totals[previous.period], previous.buckets);
-		totals[period] = addBucket(totals[period], buckets);
-		return { totals, last: { turn, step, period, buckets } };
-	},
-	view: (state) => state.totals,
-	stateVersion: 1
-};
+	}
+	return { total, today, currency };
+}
 
-function apply(ctx) {
-	ctx.inject(["sessionProjections"], (projectionCtx) => {
-		projectionCtx.sessionProjections.register(tokenUsageByPeriodProjection);
-	});
+const usageCache = { data: null, at: 0, currency: null };
+const USAGE_CACHE_TTL_MS = 30000;
 
+function tokenNameFile() {
+	return join(dshHome(), "deepseek-balance.json");
+}
+
+function readTokenName() {
+	try {
+		const p = tokenNameFile();
+		if (!existsSync(p)) return null;
+		const d = JSON.parse(readFileSync(p, "utf8"));
+		return typeof d.tokenName === "string" && d.tokenName.trim() ? d.tokenName.trim() : null;
+	} catch { return null; }
+}
+
+function writeTokenName(name) {
+	try { mkdirSync(dshHome(), { recursive: true }); } catch {}
+	writeFileSync(tokenNameFile(), JSON.stringify({ tokenName: name }), "utf8");
+}
+
+function resolveTokenName(config) {
+	return readTokenName() || config.tokenName || "API key";
+}
+
+async function maskApiKey(ctx) {
+	try {
+		const { apiKey } = await resolveDeepSeekFacts(ctx);
+		return apiKey.length > 12 ? `${apiKey.slice(0, 8)}*****${apiKey.slice(-4)}` : `${apiKey.slice(0, 8)}****`;
+	} catch {
+		return null;
+	}
+}
+
+function apply(ctx, config = {}) {
 	const balanceHandler = async (req, res) => {
 		if (req.method !== "GET" && req.method !== "HEAD") {
 			json(res, 405, { error: "method not allowed" });
@@ -383,6 +656,7 @@ function apply(ctx) {
 				json(res, upstream.status === 401 || upstream.status === 403 ? 401 : 502, { error: message });
 				return;
 			}
+			if (typeof body?.currency === "string" && body.currency.length > 0) usageCache.currency = body.currency;
 			json(res, 200, body);
 		} catch (error) {
 			json(res, 502, { error: error instanceof Error ? error.message : String(error) });
@@ -413,6 +687,104 @@ function apply(ctx) {
 	ctx.effect(() => ctx.webServer.register({ kind: "exact", path: "/api/deepseek-balance", handler: balanceHandler }), "deepseek-balance: /api/deepseek-balance route");
 	ctx.effect(() => ctx.webServer.register({ kind: "exact", path: "/api/deepseek-pricing", handler: pricingHandler }), "deepseek-balance: /api/deepseek-pricing route");
 
+	const usageHandler = async (req, res) => {
+		if (req.method !== "GET" && req.method !== "HEAD") {
+			json(res, 405, { error: "method not allowed" });
+			return;
+		}
+		if (!isTrustedRead(req)) {
+			json(res, 403, { error: "forbidden" });
+			return;
+		}
+		if (usageCache.at === 0 || Date.now() - usageCache.at > USAGE_CACHE_TTL_MS) {
+			try {
+				const ws = ctx.get("workspaceRegistry");
+				usageCache.data = aggregateSessions(ws?.archivedSessionIds ?? []);
+				usageCache.data.spend = computeSpend(usageCache.data, usageCache.currency || "CNY");
+				usageCache.at = Date.now();
+			} catch (error) {
+				if (ctx?.logger?.warn) ctx.logger.warn(`deepseek-balance: usage aggregation failed: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+		const key = await maskApiKey(ctx);
+		let payload = usageCache.data;
+		if (!payload) {
+			payload = aggregateSessions();
+			payload.spend = computeSpend(payload, usageCache.currency || "CNY");
+		}
+		let query = null;
+		try { query = new URL(req.url, "http://dsh.local").searchParams; } catch {}
+		const sessionId = query ? query.get("session") : null;
+		if (sessionId && sessionId.length > 0) {
+			const s = (payload.sessions || []).find((x) => x.id === sessionId);
+			if (s) {
+				json(res, 200, {
+					id: s.id,
+					title: s.title,
+					tokens: s.tokens,
+					spend: computeSpend({ byModel: s.byModel || {} }, usageCache.currency || "CNY"),
+					apiKeyPreview: key,
+					tokenName: resolveTokenName(config),
+					effectiveFrom: pricing.data.effectiveFrom, weekendFrom: pricing.data.weekendFrom,
+					fetchedAt: usageCache.at,
+					source: pricing.source
+				});
+				return;
+			}
+			json(res, 200, {
+				id: sessionId,
+				title: sessionId,
+				tokens: 0,
+				spend: { total: 0, today: null, currency: usageCache.currency || "CNY" },
+				apiKeyPreview: key,
+				tokenName: resolveTokenName(config),
+				effectiveFrom: pricing.data.effectiveFrom,
+				fetchedAt: usageCache.at,
+				source: pricing.source
+			});
+			return;
+		}
+		json(res, 200, {
+			...payload,
+			apiKeyPreview: key,
+			tokenName: resolveTokenName(config),
+			effectiveFrom: pricing.data.effectiveFrom,
+			fetchedAt: usageCache.at,
+			source: pricing.source
+		});
+	};
+
+	ctx.effect(() => ctx.webServer.register({ kind: "exact", path: "/api/deepseek-usage", handler: usageHandler }), "deepseek-balance: /api/deepseek-usage route");
+
+	const tokenNameHandler = async (req, res) => {
+		if (!isTrustedRead(req)) {
+			json(res, 403, { error: "forbidden" });
+			return;
+		}
+		if (req.method === "GET" || req.method === "HEAD") {
+			json(res, 200, { tokenName: resolveTokenName(config) });
+			return;
+		}
+		if (req.method === "POST") {
+			let raw = "";
+			try {
+				const chunks = [];
+				for await (const c of req) chunks.push(c);
+				raw = Buffer.concat(chunks).toString("utf8");
+				const body = raw ? JSON.parse(raw) : {};
+				const name = typeof body.tokenName === "string" && body.tokenName.trim() ? body.tokenName.trim().slice(0, 64) : "API key";
+				writeTokenName(name);
+				json(res, 200, { tokenName: name });
+			} catch (error) {
+				json(res, 400, { error: error instanceof Error ? error.message : String(error) });
+			}
+			return;
+		}
+		json(res, 405, { error: "method not allowed" });
+	};
+
+	ctx.effect(() => ctx.webServer.register({ kind: "exact", path: "/api/deepseek-balance/token-name", handler: tokenNameHandler }), "deepseek-balance: /api/deepseek-balance/token-name route");
+
 	ctx.effect(() => {
 		refreshPricing(ctx).catch(() => {});
 		let timer;
@@ -428,4 +800,4 @@ function apply(ctx) {
 	}, "deepseek-balance: daily 01:00 Beijing pricing refresh");
 }
 
-export { apply, inject, name };
+export { Config, apply, inject, name };