@dougen/dsh-deepseek-usage 0.1.6 → 0.1.8

package/README.md

@@ -6,10 +6,11 @@ DeepSeek 用量侧边栏插件（DeepSeek Harness Web UI）
 > - 本插件界面文案仅提供**中文**，无多语言版本。
 > - **仅适用于 DSH 的 Web UI**：命令行等其他非WEB界面不支持。
 > - **今日花费为本地估算值**（非官方账单）：按本地会话日志 token × 官方峰谷价格表计算。
+> - **峰谷时段按北京时间（Asia/Shanghai）固定计算**，与服务器本地时区无关。
 
 ## 简介
 
-给 DeepSeek Harness（DSH）**网页界面**用的插件：在**侧边栏底部**常驻显示你的 **DeepSeek 账号用量**卡片 —— 余额、今日花费、今日 Token、今日 API 请求次数与高峰/空闲计费时段指示灯。
+给 DeepSeek Harness（DSH）**网页界面**用的插件：在**侧边栏底部**常驻显示你的 **DeepSeek 账号用量**卡片 —— 余额、今日花费、今日 Token、今日 API 调用次数与高峰/空闲计费时段指示灯。
 
 ## 界面截图
 
@@ -22,7 +23,7 @@ DeepSeek 用量侧边栏插件（DeepSeek Harness Web UI）
 - 第一行：`余额 ¥110.00`
 - 第二行：`今日 ¥2.94 · 36.9M · 170`（今日花费为**本地估算**）
 - 第三行：`↑1.5 · 💾0.05 · ↓4.5`（输入 / 缓存命中 / 输出 单价，按当前启用模型与峰谷时段自动切换）
-- 右上角：高峰/空闲状态指示灯（高峰 9:00–12:00、14:00–18:00 为橙色；其余空闲为绿色；悬停提示时段）
+- 右上角：高峰/空闲状态指示灯（高峰 9:00–12:00、14:00–18:00 **北京时间**为橙色；其余空闲为绿色；悬停提示时段）
 - 每 60 秒自动刷新；点击卡片任意位置也可手动刷新
 - 跟随应用明暗主题（`--dsw-*` 变量，含兜底值）
 
@@ -44,7 +45,6 @@ pnpm pack                                       # 生成 dougen-dsh-deepseek-usa
 dsh plugin --profile web add <生成的 .tgz>
 ```
 
-
 安装之后：
 
 1. 重启网页应用：`dsh web`（bundle 层在启动时读取）。
@@ -59,14 +59,46 @@ dsh plugin --profile web add <生成的 .tgz>
 >       name: @dougen/dsh-deepseek-usage
 > ```
 
-## 数据来源
+## 数据来源与统计口径
 
 | 数据 | 来源 |
 |---|---|
 | 余额 | DeepSeek 官方 `GET /user/balance`（API Key 经凭证服务 `DEEPSEEK_API_KEY` 解析，不出本机） |
 | 今日花费 | **本地估算**：本地会话日志 token × 官方峰谷价格表（非官方账单） |
