@fyeeme/pi-statusline 1.1.1 → 1.2.0

package/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.0] - 2026-08-21
+
+### Added
+
+- Adopt DeepSeek's peak/off-peak pricing (effective 2026-08-17): the price table is split into peak/off-peak columns (flash: cache-hit input ¥0.05/0.10, cache-miss input ¥1.5/3.0, output ¥4.5/9.0; pro: cache-hit input ¥0.15/0.30, cache-miss input ¥4.5/9.0, output ¥13.5/27.0 per million tokens); `isDeepSeekPeakTime()` determines peak hours in Beijing time (UTC+8, no DST; 9:00-12:00, 14:00-18:00), independent of the host timezone.
+- Session cost is recomputed per message using the peak/off-peak rate of the message's own timestamp (`AssistantMessage.timestamp`), so long sessions spanning 9:00/12:00/14:00/18:00 boundaries price each message correctly; the DeepSeek usage segment appends the current period (`peak`/`off-peak`).
+- The registry pricing patch follows the current period (peak or off-peak); the footer render detects period flips and re-aligns the registry so pi's recorded `usage.cost` tracks the period.
+
+### Changed
+
+- Pricing logic refactored into a strategy pattern (new `pricing/` module): the `PricingStrategy` interface (`messageCost`/`defaultCurrency`/`applyPricingPatch`/`shouldRefreshPatch`/`footerTag`) defines each provider's price model; DeepSeek is implemented as `DeepSeekPricingStrategy`, dispatched by provider via `getPricingStrategy()`; `cost.ts` removed. Session stats and rendering depend only on the interface — future DeepSeek price changes or GLM/ZAI pricing models only touch/add the corresponding strategy, never the `token-usage`/`index` core flow.
+
 ## [1.1.1] - 2026-08-08
 
 ### Fixed

package/README.md

@@ -28,6 +28,7 @@ Shows live **account balance** and **weekly token usage**.
 | Weekly tokens | `7d:1.2M` | Local session file scan (rolling 7 days) |
 
 - Currency auto-detected as `¥` (CNY) from the balance API response
+- Session cost follows DeepSeek's peak/off-peak pricing (since 2026-08-17): peak hours are 9:00-12:00 and 14:00-18:00 Beijing time, off-peak is half price. Each message is priced at the rate of its own timestamp; the footer marks the current period (`peak` / `off-peak`).
 - Balance is fetched on startup and refreshed in the background; cached for 5 minutes
 - Triggered when `model.provider === "deepseek"`
 

package/index.ts

@@ -22,11 +22,7 @@ import { DeepSeekUsageProvider } from "./providers/deepseek.ts";
 import { ZaiUsageProvider } from "./providers/zai.ts";
 import type { UsageProvider } from "./providers/types.ts";
 import { SessionTokenUsageCalculator } from "./token-usage.ts";
-import {
-	applyDeepSeekPricingPatch,
-	setCostCurrencyOverride,
-	getCostCurrencyOverride,
-} from "./cost.ts";
+import { deepSeekPricing } from "./pricing/deepseek.ts";
 import { refreshUsage, getCachedUsage, getUsageCacheAge, resetUsageCache } from "./cache.ts";
 import { formatCwd, buildStatLine, buildInfoLine } from "./footer.ts";
 
@@ -51,7 +47,7 @@ let agentRunning = false;
 let lastElapsedSec = 0;
 let lastTps = 0;
 
-const tokenCalculator = new SessionTokenUsageCalculator(() => getCostCurrencyOverride());
+const tokenCalculator = new SessionTokenUsageCalculator(() => deepSeekPricing.getCurrencyOverride());
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -157,20 +153,20 @@ export default function (pi: ExtensionAPI) {
 		handler: async (args, ctx) => {
 			const a = args.trim().toLowerCase();
 			if (a === "auto" || a === "") {
-				setCostCurrencyOverride(undefined);
+				deepSeekPricing.setCurrencyOverride(undefined);
 				ctx.ui.notify("Currency: auto (deepseek→¥ or balance currency)", "info");
 			} else if (a === "¥" || a === "rmb" || a === "cny") {
-				setCostCurrencyOverride("¥");
+				deepSeekPricing.setCurrencyOverride("¥");
 				ctx.ui.notify("Currency: ¥", "info");
 			} else if (a === "$" || a === "usd") {
-				setCostCurrencyOverride("$");
+				deepSeekPricing.setCurrencyOverride("$");
 				ctx.ui.notify("Currency: $", "info");
 			} else {
 				ctx.ui.notify("Usage: /currency [auto|¥|$]", "warning");
 				return;
 			}
-			// 币种变更后立即对齐注册表定价（CNY→覆盖为官方价；USD→还原 pi 内置价）
-			applyDeepSeekPricingPatch(ctx.modelRegistry);
+			// 币种变更后立即对齐注册表定价（CNY→覆盖为当前时段官方价；USD→还原 pi 内置价）
+			deepSeekPricing.applyPricingPatch(ctx.modelRegistry);
 		},
 	});
 
