balance-dsh 1.0.9 → 1.1.0

package/lib/client.js

@@ -111,12 +111,13 @@ window.__ModuleLoader__.load({
     }
 
     // ─── 价格（与服务端默认保持一致；服务端 /balance-api 返回后会覆盖） ───
-    // 2026-08-17 生效的 DeepSeek V4-Flash 空闲时段价（元/百万 tokens）
+    // 北京时间 2026-09-10 12:00 起生效的 DeepSeek V4-Flash 空闲时段价（元/百万 tokens）
+    // 注：历史消耗由服务端按当时价格回传 cost；这里的默认值只用于拉不到服务端分桶时的本地估算。
     const DEFAULT_PRICING = {
-      inputCnyPerMillion: 1.5, // 输入（缓存未命中）
-      cacheReadCnyPerMillion: 0.05, // 输入（缓存命中）
+      inputCnyPerMillion: 1, // 输入（缓存未命中）
+      cacheReadCnyPerMillion: 0.02, // 输入（缓存命中）
       cacheWriteCnyPerMillion: 0, // DeepSeek 无缓存写入计费
-      outputCnyPerMillion: 4.5, // 输出
+      outputCnyPerMillion: 4, // 输出
     };
 
     let pricing = DEFAULT_PRICING;
@@ -808,9 +809,12 @@ function UsageCostLine({ useProjection, sessionId }) {
 
       // 金额：优先用服务端分时段 usage（高峰桶×2+空闲桶）；未就绪时按当前时段价估算
       const split = splitReady && splitUsage ? splitUsage : null;
-      const cost = split ? computeSplitCost(split, p) : computeCost(usage, periodAdjustedPricing(p));
-      const peakTokens = split ? split.peak.inputTokens + split.peak.cacheReadTokens + split.peak.cacheWriteTokens + split.peak.outputTokens : 0;
-      const offpeakTokens = split ? split.offpeak.inputTokens + split.offpeak.cacheReadTokens + split.offpeak.cacheWriteTokens + split.offpeak.outputTokens : 0;
+      // 服务端分桶可能"非 null 但为空"（拿不到该会话事件），此时必须回退本地投影估算，否则金额会显示 ¥0.0000
+      const splitUsable =
+        split != null && ((Array.isArray(split.byModel) && split.byModel.length > 0) || (split.totalTokens ?? 0) > 0);
+      const cost = splitUsable ? computeSplitCost(split, p) : computeCost(usage, periodAdjustedPricing(p));
+      const peakTokens = splitUsable ? split.peak.inputTokens + split.peak.cacheReadTokens + split.peak.cacheWriteTokens + split.peak.outputTokens : 0;
+      const offpeakTokens = splitUsable ? split.offpeak.inputTokens + split.offpeak.cacheReadTokens + split.offpeak.cacheWriteTokens + split.offpeak.outputTokens : 0;
 
       // 子代理消耗（与主会话分开，同样跨时段精确计费）
       const hasSubagent = splitReady && subagentUsage && subagentUsage.totalTokens > 0;
@@ -825,7 +829,7 @@ function UsageCostLine({ useProjection, sessionId }) {
         "新增：" + formatTokens(newTokens) + " tokens（未缓存输入 " + formatTokens(uncachedInput) + " + 输出 " + formatTokens(output) + "）",
         "计费：" + formatTokens(billedTotal) + " tokens（含缓存重读 " + formatTokens(cacheRead) + "、缓存写入 " + formatTokens(cacheWrite) + "）",
       ];
-      if (split) {
+      if (splitUsable) {
         detailLines.push(
           "时段拆分：高峰 " + formatTokens(peakTokens) + " tokens + 空闲 " + formatTokens(offpeakTokens) + " tokens",
           "估算金额：¥" + cost.toFixed(4) + "（高峰桶按目录价×2、空闲桶按目录价）",

package/lib/index.js

@@ -55,10 +55,10 @@ const DEEPSEEK_BALANCE_URL = "https://api.deepseek.com/user/balance";
 // DeepSeek 目录价（人民币/百万 tokens），按模型区分。默认取 2026-08-17 生效的
 // V4 峰谷定价之空闲时段价；高峰时段（每日 9:00 / 14:00）价格为下表 2 倍，
 // 可在 config.peak: true 时统一翻倍，或在 config.price 中逐项覆盖。
-// V4-Flash 空闲：输入未命中 1.5 / 命中 0.05 / 输出 4.5
-// V4-Pro   空闲：输入未命中 4.5 / 命中 0.15 / 输出 13.5
+// V4-Flash 空闲：输入未命中 1 / 命中 0.02 / 输出 4（北京时间 2026-09-10 12:00 起的新价）
+// V4-Pro   空闲：输入未命中 4.5 / 命中 0.15 / 输出 13.5（官方 2026-09-14 后继续提供，计费不变）
 const MODEL_PRICING = {
-  "deepseek-v4-flash": { inputCnyPerMillion: 1.5, cacheReadCnyPerMillion: 0.05, cacheWriteCnyPerMillion: 0, outputCnyPerMillion: 4.5 },
+  "deepseek-v4-flash": { inputCnyPerMillion: 1, cacheReadCnyPerMillion: 0.02, cacheWriteCnyPerMillion: 0, outputCnyPerMillion: 4 },
   "deepseek-v4-pro": { inputCnyPerMillion: 4.5, cacheReadCnyPerMillion: 0.15, cacheWriteCnyPerMillion: 0, outputCnyPerMillion: 13.5 },
   // 旧模型兜底（V3.2 时代目录价）
   "deepseek-chat": { inputCnyPerMillion: 2, cacheReadCnyPerMillion: 0.5, cacheWriteCnyPerMillion: 0, outputCnyPerMillion: 3 },
@@ -66,6 +66,18 @@ const MODEL_PRICING = {
 };
 const FALLBACK_PRICING = MODEL_PRICING["deepseek-v4-flash"];
 
+// 定价历史：官方自北京时间 2026-09-10 12:00 起下调 flash 系列价格。
+// 调价前产生的 token 仍按当时旧价计算（历史消耗金额不因后续调价而改变），
+// 之后的消耗用 MODEL_PRICING（新价）。按每条 usage 的事件时间戳自动选择。
+const FLASH_REPRICED_AT = Date.parse("2026-09-10T12:00:00+08:00");
+const LEGACY_MODEL_PRICING = {
+  "deepseek-v4-flash": { inputCnyPerMillion: 1.5, cacheReadCnyPerMillion: 0.05, cacheWriteCnyPerMillion: 0, outputCnyPerMillion: 4.5 },
+};
+/** 事件时间在调价前返回 "legacy"（旧价），之后返回 "current"（新价）。 */
+function pricingEraAt(time) {
+  return Number(time) < FLASH_REPRICED_AT ? "legacy" : "current";
+}
+
 // 高峰/空闲时段（V4 峰谷定价，2026-08-17 生效）：高峰价 = 空闲价 × 2。
 // 官方高峰窗口（北京时间）为 周一至周五 09:00-12:00、14:00-18:00；周末全天空闲。
 // 可用 config.peakWindows 覆盖小时窗口（如 [{start:9,end:12},{start:14,end:18}]），
@@ -91,19 +103,23 @@ function isPeakAt(timeMs, config) {
   return weekdays.includes(weekday) && windows.some((w) => hour >= w.start && hour < w.end);
 }
 
-/** 把模型字符串规整到定价表键；未识别返回 ""（用 Flash 价兜底）。 */
+/** 把模型字符串规整到定价表键；未识别返回 ""（用 Flash 价兜底）。
+ *  注意：官方已把 Flash 主名改为 `deepseek-flash`，旧名 `deepseek-v4-flash` /
+ *  `deepseek-v4-flash-vision-exp` 虽已退役但仍按 Flash 价计费，因此统一按 "flash" 匹配。 */
 function modelKey(model) {
   const m = String(model || "").toLowerCase();
-  if (m.includes("v4-pro") || m.includes("v4pro")) return "deepseek-v4-pro";
-  if (m.includes("v4-flash") || m.includes("v4flash")) return "deepseek-v4-flash";
+  if (m.includes("v4-pro") || m.includes("v4pro") || m.includes("-pro")) return "deepseek-v4-pro";
+  if (m.includes("flash")) return "deepseek-v4-flash";
   if (m.includes("reasoner")) return "deepseek-reasoner";
   if (m.includes("chat")) return "deepseek-chat";
   return "";
 }
 
-/** 解析价格：模型基价 + config.price 覆盖，config.peak: true 时按高峰价翻倍。 */
-function resolvePricing(config, model = "") {
-  const base = MODEL_PRICING[modelKey(model)] ?? FALLBACK_PRICING;
+/** 解析价格：模型基价 + config.price 覆盖，config.peak: true 时按高峰价翻倍。
+ *  era = "legacy" 时取调价前的历史价（目前仅 flash 系列与现价不同）。 */
+function resolvePricing(config, model = "", era = "current") {
+  const key = modelKey(model);
+  const base = (era === "legacy" && LEGACY_MODEL_PRICING[key]) || MODEL_PRICING[key] || FALLBACK_PRICING;
   const price = config?.price ?? {};
   const multiplier = config?.peak === true ? 2 : 1;
   const pick = (name, fallback) => Number(price[name] ?? fallback) * multiplier;
@@ -115,9 +131,25 @@ function resolvePricing(config, model = "") {
   };
 }
 
+/** 取会话事件数组。DSH 2.0.4 起 live session **不再有 `.events` 属性**，改用 `snapshotEvents()` 方法
+ *  （签名 `snapshotEvents(fromSeq = 0, toSeqExclusive = seq)`，可无参调用取全部事件）；
+ *  旧版仍读 `.events` 属性。两者都拿不到时返回空数组（由调用方降级）。 */
+function sessionEvents(session) {
+  if (!session) return [];
+  if (typeof session.snapshotEvents === "function") {
+    try {
+      const events = session.snapshotEvents();
+      if (Array.isArray(events)) return events;
+    } catch {
+      // 落到旧属性兜底
+    }
+  }
+  return Array.isArray(session.events) ? session.events : [];
+}
+
 /** 从会话中识别实际使用的模型。
  *  优先用 DSH 会话的 requestHeader()/requestContext() 折叠结果（即官方 session.models 取 current 的同一来源），
- *  取不到再回退遍历 session.events 找 request/header / request/context 事件。 */
+ *  取不到再回退遍历会话事件找 request/header / request/context 事件。 */
 function detectModel(session) {
   if (!session) return "";
   // 1) DSH 官方折叠 API：requestHeader().config.model 或 requestContext().model
@@ -133,7 +165,7 @@ function detectModel(session) {
   }
   // 2) 兜底：遍历事件
   let model = "";
-  for (const event of session?.events ?? []) {
+  for (const event of sessionEvents(session)) {
     if (event.type === "request/header") {
       const m = event.data?.header?.config?.model;
       if (typeof m === "string" && m !== "") model = m;
@@ -272,11 +304,14 @@ function sumEventsUsage(events, config, fallbackModel = "") {
     bucket.cacheWriteTokens += usage.cacheWriteTokens ?? 0;
   };
   const empty = () => ({ inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 });
-  const byModel = new Map(); // model -> { model, peak, offpeak }
+  const byModel = new Map(); // `${model}\0${era}` -> { model, era, peak, offpeak }
   for (const { usage, time } of latestByStep.values()) {
     const model = modelAtTime(switches, time) || fallback;
-    let e = byModel.get(model);
-    if (!e) { e = { model, peak: empty(), offpeak: empty() }; byModel.set(model, e); }
+    // 同一模型在调价前后的 token 分开分桶，各自用当时的价格计算（历史金额不变）。
+    const era = pricingEraAt(time);
+    const key = `${model}\u0000${era}`;
+    let e = byModel.get(key);
+    if (!e) { e = { model, era, peak: empty(), offpeak: empty() }; byModel.set(key, e); }
     add(isPeakAt(time, config) ? e.peak : e.offpeak, usage);
   }
   // 聚合 + 转换 byModel（按金额未在前面算，这里只分桶 + 汇总字段）
@@ -284,7 +319,7 @@ function sumEventsUsage(events, config, fallbackModel = "") {
   const offpeak = empty();
   const modelList = [];
   for (const e of byModel.values()) {
-    modelList.push({ model: e.model, peak: e.peak, offpeak: e.offpeak });
+    modelList.push({ model: e.model, era: e.era, peak: e.peak, offpeak: e.offpeak, cost: estimateCost(e, resolvePricing(config, e.model, e.era)) });
     peak.inputTokens += e.peak.inputTokens;
     peak.outputTokens += e.peak.outputTokens;
     peak.cacheReadTokens += e.peak.cacheReadTokens;
@@ -315,7 +350,7 @@ function sumEventsUsage(events, config, fallbackModel = "") {
 function sumSessionUsage(session, config) {
   if (session == null) return null;
   // fallbackModel = detectModel(session)：当 message 早于所有模型切换点时兜底，避免落到默认 flash 价。
-  return sumEventsUsage(session.events ?? [], config, detectModel(session));
+  return sumEventsUsage(sessionEvents(session), config, detectModel(session));
 }
 
 function estimateCost(usage, pricing) {
@@ -385,7 +420,7 @@ function collectDailyUsage(events, config, fallbackModel, cutoffMs, days, sessio
     const model = modelAtTime(switches, time) || fallback;
     const bucket = { peak: emptyTokenBucket(), offpeak: emptyTokenBucket() };
     addTokenUsage(isPeakAt(time, config) ? bucket.peak : bucket.offpeak, usage);
-    day.cost += estimateCost(bucket, resolvePricing(config, model));
+    day.cost += estimateCost(bucket, resolvePricing(config, model, pricingEraAt(time)));
   }
 }
 
@@ -401,16 +436,35 @@ function recentDayKeys(days, now = Date.now()) {
 }
 
 async function buildUsageStats(ctx, config) {
-  const persistence = typeof ctx.get === "function" ? ctx.get("sessionPersistence") : void 0;
-  if (persistence == null || typeof persistence.list !== "function" || typeof persistence.inspect !== "function") {
-    throw new Error("会话持久化服务不可用");
-  }
+  const getService = typeof ctx.get === "function" ? ctx.get.bind(ctx) : null;
+  const controller = getService?.("sessionController");
+  const persistence = getService?.("sessionPersistence");
   const now = Date.now();
   const cutoffMs = now - (STATS_DAYS - 1) * 24 * 60 * 60 * 1000;
-  const headers = await persistence.list();
-  const selected = [...headers]
-    .filter((header) => header && typeof header.id === "string")
-    .sort((a, b) => Number(b.createdAt ?? 0) - Number(a.createdAt ?? 0))
+  // 列举会话要跨 DSH 版本：新版 sessionController.list() 返回 { items:[{ sessionId, updatedAt }] }
+  // （已按活动降序，字段叫 sessionId）；旧版 sessionPersistence.list() 返回 [{ id, createdAt }]
+  // （字段叫 id）。旧版 persistence 还提供 inspect()，新版改成 handle-based 的 open()，
+  // 所以读取一律走已做三级兼容的 inspectPersistedSession，不再直接调 persistence.inspect。
+  let sessionIds = [];
+  let availableSessions = 0;
+  if (typeof controller?.list === "function") {
+    const listed = await controller.list({});
+    const items = Array.isArray(listed) ? listed : (listed?.items ?? []);
+    sessionIds = items.map((item) => (item && typeof item === "object" ? item.sessionId ?? item.id : void 0));
+    availableSessions = sessionIds.length;
+  } else if (typeof persistence?.list === "function") {
+    const headers = await persistence.list();
+    const list = Array.isArray(headers) ? headers : [];
+    availableSessions = list.length;
+    sessionIds = [...list]
+      .filter((header) => header && typeof header.id === "string")
+      .sort((a, b) => Number(b.createdAt ?? 0) - Number(a.createdAt ?? 0))
+      .map((header) => header.id);
+  } else {
+    throw new Error("会话持久化服务不可用");
+  }
+  const selected = sessionIds
+    .filter((id) => typeof id === "string" && id !== "")
     .slice(0, STATS_MAX_SESSIONS);
   const daily = new Map();
   let cursor = 0;
@@ -418,16 +472,16 @@ async function buildUsageStats(ctx, config) {
   let failedSessions = 0;
   const worker = async () => {
     while (cursor < selected.length) {
-      const header = selected[cursor++];
+      const sessionId = selected[cursor++];
       try {
-        const inspected = await persistence.inspect(header.id);
+        const inspected = await inspectPersistedSession(ctx, sessionId);
         collectDailyUsage(
           inspected?.events ?? [],
           config,
           detectModel({ requestHeader: () => void 0, requestContext: () => void 0, events: inspected?.events ?? [] }),
           cutoffMs,
           daily,
-          header.id,
+          sessionId,
         );
         scannedSessions++;
       } catch {
@@ -468,8 +522,8 @@ async function buildUsageStats(ctx, config) {
     rangeDays: STATS_DAYS,
     scannedSessions,
     failedSessions,
-    availableSessions: headers.length,
-    limited: headers.length > selected.length,
+    availableSessions,
+    limited: availableSessions > selected.length,
     generatedAt: now,
   };
 }
@@ -564,7 +618,15 @@ async function sumSubagentUsage(ctx, sessionId, config) {
 }
 
 function formatUsage(usage, pricing, model = "") {
-  const cost = estimateCost(usage, pricing);
+  // 优先按 byModel 逐段累加（每段用各自模型 + 价格时代的价格，历史消耗不因调价而变）；
+  // 无 byModel 时回退单一价格估算（兼容旧数据）。
+  const cost =
+    Array.isArray(usage.byModel) && usage.byModel.length > 0
+      ? usage.byModel.reduce(
+          (sum, b) => sum + (typeof b.cost === "number" && Number.isFinite(b.cost) ? b.cost : estimateCost(b, pricing)),
+          0,
+        )
+      : estimateCost(usage, pricing);
   const newTokens = usage.inputTokens + usage.outputTokens;
   const peakTokens = usage.peak.inputTokens + usage.peak.cacheReadTokens + usage.peak.cacheWriteTokens + usage.peak.outputTokens;
   const offpeakTokens = usage.offpeak.inputTokens + usage.offpeak.cacheReadTokens + usage.offpeak.cacheWriteTokens + usage.offpeak.outputTokens;
@@ -710,6 +772,27 @@ export function apply(ctx, config = {}) {
               usage = sumSessionUsage(session, config);
               detectedModel = detectModel(session);
             }
+            // DSH 2.0.4 起 live session（sessions.get）可能拿不到 events，导致 usage 全 0。
+            // 此时回退从持久化读事件，避免客户端拿到"空但非 null"的 usage 而把金额显示成 ¥0.0000。
+            if (usage == null || usage.totalTokens === 0) {
+              try {
+                const persisted = await inspectPersistedSession(ctx, sessionParam);
+                if (Array.isArray(persisted?.events) && persisted.events.length > 0) {
+                  const persistedUsage = sumEventsUsage(persisted.events, config, detectedModel);
+                  if (persistedUsage.totalTokens > 0) {
+                    usage = persistedUsage;
+                    if (detectedModel === "") {
+                      const switches = collectModelSwitches(persisted.events);
+                      if (switches.length > 0) detectedModel = switches[switches.length - 1].model;
+                    }
+                  }
+                }
+              } catch {
+                // 持久化读取不可用：忽略，走下方统一降级
+              }
+            }
+            // 仍无任何 token 就返回 null，让客户端回退本地投影估算（而不是当成 0 消耗显示 ¥0.0000）
+            if (usage != null && usage.totalTokens === 0) usage = null;
             // 子代理枚举走持久化目录（不依赖 live 会话），即使父会话不在内存也能拿到
             const subRes = await sumSubagentUsage(httpCtx, sessionParam, config);
             subagentUsage = subRes.usage;
@@ -722,10 +805,10 @@ export function apply(ctx, config = {}) {
         const effectiveModel = model || detectedModel;
         // 逐模型标注 cost（高峰期×2、空闲期×1），客户端直接按各模型 cost 累加，无需自己定价。
         if (usage && Array.isArray(usage.byModel)) {
-          usage.byModel = usage.byModel.map((b) => ({ ...b, cost: estimateCost(b, resolvePricing(config, b.model)) }));
+          usage.byModel = usage.byModel.map((b) => ({ ...b, cost: estimateCost(b, resolvePricing(config, b.model, b.era)) }));
         }
         if (subagentUsage && Array.isArray(subagentUsage.byModel)) {
-          subagentUsage.byModel = subagentUsage.byModel.map((b) => ({ ...b, cost: estimateCost(b, resolvePricing(config, b.model)) }));
+          subagentUsage.byModel = subagentUsage.byModel.map((b) => ({ ...b, cost: estimateCost(b, resolvePricing(config, b.model, b.era)) }));
         }
         try {
           const data = await fetchBalance(apiKey);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "balance-dsh",
-  "version": "1.0.9",
+  "version": "1.1.0",
   "description": "查询 DeepSeek 余额并显示当前会话 token 消耗。DeepSeek 账户余额 + 会话 token/费用显示，含高峰/空闲峰谷计费。",
   "author": "Rannist",
   "type": "module",