-| 今日 Token / API 次数 | 本地会话日志统计（官方 API 无用量查询接口），覆盖全部会话，含重启前历史 |
+| 今日 Token / API 调用数 | 本地会话日志统计（官方 API 无用量查询接口），覆盖全部会话，含重启前历史 |
+
+统计口径（v0.1.7 起，与 DSH 官方 token-meter 对齐）：
+
+- **按 (turn, step) 去重**：同一调用的流式 usage 与最终消息只计一次，绝不重复计数；
+- **失败请求的用量也计入**：请求失败、没有最终消息时，流式 usage 样本仍被统计；
+- **今日 = 北京时间（Asia/Shanghai）**的自然日，与服务器时区无关；
+- 模型不在内置价格表时按 `deepseek-chat` 档计价，并在卡片错误提示中明示（避免静默算错）。
+
+## 安全说明
+
+- 用量路由 `GET /api/deepseek-usage` **仅接受本机 Host**（`127.0.0.1` / `localhost` / `::1`），可拦截 DNS rebinding 与局域网直接访问。
+- ⚠️ 若将 DSH 配置为 `host: 0.0.0.0` 对外网开放，本插件会在入口拒绝非本机 Host 的请求，但**请勿依赖插件作为唯一防线**——余额为账号敏感信息，建议用反向代理 + 鉴权保护整个 DSH 服务。
+- ⚠️ 环境变量 `DEEPSEEK_BASE_URL`（与 llm-deepseek 适配器对齐）会把余额请求与 **API Key 一起发给该地址**；仅在你信任该网关/代理时配置。
+
+## 变更记录
+
+### v0.1.8
+
+- **修复 0.1.7 回归：今日用量统计全为 0**。根因：`listSnapshots()` 返回的会话条目是 `{ header: SessionHeader, revision }`，id 位于 `header.id` 嵌套字段；0.1.7 误取顶层 `header.id`（undefined），导致所有会话 `readRaw` 失败被跳过（skipped>0、统计为 0）。已修正并从真实会话日志端到端验证：统计恢复、无读取失败。
+
+### v0.1.7
+
+- **统计口径修正**：按 (turn, step) 去重并吸收流式 usage 样本，失败请求的用量不再漏计（P1）。
+- **性能优化**：按会话修订值增量扫描，只重读变化的会话日志；跨北京日自动失效缓存（P2）。
+- **安全加固**：路由仅接受本机 Host，拦截 DNS rebinding 与局域网访问（P3）。
+- **字段语义修正**：余额响应 `available`（误用官方 `is_available`）改为 `isAvailable` 布尔（P4）。
+- **未知模型提示**：价格表外模型按 chat 档计价并明示，不再静默算错（P5）。
+- **时区修正**：峰谷判定与"今日"边界改为固定北京时间，不随服务器时区漂移（P6）。
+- **依赖声明**：补充 `@deepseek-ai/dsh-host-webserver` peer 依赖（P8）。
+
+### v0.1.6
 
+- 初始发布（审计基线）。
 
 ## 卸载
 

package/lib/index.js

@@ -8,16 +8,16 @@
  * 返回（JSON）：
  *   {
  *     ok: true,
- *     balance: { available, total, currency, granted, toppedUp },   // 官方余额接口
+ *     balance: { isAvailable, total, currency, granted, toppedUp },   // 官方余额接口
  *     today: {
  *       cost,         // 今日花费：本地日志估算（日志 token × 官方峰谷价格表）
  *       costSource: 'estimate' | null,
  *       tokens: { input, output, cacheRead, cacheWrite, total },   // 今日 token 数（本地日志）
- *       calls,        // 今日 API 请求数（本地日志）
+ *       calls,        // 今日有用量报告的 API 调用数（本地日志，按 turn/step 去重）
  *       sessions      // 今日有活动的会话数
  *     },
- *     peak, peakHours,                                              // 峰谷时段
- *     tier: { input, cacheRead, cacheWrite, output },               // 当前模型当前档单价
+ *     peak, peakHours,                                              // 峰谷时段（北京时间）
+ *     tier: { input, cacheRead, cacheWrite, output, model, known }, // 当前模型当前档单价
  *     updatedAt, errors
  *   }
  *
@@ -25,15 +25,37 @@
  * llm-deepseek 同一引用，不出本机）。今日 Token / API 次数只能从本地会话
  * 日志统计（官方无用量查询接口）；今日花费为本地估算：
  * 日志 token × 官方峰谷价格表（见 lib/pricing.js）。
+ *
+ * 统计口径（0.1.7 起，与 DSH 官方 token-meter 对齐）：
+ * - 按 (turn, step) 去重：同一调用的流式 usage chunk 与最终 assistant/message
+ *   只计一次，后者覆盖前者（last-wins）；
+ * - 同时吸收 assistant/chunk 的 usage 样本，因此"请求失败、没有最终
+ *   assistant/message"的调用其用量仍被计入（chunk 样本存活）；
+ * - calls = 今日有用量报告的唯一调用数（近似 API 请求数，含失败请求）。
+ *
+ * 性能（0.1.7 起）：按会话增量扫描——持久化后端会话修订值
+ * （listSnapshots）未变的会话复用缓存的聚合结果，只重读变化的会话；
+ * 跨北京日自动失效全部缓存。
+ *
+ * 安全（0.1.7 起）：路由仅接受 Host 为 127.0.0.1 / localhost / ::1 的请求，
+ * 拒绝 DNS rebinding 与 0.0.0.0 绑定下的局域网访问。
  */
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
-import { DEFAULT_MODEL, PEAK_HOURS_TEXT, costOf, isPeak, unitAt } from "./pricing.js";
+import {
+  DEFAULT_MODEL,
+  PEAK_HOURS_TEXT,
+  costOf,
+  isPeak,
+  shanghaiDayKey,
+  startOfTodayShanghaiMs,
+  unitAt,
+} from "./pricing.js";
 
 const name = "dsh-deepseek-usage";
 const inject = ["credentials", "webServer"];
 
 const PUBLIC_BASE_URL = "https://api.deepseek.com";