@@ -178,7 +174,7 @@ export default function (pi: ExtensionAPI) {
 	pi.on("model_select", (event) => {
 		if (lastCtx) {
 			lastModel = event.model;
-			applyDeepSeekPricingPatch(lastCtx.modelRegistry);
+			deepSeekPricing.applyPricingPatch(lastCtx.modelRegistry);
 			void refreshUsage(providers, lastCtx.modelRegistry, event.model);
 		}
 	});
@@ -198,7 +194,7 @@ export default function (pi: ExtensionAPI) {
 		lastTps = 0;
 
 		// 根治：运行时修正 deepseek 定价（pi 内置定价低估约 7 倍），使后续 usage.cost 记录全局正确
-		applyDeepSeekPricingPatch(ctx.modelRegistry);
+		deepSeekPricing.applyPricingPatch(ctx.modelRegistry);
 
 		// Prime usage cache on startup (non-blocking)
 		lastCtx = ctx;
@@ -212,6 +208,11 @@ export default function (pi: ExtensionAPI) {
 				dispose: unsub,
 				invalidate() {},
 				render(width: number): string[] {
+					// 峰谷时段翻转（如跨 9:00/12:00/14:00/18:00 边界）后重新对齐注册表定价，使 pi 后续
+					// 记录的 usage.cost 跟随时段；幂等，仅在翻转时 registerProvider 一次。
+					if (deepSeekPricing.shouldRefreshPatch()) {
+						deepSeekPricing.applyPricingPatch(ctx.modelRegistry);
+					}
 					const stats = tokenCalculator.compute(ctx);
 					const cu = ctx.getContextUsage();
 					const model = ctx.model;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fyeeme/pi-statusline",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Rich custom status bar for pi with token usage, cost, DeepSeek balance, context window, and timing.",
   "type": "module",
   "license": "MIT",
@@ -33,6 +33,7 @@
   "files": [
     "*.ts",
     "providers/*.ts",
+    "pricing/*.ts",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"

package/pricing/deepseek.ts

@@ -0,0 +1,162 @@
+/**
+ * DeepSeek 定价策略（跟随结算币种 + 峰谷时段）。
+ *
+ * 背景：pi 内置的 deepseek 定价数据（pi-ai 的 providers/data/deepseek.json）用的是旧版官方 USD 价
+ * （flash $0.14/0.28、pro $0.435/0.87 每百万 tokens）。DeepSeek 账户分 CNY 与 USD 两种结算：
+ *   - CNY 账户按官方 ¥ 价计费，且自 2026-08-17 起实施峰谷计价：高峰时段（北京时间 9:00-12:00、
+ *     14:00-18:00）为官价，空闲时段为高峰的一半（见官方定价页备注）；
+ *   - USD 账户按 USD 计费，pi 内置价负责（本策略不覆盖）。
+ *
+ * 因此所有「修正」都必须跟随结算币种与峰谷时段：
+ *   1. `billedInCny()`：判定是否按 CNY 计价 —— 用户显式 `/currency` 优先；否则按 balance API
+ *      探测到的账户币种（探测失败/未知时按 CNY，保持原有「deepseek → ¥」默认行为）。
+ *   2. `isDeepSeekPeakTime()`：按北京时间（UTC+8，无夏令时）判定指定时刻是否高峰时段。
+ *   3. `messageCost()`：按消息时刻对应的峰谷单价重算单条消息成本（仅 CNY 计价时接管；USD 计价
+ *      返回 null 回退 pi 记录的 cost —— 会话文件里已记录的 cost 无法追溯修正）。
+ *   4. `applyPricingPatch()`：运行时把注册表中 deepseek 模型定价覆盖为当前时段的官方 CNY 价
+ *      （仅 CNY 计价时；USD 计价时还原为 pi 内置 USD 价）。内存补丁，不修改数据文件、pi 升级不丢。
+ */
+import type { Model, Api } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import type { PricedUsage, PricingStrategy } from "./types.ts";
+
+export interface DeepSeekPricedUsage extends PricedUsage {}
+
+export interface DeepSeekCnyPrice {
+	/** 高峰时段单价（元 / 百万 tokens） */
+	peak: DeepSeekPricedUsage;
+	/** 空闲时段单价（元 / 百万 tokens）= 高峰的一半（官方规则） */
+	offPeak: DeepSeekPricedUsage;
+}
+
+/**
+ * DeepSeek 官方 CNY 单价（元 / 百万 tokens），2026-08-17 峰谷计价起生效（见官方定价页）：
+ * 缓存命中输入 / 未命中输入 / 输出；cacheWrite 官方未单列（按 0 计）。
+ */
+export const DEEPSEEK_CNY_PRICES: Record<string, DeepSeekCnyPrice> = {
+	"deepseek-v4-flash": {
+		peak: { input: 3.0, output: 9.0, cacheRead: 0.1, cacheWrite: 0 },
+		offPeak: { input: 1.5, output: 4.5, cacheRead: 0.05, cacheWrite: 0 },
+	},
+	"deepseek-v4-pro": {
+		peak: { input: 9.0, output: 27.0, cacheRead: 0.3, cacheWrite: 0 },
+		offPeak: { input: 4.5, output: 13.5, cacheRead: 0.15, cacheWrite: 0 },
+	},
+};
+
+const PER_MILLION = 1_000_000;
+
+/**
+ * DeepSeek 高峰时段判定：北京时间（UTC+8，无夏令时）9:00-12:00、14:00-18:00 为高峰，
+ * 其余为空闲时段（官方定价页备注）。`at` 可指定时刻，默认当前时间。
+ */
+export function isDeepSeekPeakTime(at: Date = new Date()): boolean {
+	const beijingHour = (at.getUTCHours() + 8) % 24;
+	return (beijingHour >= 9 && beijingHour < 12) || (beijingHour >= 14 && beijingHour < 18);
+}
+
+export class DeepSeekPricingStrategy implements PricingStrategy {
+	readonly providerId = "deepseek";
+
+	/** balance API 探测到的账户结算币种（CNY / USD / 其他）。 */
+	private detectedCurrency: string | null = null;
+	/** 用户显式 `/currency` 设置，覆盖自动判定。 */
+	private currencyOverride: "¥" | "$" | undefined = undefined;
+	/** 首次 applyPricingPatch 时缓存的原始模型定义（用于 USD 计价时还原）。 */
+	private originalModels: Model<Api>[] | null = null;
+	/** 上次注册表补丁写入时的时段（用于峰谷翻转后廉价重新对齐）。 */
+	private lastPatchedPeriod: "peak" | "offPeak" | null = null;
+
+	/** 记录 balance API 探测到的账户结算币种（fetchUsage 成功后写入；null 表示未知）。 */
+	setDetectedCurrency(currency: string | null): void {
+		this.detectedCurrency = currency;
+	}
+
+	/** 设置用户显式币种偏好（`/currency` 命令）；undefined 恢复自动判定。 */
+	setCurrencyOverride(override: "¥" | "$" | undefined): void {
+		this.currencyOverride = override;
+	}
+
+	/** 当前用户显式币种偏好（undefined = 自动）。 */
+	getCurrencyOverride(): "¥" | "$" | undefined {
+		return this.currencyOverride;
+	}
+
+	/**
+	 * 是否按 CNY 计价：用户显式偏好优先；否则仅当探测明确为 USD 时按 USD 计价，
+	 * 其余情况（CNY 或未知）按 CNY —— 保持原有「deepseek → ¥」的默认行为。
+	 */
+	billedInCny(): boolean {
+		if (this.currencyOverride === "$") return false;
+		if (this.currencyOverride === "¥") return true;
+		return this.detectedCurrency !== "USD";
+	}
+
+	/** 重置策略状态与补丁缓存（测试用）。 */
+	reset(): void {
+		this.detectedCurrency = null;
+		this.currencyOverride = undefined;
+		this.originalModels = null;
+		this.lastPatchedPeriod = null;
+	}
+
+	messageCost(model: string | undefined, usage: PricedUsage, at: Date): number | null {
+		// 仅 CNY 计价时接管重算；USD 结算用户沿用 pi 记录的 cost
+		if (!this.billedInCny()) return null;
+		if (!model) return null;
+		const p = DEEPSEEK_CNY_PRICES[model];
+		if (!p) return null;
+		const rates = isDeepSeekPeakTime(at) ? p.peak : p.offPeak;
+		return (
+			(rates.input * usage.input +
+				rates.output * usage.output +
+				rates.cacheRead * usage.cacheRead +
+				rates.cacheWrite * usage.cacheWrite) /
+			PER_MILLION
+		);
+	}
+
+	defaultCurrency(): "¥" | "$" | null {
+		return this.billedInCny() ? "¥" : null;
+	}
+
+	applyPricingPatch(registry: ModelRegistry): void {
+		const dsModels = registry.getAll().filter((m) => m.provider === this.providerId);
+		if (dsModels.length === 0) return;
+		if (!this.originalModels) {
+			this.originalModels = dsModels;
+		} else {
+			// Merge in deepseek models added after the first snapshot, so a later
+			// re-patch（时段翻转 / 币种切换 / model_select / 探测后纠正）不会丢掉它们：
+			// registerProvider 是整表替换，用陈旧快照 map 会把新增模型从 registry 里静默删掉。
+			const known = new Set(this.originalModels.map((m) => m.id));
+			for (const m of dsModels) if (!known.has(m.id)) this.originalModels.push(m);
+		}
+
+		const billedInCny = this.billedInCny();
+		const peak = isDeepSeekPeakTime();
+		this.lastPatchedPeriod = peak ? "peak" : "offPeak";
+		const models = this.originalModels.map((m) => {
+			if (!billedInCny) return m;
+			const cny = DEEPSEEK_CNY_PRICES[m.id];
+			if (!cny) return m;
+			const rates = peak ? cny.peak : cny.offPeak;
+			return { ...m, cost: { ...m.cost, ...rates } };
+		});
+		registry.registerProvider("deepseek", { models });
+	}
+
+	shouldRefreshPatch(): boolean {
+		if (this.lastPatchedPeriod === null) return false;
+		return isDeepSeekPeakTime() !== (this.lastPatchedPeriod === "peak");
+	}
+
+	footerTag(): string | null {
+		// 峰谷计价（2026-08-17 起）生效后，标注当前时段：CNY 计价按官方峰谷价重算，直接可见；
+		// USD 计价走 pi 内置价（无峰谷概念），不标注避免误导。
+		return this.billedInCny() ? (isDeepSeekPeakTime() ? "peak" : "off-peak") : null;
+	}
+}
+
+/** DeepSeek 定价策略单例（注册表与消费方共用同一份状态）。 */
+export const deepSeekPricing = new DeepSeekPricingStrategy();

package/pricing/index.ts

@@ -0,0 +1,16 @@
+import type { PricingStrategy } from "./types.ts";
+import { deepSeekPricing } from "./deepseek.ts";
+
+/**
+ * 已注册的定价策略（按 provider id 索引）。新 provider 引入自有价格体系（如未来 GLM/ZAI
+ * 跟进峰谷计价）时，实现 `PricingStrategy` 并在此注册，会话统计与渲染无需改动。
+ */
+export const pricingStrategies: Record<string, PricingStrategy> = {
+	[deepSeekPricing.providerId]: deepSeekPricing,
+};
+
+/** 按 provider id 取定价策略（大小写不敏感）；未注册返回 undefined（成本走 pi 记录值、币种走 `$`）。 */
+export function getPricingStrategy(provider: string | undefined): PricingStrategy | undefined {
+	if (!provider) return undefined;
+	return pricingStrategies[provider.toLowerCase()];
+}

package/pricing/types.ts

@@ -0,0 +1,39 @@
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+
+/** 消息 token 用量分解（会话统计所需的子集）。 */
+export interface PricedUsage {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+}
+
+/**
+ * Provider 定价策略：把「该 provider 当前生效的价格体系」收敛到一个实现里。
+ * 价格调整（如 DeepSeek 2026-08 峰谷计价、未来 GLM/ZAI 调价）只改对应策略，
+ * 会话统计（token-usage）与渲染（index/footer）只依赖本接口，不感知具体 provider。
+ */
+export interface PricingStrategy {
+	/** 适用 provider id（小写，如 `deepseek`）。 */
+	readonly providerId: string;
+
+	/**
+	 * 按消息时刻重算单条消息成本；返回 null 表示不接管（会话统计回退 pi 记录的
+	 * `usage.cost`，如 USD 结算的 DeepSeek 或未实现定价策略的 provider）。
+	 *
+	 * @param at 消息产生时刻；按时段计价的策略（如峰谷）据此选单价
+	 */
+	messageCost(model: string | undefined, usage: PricedUsage, at: Date): number | null;
+
+	/** 该 provider 的成本显示币种偏好；null 表示不接管（通用逻辑按 `$`）。 */
+	defaultCurrency(): "¥" | "$" | null;
+
+	/** 把注册表中该 provider 模型的定价对齐当前价格体系；幂等可逆，无覆盖需求时 no-op。 */
+	applyPricingPatch(registry: ModelRegistry): void;
+
+	/** 注册表定价是否需要按当前状态重新对齐（如峰谷时段翻转）；无则 false。 */
+	shouldRefreshPatch(): boolean;
+
+	/** footer 附加标注（如当前峰谷时段 `峰`/`闲`）；无则 null。 */
+	footerTag(): string | null;
+}

package/providers/deepseek.ts

@@ -1,7 +1,7 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { DeepSeekResult, ProviderUsageResult } from "../types.ts";
 import type { UsageProvider } from "./types.ts";
-import { applyDeepSeekPricingPatch, setDetectedDeepSeekCurrency } from "../cost.ts";
+import { deepSeekPricing } from "../pricing/deepseek.ts";
 import { scanWeeklyTokens } from "../session-scanner.ts";
 import { fmt } from "../footer.ts";
 
@@ -41,11 +41,11 @@ export class DeepSeekUsageProvider implements UsageProvider {
 			if (!info) return null;
 
 			// 记录账户结算币种：CNY 账户按官方 ¥ 价计费；USD 账户保持 pi 内置 USD 价（不覆盖）
-			setDetectedDeepSeekCurrency(info.currency ?? null);
-			// 探测到币种后立即重新对齐注册表定价：session_start 时（detectedDeepSeekCurrency 尚为
-			// null）已按默认 CNY 覆盖过一次；此处按真实币种纠正，避免 USD 账户停在被高估约 7 倍的
-			// CNY 价上，直到下一次 model_select/​/currency 才修正。
-			applyDeepSeekPricingPatch(modelRegistry);
+			deepSeekPricing.setDetectedCurrency(info.currency ?? null);
+			// 探测到币种后立即重新对齐注册表定价：session_start 时（币种尚为 null）已按默认 CNY
+			// 覆盖过一次；此处按真实币种纠正，避免 USD 账户停在被高估约 7 倍的 CNY 价上，直到
+			// 下一次 model_select/​/currency 才修正。
+			deepSeekPricing.applyPricingPatch(modelRegistry);
 
 			const weeklyTokens = scanWeeklyTokens("deepseek");
 
@@ -73,6 +73,9 @@ export class DeepSeekUsageProvider implements UsageProvider {
 			parts.push(balance);
 		}
 		if (weekly) parts.push(weekly);
+		// 峰谷时段标注（如当前为高峰 → "峰"）；USD 计价不标注（见策略 footerTag）
+		const tag = deepSeekPricing.footerTag();
+		if (tag) parts.push(tag);
 
 		return parts.join(" · ");
 	}

package/token-usage.ts

@@ -1,7 +1,7 @@
 import type { AssistantMessage } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { TokenUsage, TokenUsageCalculator } from "./types.ts";
-import { deepSeekBilledInCny, deepseekMessageCostCny } from "./cost.ts";
+import { getPricingStrategy } from "./pricing/index.ts";
 
 export class SessionTokenUsageCalculator implements TokenUsageCalculator {
 	private getCurrencyOverride: () => "\u00a5" | "$" | undefined;
@@ -18,7 +18,8 @@ export class SessionTokenUsageCalculator implements TokenUsageCalculator {
 		let total = 0;
 		let cost = 0;
 
-		const billedInCny = deepSeekBilledInCny();
+		// 定价策略按当前 provider 接管成本重算；未注册（或策略不接管）时回退 pi 记录的 cost。
+		const strategy = getPricingStrategy(ctx.model?.provider);
 
 		// Use getBranch() (current branch only) so token/cost stats exclude abandoned
 		// sibling branches after /fork or /tree navigation. getEntries() would sum
@@ -31,9 +32,12 @@ export class SessionTokenUsageCalculator implements TokenUsageCalculator {
 				cacheRead += m.usage.cacheRead;
 				cacheWrite += m.usage.cacheWrite;
 				total += m.usage.totalTokens;
-				// DeepSeek 仅按 CNY 计价时重算（pi 内置 USD 价低估约 7 倍）；USD 结算用户沿用 pi 记录的 cost
-				const dsCost = billedInCny ? deepseekMessageCostCny(m.model, m.usage) : null;
-				cost += dsCost !== null ? dsCost : (m.usage.cost?.total ?? 0);
+				// 策略接管时按消息时刻重算（如 DeepSeek CNY 峰谷价：跨 9:00/12:00/14:00/18:00
+				// 边界的长会话各条消息各算各的）；否则沿用 pi 记录的 cost。
+				const priced = strategy
+					? strategy.messageCost(m.model, m.usage, m.timestamp ? new Date(m.timestamp) : new Date())
+					: null;
+				cost += priced !== null ? priced : (m.usage.cost?.total ?? 0);
 			}
 		}
 
@@ -44,8 +48,7 @@ export class SessionTokenUsageCalculator implements TokenUsageCalculator {
 		if (override) {
 			currency = override;
 		} else {
-			const p = ctx.model?.provider ?? "";
-			if (p.toLowerCase().includes("deepseek")) currency = billedInCny ? "\u00a5" : "$";
+			currency = strategy?.defaultCurrency() ?? "$";
 		}
 
 		return { input, output, cacheRead, cacheWrite, total, hitRate, cost, currency };

package/cost.ts

@@ -1,135 +0,0 @@
-/**
- * DeepSeek 定价修正（跟随结算币种）。
- *
- * 背景：pi 内置的 deepseek 定价数据（pi-ai 的 providers/data/deepseek.json）用的是官方 USD 价
- * （flash $0.14/0.28/0.0028、pro $0.435/0.87/0.003625 每百万 tokens）。DeepSeek 账户分 CNY 与 USD
- * 两种结算：CNY 账户按 ¥1/¥2/¥0.02、¥3/¥6/¥0.025 计费，此时 pi 记录的成本低估约 7 倍；USD 账户
- * 按 USD 计费，pi 内置价本来就是对的。
- *
- * 因此所有"修正"都必须跟随结算币种：
- *   1. `deepSeekBilledInCny()`：判定 DeepSeek 是否按 CNY 计价 —— 用户显式 `/currency` 优先；
- *      否则按 balance API 探测到的账户币种（探测失败/未知时按 CNY，保持原行为）。
- *   2. `deepseekMessageCostCny`：按官方 CNY 单价重算单条消息成本（仅 CNY 计价时用于兜底存量消息，
- *      会话文件里已记录的 cost 无法追溯修正）。
- *   3. `applyDeepSeekPricingPatch`：运行时把注册表中 deepseek 模型定价覆盖为官方 CNY 价（仅 CNY
- *      计价时；USD 计价时还原为 pi 内置 USD 价）。内存补丁，不修改数据文件、pi 升级不丢。
- */
-import type { Model, Api } from "@earendil-works/pi-ai";
-import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
-
-export interface DeepSeekPricedUsage {
-	input: number;
-	output: number;
-	cacheRead: number;
-	cacheWrite: number;
-}
-
-/** DeepSeek 官方 CNY 单价（元 / 百万 tokens）：缓存命中输入 / 未命中输入 / 输出（见官方定价页）。 */
-export const DEEPSEEK_CNY_PRICES: Record<string, DeepSeekPricedUsage> = {
-	"deepseek-v4-flash": { input: 1, output: 2, cacheRead: 0.02, cacheWrite: 0 },
-	"deepseek-v4-pro": { input: 3, output: 6, cacheRead: 0.025, cacheWrite: 0 },
-};
-
-const PER_MILLION = 1_000_000;
-
-// ---------------------------------------------------------------------------
-// 结算币种状态（DeepSeek）
-// ---------------------------------------------------------------------------
-
-/** balance API 探测到的账户结算币种（CNY / USD / 其他）。 */
-let detectedDeepSeekCurrency: string | null = null;
-/** 用户显式 `/currency` 设置，覆盖自动判定。 */
-let costCurrencyOverride: "¥" | "$" | undefined = undefined;
-/** 首次 applyDeepSeekPricingPatch 时缓存的原始模型定义（用于 USD 计价时还原）。 */
-let originalDeepSeekModels: Model<Api>[] | null = null;
-
-/** 记录 balance API 探测到的 DeepSeek 账户结算币种（fetchUsage 成功后写入；null 表示未知）。 */
-export function setDetectedDeepSeekCurrency(currency: string | null): void {
-	detectedDeepSeekCurrency = currency;
-}
-
-/** 设置用户显式币种偏好（`/currency` 命令）；undefined 恢复自动判定。 */
-export function setCostCurrencyOverride(override: "¥" | "$" | undefined): void {
-	costCurrencyOverride = override;
-}
-
-/** 当前用户显式币种偏好（undefined = 自动）。 */
-export function getCostCurrencyOverride(): "¥" | "$" | undefined {
-	return costCurrencyOverride;
-}
-
-/**
- * DeepSeek 是否按 CNY 计价：用户显式偏好优先；否则仅当探测明确为 USD 时按 USD 计价，
- * 其余情况（CNY 或未知）按 CNY —— 保持原有"deepseek → ¥"的默认行为。
- */
-export function deepSeekBilledInCny(): boolean {
-	if (costCurrencyOverride === "$") return false;
-	if (costCurrencyOverride === "¥") return true;
-	return detectedDeepSeekCurrency !== "USD";
-}
-
-/** 重置币种状态与补丁缓存（测试用）。 */
-export function resetDeepSeekPricingState(): void {
-	detectedDeepSeekCurrency = null;
-	costCurrencyOverride = undefined;
-	originalDeepSeekModels = null;
-}
-
-// ---------------------------------------------------------------------------
-// 单条消息成本重算
-// ---------------------------------------------------------------------------
-
-/**
- * 按官方 CNY 单价重算单条消息成本；模型不在定价表内返回 null（调用方回退 `m.usage.cost`）。
- *
- * @param model 消息模型 id（如 `deepseek-v4-flash`）
- * @param usage 消息的 token 用量分解
- */
-export function deepseekMessageCostCny(
-	model: string | undefined,
-	usage: DeepSeekPricedUsage,
-): number | null {
-	if (!model) return null;
-	const p = DEEPSEEK_CNY_PRICES[model];
-	if (!p) return null;
-	return (
-		(p.input * usage.input +
-			p.output * usage.output +
-			p.cacheRead * usage.cacheRead +
-			p.cacheWrite * usage.cacheWrite) /
-		PER_MILLION
-	);
-}
-
-// ---------------------------------------------------------------------------
-// 运行时注册表补丁（根治 pi 内置定价，可逆、跟随结算币种）
-// ---------------------------------------------------------------------------
-
-/**
- * 把注册表中 deepseek 模型的定价与结算币种对齐：
- *  - CNY 计价：cost 覆盖为官方 CNY 价；
- *  - USD 计价：还原为 pi 内置 USD 价（首次调用时缓存原始定义，之后不再被 CNY 覆盖）。
- * 未知/未来新增模型原样保留；重复调用幂等；注册表未加载模型时静默跳过（由调用方后续重试）。
- */
-export function applyDeepSeekPricingPatch(registry: ModelRegistry): void {
-	const dsModels = registry.getAll().filter((m) => m.provider === "deepseek");
-	if (dsModels.length === 0) return;
-	if (!originalDeepSeekModels) {
-		originalDeepSeekModels = dsModels;
-	} else {
-		// Merge in deepseek models added after the first snapshot, so a later
-		// re-patch（币种切换 / model_select / 探测后纠正）不会丢掉它们：registerProvider
-		// 是整表替换，用陈旧快照 map 会把新增模型从 registry 里静默删掉。
-		const known = new Set(originalDeepSeekModels.map((m) => m.id));
-		for (const m of dsModels) if (!known.has(m.id)) originalDeepSeekModels.push(m);
-	}
-
-	const billedInCny = deepSeekBilledInCny();
-	const models = originalDeepSeekModels.map((m) => {
-		if (!billedInCny) return m;
-		const cny = DEEPSEEK_CNY_PRICES[m.id];
-		if (!cny) return m;
-		return { ...m, cost: { ...m.cost, ...cny } };
-	});
-	registry.registerProvider("deepseek", { models });
-}