-/** 与 llm-deepseek 适配器对齐的环境变量覆盖。 */
+/** 与 llm-deepseek 适配器对齐的环境变量覆盖。注意：指向第三方网关时 API Key 会发给该地址。 */
 const BASE_URL_ENV = "DEEPSEEK_BASE_URL";
 const API_KEY_REF = credentialRef("DEEPSEEK_API_KEY");
 const BALANCE_PATH = "/user/balance";
@@ -67,20 +89,111 @@ function toFinite(value) {
   return NaN;
 }
 
-/** 本地今日零点（unix ms）。 */
-function startOfTodayMs() {
-  const d = new Date();
-  d.setHours(0, 0, 0, 0);
-  return d.getTime();
+/** 仅接受本机 Host（127.0.0.1 / localhost / ::1），拦截 DNS rebinding 与局域网访问。 */
+function isLocalHost(req) {
+  const raw = req.headers.host;
+  if (typeof raw !== "string" || raw === "") return false;
+  let host = raw.toLowerCase();
+  if (host.startsWith("[")) {
+    const end = host.indexOf("]");
+    if (end === -1) return false;
+    host = host.slice(1, end);
+  } else {
+    const idx = host.lastIndexOf(":");
+    if (idx !== -1) host = host.slice(0, idx);
+  }
+  return host === "127.0.0.1" || host === "localhost" || host === "::1";
+}
+
+/**
+ * (turn, step) 去重键：同一调用的 usage chunk 与最终 message 共享 key，
+ * 后者覆盖前者；缺少 turn/step 时退化为按事件 seq 独立计（罕见，日志
+ * 规范下不该发生）。
+ */
+function stepKey(turn, step, seq) {
+  if (typeof turn === "number" && typeof step === "number") return `t:${turn}:s:${step}`;
+  return `e:${seq}`;
+}
+
+function freshAgg() {
+  return { calls: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, unknownModels: new Set() };
+}
+
+function addAgg(target, src) {
+  target.calls += src.calls;
+  target.input += src.input;
+  target.output += src.output;
+  target.cacheRead += src.cacheRead;
+  target.cacheWrite += src.cacheWrite;
+  target.cost += src.cost;
+  for (const m of src.unknownModels) target.unknownModels.add(m);
+}
+
+/**
+ * 顺序扫描一个会话的原始日志，返回该会话的今日聚合；无今日样本返回 null。
+ * 与 token-meter 相同的 last-wins 语义：同一 (turn, step) 的 usage 样本
+ * （流式 chunk 或最终 message）只计最后一次，绝不重复计数。
+ */
+function scanSessionRaw(content, dayStart, fallbackModel) {
+  const agg = freshAgg();
+  const steps = new Map();
+  for (const line of content.split("\n")) {
+    if (line === "") continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (event === null || typeof event !== "object" || typeof event.time !== "number" || event.time < dayStart) continue;
+    const data = event.data;
+    if (data === null || typeof data !== "object") continue;
+    let usage;
+    let model;
+    if (
+      event.type === "assistant/chunk" &&
+      data.chunk !== null &&
+      typeof data.chunk === "object" &&
+      data.chunk.type === "usage" &&
+      data.chunk.usage
+    ) {
+      // 流式 usage 样本：失败请求没有最终 message 时仍存活，必须计入。
+      usage = data.chunk.usage;
+      model = fallbackModel;
+    } else if (event.type === "assistant/message" && data.usage) {
+      // 最终样本：覆盖同 (turn, step) 的早期 chunk 样本。
+      usage = data.usage;
+      const source = data.message && data.message.source;
+      model = source && typeof source.model === "string" ? source.model : fallbackModel;
+    } else {
+      continue;
+    }
+    steps.set(stepKey(data.turn, data.step, event.seq), { usage, model, time: event.time });
+  }
+  if (steps.size === 0) return null;
+  for (const { usage, model, time } of steps.values()) {
+    const unit = unitAt(model, time);
+    if (!unit.known) agg.unknownModels.add(model);
+    agg.calls += 1;
+    agg.input += usage.inputTokens || 0;
+    agg.output += usage.outputTokens || 0;
+    agg.cacheRead += usage.cacheReadTokens || 0;
+    agg.cacheWrite += usage.cacheWriteTokens || 0;
+    agg.cost += costOf(usage, unit);
+  }
+  return agg;
 }
 
 let usageCache = null;
 let usageCacheAt = 0;
+let usageCacheDay = "";
+/** sessionId -> { revision, agg }，per-session 增量聚合缓存（P2）。 */
+let sessionAggCache = new Map();
 
 /**
- * 扫描全部会话日志，统计今日（本地时区）token 用量 / API 请求数 / 花费估算。
- * 每条 `assistant/message` 按消息自带的 model（data.message.source.model）
- * 与事件时刻的峰谷单价计价。
+ * 扫描全部会话日志，统计今日（北京时间）token 用量 / API 调用数 / 花费估算。
+ * 增量策略：会话修订值（listSnapshots）未变 → 复用缓存聚合；只重读变化的
+ * 会话；跨北京日（shanghaiDayKey 变化）时全部失效重扫。
  */
 async function scanTodayUsage(ctx) {
   const persistence = ctx.get("sessionPersistence");
@@ -88,44 +201,65 @@ async function scanTodayUsage(ctx) {
     return { usable: false, error: "sessionPersistence 不可用" };
   }
   const now = Date.now();
-  if (usageCache !== null && now - usageCacheAt < USAGE_CACHE_MS) return usageCache;
-  const dayStart = startOfTodayMs();
-  const acc = { usable: true, calls: 0, sessions: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, skipped: 0 };
+  const dayKey = shanghaiDayKey(now);
+  if (usageCache !== null && usageCacheDay === dayKey && now - usageCacheAt < USAGE_CACHE_MS) return usageCache;
+  if (usageCacheDay !== dayKey) {
+    usageCacheDay = dayKey;
+    sessionAggCache.clear();
+  }
+  const dayStart = startOfTodayShanghaiMs(now);
+  const acc = freshAgg();
+  acc.usable = true;
+  acc.sessions = 0;
+  acc.skipped = 0;
+  let defaultModel = DEFAULT_MODEL;
+  try {
+    const adm = ctx.get("agentDefaultModel");
+    const selection = adm && typeof adm.currentSelection === "function" ? adm.currentSelection() : void 0;
+    if (selection && typeof selection.model === "string") defaultModel = selection.model;
+  } catch {}
   try {
-    const headers = await persistence.list();
+    const hasSnapshots = typeof persistence.listSnapshots === "function";
+    const headers = hasSnapshots ? await persistence.listSnapshots() : await persistence.list();
+    const seen = new Set();
     for (const header of headers) {
+      // listSnapshots 返回 { header: SessionHeader, revision }，id 在 header.header.id；
+      // list 直接返回 SessionHeader[]（顶层 id）。
+      const id = hasSnapshots ? header.header.id : header.id;
+      if (typeof id !== "string" || id === "") continue;
+      seen.add(id);
+      const revision = hasSnapshots ? header.revision : void 0;
+      const cached = sessionAggCache.get(id);
+      if (cached !== void 0 && revision !== void 0 && cached.revision === revision) {
+        if (cached.agg !== null) {
+          addAgg(acc, cached.agg);
+          acc.sessions += 1;
+        }
+        continue;
+      }
       let raw;
       try {
-        raw = await persistence.readRaw(header.id);
+        raw = await persistence.readRaw(id);
       } catch {
         acc.skipped += 1;
+        sessionAggCache.delete(id);
         continue;
       }
-      if (raw === void 0 || raw === null || typeof raw.content !== "string") continue;
-      let hit = false;
-      for (const line of raw.content.split("\n")) {
-        if (line === "") continue;
-        let event;
-        try {
-          event = JSON.parse(line);
-        } catch {
-          continue;
-        }
-        if (event === null || typeof event !== "object" || event.type !== "assistant/message") continue;
-        const usage = event.data && event.data.usage;
-        if (usage === void 0 || usage === null || typeof event.time !== "number" || event.time < dayStart) continue;
-        hit = true;
-        const source = event.data.message && event.data.message.source;
-        const model = source && typeof source.model === "string" ? source.model : void 0;
-        const unit = unitAt(model, event.time);
-        acc.calls += 1;
-        acc.input += usage.inputTokens || 0;
-        acc.output += usage.outputTokens || 0;
-        acc.cacheRead += usage.cacheReadTokens || 0;
-        acc.cacheWrite += usage.cacheWriteTokens || 0;
-        acc.cost += costOf(usage, unit);
+      if (raw === void 0 || raw === null || typeof raw.content !== "string") {
+        sessionAggCache.delete(id);
+        continue;
+      }
+      const agg = scanSessionRaw(raw.content, dayStart, defaultModel);
+      sessionAggCache.set(id, { revision, agg });
+      if (agg === null) continue;
+      addAgg(acc, agg);
+      acc.sessions += 1;
+    }
+    if (hasSnapshots) {
+      // 修剪已被删除的会话缓存。
+      for (const id of sessionAggCache.keys()) {
+        if (!seen.has(id)) sessionAggCache.delete(id);
       }
-      if (hit) acc.sessions += 1;
     }
   } catch (error) {
     acc.usable = false;
@@ -134,6 +268,7 @@ async function scanTodayUsage(ctx) {
   acc.cost = Math.round(acc.cost * 1e6) / 1e6;
   usageCache = acc;
   usageCacheAt = now;
+  usageCacheDay = dayKey;
   return acc;
 }
 
@@ -144,10 +279,15 @@ function apply(ctx) {
       path: ROUTE_PATH,
       handler: async (req, res) => {
         try {
+          // ---- 仅本机访问（P3）：拦截 DNS rebinding 与局域网直接访问 ----
+          if (!isLocalHost(req)) {
+            return sendJson(res, 403, { ok: false, error: "forbidden", message: "仅允许本机访问" });
+          }
+
           const errors = [];
 
           // ---- 余额（官方接口）----
-          const balance = { available: null, total: null, currency: null, granted: null, toppedUp: null };
+          const balance = { isAvailable: null, total: null, currency: null, granted: null, toppedUp: null };
           try {
             const hit = await ctx.credentials.resolve(API_KEY_REF);
             if (hit === void 0) {
@@ -164,7 +304,7 @@ function apply(ctx) {
                 const body = JSON.parse(text);
                 const infos = body && Array.isArray(body.balance_infos) ? body.balance_infos : [];
                 const first = infos[0] || {};
-                balance.available = body?.is_available !== false;
+                balance.isAvailable = body?.is_available !== false;
                 balance.total = toFinite(first.total_balance);
                 balance.currency = typeof first.currency === "string" ? first.currency : null;
                 balance.granted = toFinite(first.granted_balance);
@@ -175,9 +315,12 @@ function apply(ctx) {
             errors.push(`余额获取失败: ${error instanceof Error ? error.message : String(error)}`);
           }
 
-          // ---- 今日 token / API 次数 / 花费估算（本地日志）----
+          // ---- 今日 token / API 调用数 / 花费估算（本地日志）----
           const usage = await scanTodayUsage(ctx);
           if (!usage.usable) errors.push(usage.error ?? "今日用量统计不可用");
+          if (usage.usable && usage.unknownModels.size > 0) {
+            errors.push(`未知模型按 chat 档计价: ${[...usage.unknownModels].join(", ")}`);
+          }
 
           const now = Date.now();
           let model = DEFAULT_MODEL;
@@ -212,7 +355,14 @@ function apply(ctx) {
             },
             peak: isPeak(now),
             peakHours: PEAK_HOURS_TEXT,
-            tier: { input: unit.input, cacheRead: unit.cacheRead, cacheWrite: unit.cacheWrite, output: unit.output },
+            tier: {
+              input: unit.input,
+              cacheRead: unit.cacheRead,
+              cacheWrite: unit.cacheWrite,
+              output: unit.output,
+              model: unit.model,
+              known: unit.known,
+            },
             updatedAt: now,
             errors,
           });

package/lib/pricing.js

@@ -2,11 +2,19 @@
  * dsh-deepseek-usage — 定价引擎（元 / 百万 tokens）。
  *
  * DeepSeek 官方价格快照（2026-08-17 起 V4 系列峰谷定价，北京时间）：
- * 高峰时段 9:00–12:00 与 14:00–18:00，其余为空闲时段（空闲=高峰半价）。
- * 缓存写暂不计费（cacheWrite = 0）；未知模型回退 chat 档。
+ * 高峰时段 9:00–12:00 与 14:00–18:00（北京时间），其余为空闲时段（空闲=高峰半价）。
+ * 缓存写暂不计费（cacheWrite = 0）；未知模型回退 chat 档，并通过 unitAt().known
+ * 与 isKnownModel() 让调用方提示用户，而不是静默算错。
  * 价格调整时只需改 PRICE_TABLE 与 PEAK_WINDOWS。
+ *
+ * 时区（0.1.7 起）：峰谷判定与"今日"边界一律按北京时间（Asia/Shanghai，
+ * 固定 UTC+8，无夏令时）计算，不随服务器本地时区变化——在任何时区部署的
+ * DSH 上显示一致。
  */
 
+/** 北京时间固定偏移（上海无夏令时）。 */
+const SHANGHAI_OFFSET_MS = 8 * 60 * 60 * 1000;
+
 /** 每模型价格：input/cacheRead/output 均为 [高峰, 空闲] 二元组；cacheWrite 为常量 0。 */
 const PRICE_TABLE = {
   'deepseek-v4-flash': { input: [3.0, 1.5], cacheRead: [0.1, 0.05], cacheWrite: 0, output: [9.0, 4.5] },
@@ -15,22 +23,51 @@ const PRICE_TABLE = {
   'deepseek-reasoner': { input: [4, 4], cacheRead: [1, 1], cacheWrite: 0, output: [16, 16] },
 };
 
-/** 默认模型（当 agentDefaultModel 不可用时）。 */
+/** 默认模型（当 agentDefaultModel 不可用时的展示默认）。 */
 export const DEFAULT_MODEL = 'deepseek-v4-flash';
 
-/** 高峰时段窗口（本地/北京时间，含起点不含终点）。 */
+/** 高峰时段窗口（北京时间，含起点不含终点）。 */
 export const PEAK_WINDOWS = [[9, 12], [14, 18]];
 /** 高峰时段展示文案。 */
-export const PEAK_HOURS_TEXT = '9:00–12:00、14:00–18:00';
+export const PEAK_HOURS_TEXT = '9:00–12:00、14:00–18:00（北京时间）';
+
+/** 某时刻的北京时间小时（0–23）。 */
+export function shanghaiHour(ms) {
+  return new Date(ms + SHANGHAI_OFFSET_MS).getUTCHours();
+}
+
+/** 某时刻所在北京日的零点（unix ms）。 */
+export function startOfTodayShanghaiMs(now) {
+  const shifted = new Date(now + SHANGHAI_OFFSET_MS);
+  return Date.UTC(shifted.getUTCFullYear(), shifted.getUTCMonth(), shifted.getUTCDate()) - SHANGHAI_OFFSET_MS;
+}
 
-/** 某时刻是否为高峰时段。 */
+/** 某时刻所在北京日的日期键（YYYY-MM-DD），用于跨日失效。 */
+export function shanghaiDayKey(now) {
+  const shifted = new Date(now + SHANGHAI_OFFSET_MS);
+  const y = shifted.getUTCFullYear();
+  const m = String(shifted.getUTCMonth() + 1).padStart(2, '0');
+  const d = String(shifted.getUTCDate()).padStart(2, '0');
+  return `${y}-${m}-${d}`;
+}
+
+/** 某时刻是否为高峰时段（按北京时间）。 */
 export function isPeak(ms) {
-  const h = new Date(ms).getHours();
+  const h = shanghaiHour(ms);
   return PEAK_WINDOWS.some(([start, end]) => h >= start && h < end);
 }
 
-/** 某模型在某一时刻的单位价格（元/百万 tokens）。 */
+/** 模型是否在价格表中。 */
+export function isKnownModel(model) {
+  return typeof model === 'string' && Object.prototype.hasOwnProperty.call(PRICE_TABLE, model);
+}
+
+/**
+ * 某模型在某一时刻的单位价格（元/百万 tokens）。
+ * 未知模型回退 chat 档；known=false 供调用方提示，避免静默算错。
+ */
 export function unitAt(model, ms) {
+  const known = isKnownModel(model);
   const p = PRICE_TABLE[model] || PRICE_TABLE['deepseek-chat'];
   const tier = isPeak(ms) ? 0 : 1;
   return {
@@ -38,6 +75,8 @@ export function unitAt(model, ms) {
     cacheRead: p.cacheRead[tier],
     cacheWrite: p.cacheWrite,
     output: p.output[tier],
+    model: known ? model : 'deepseek-chat',
+    known,
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dougen/dsh-deepseek-usage",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "DeepSeek 用量侧边栏插件：余额（官方 API）、今日花费（本地日志估算）、今日 Token 与 API 次数（本地日志）、高峰/空闲时段指示灯。",
   "type": "module",
   "main": "lib/index.js",
@@ -27,7 +27,8 @@
     }
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-credentials": "^0.1.0-rc.6"
+    "@deepseek-ai/dsh-credentials": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6"
   },
   "keywords": [
     "dsh",