balance-dsh 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rannist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,108 @@
+# balance-dsh
+
+DSH 插件：在 Web UI 中直接显示 DeepSeek 账户余额和当前会话 token/金额消耗。
+
+## 功能
+
+- **侧边栏余额行**：侧边栏展开时显示在底部（紧贴"设置"按钮上方），格式：钱包图标 + `余额` + 金额（带货币单位）+ 时段标签（高峰红 / 空闲绿）。金额按余额状态变色：充足绿色、偏低（<10）琥珀黄、为 0 显示红色"去充值"。悬停显示明细（总余额、充值余额），点击金额跳转 DeepSeek 用量页。
+- **收起态 FAB**：侧边栏收起时，余额显示为左下角悬浮胶囊。
+- **自动刷新**：每 60 秒自动刷新一次；每次对话完成（新回复落库）也会立即刷新；右键余额任意区域可手动刷新。
+- **高峰/空闲计费**：官方高峰窗口为**周一至周五 09:00-12:00、14:00-18:00（北京时间）**，周末全天空闲。消耗金额**跨时段精确计费**：高峰时段的 token 按高峰价 ×2、空闲时段按目录价，按事件时间分桶计算。
+- **会话消耗行**：对话框下方实时显示当前会话消耗（新增 tokens + 估算金额），悬停查看完整明细（模型、时段拆分、计费口径）。
+- **`/balance` 命令**：命令行查询余额明细和当前会话消耗。
+
+## 安装
+
+前提：已安装 DSH Desktop，且知道自己的 profile 目录（通常是 `C:\Users\<你的用户名>\.dsh\profiles\desktop\`）。
+
+### 方式一：通过 npm 安装（推荐）
+
+```powershell
+cd C:\Users\<你的用户名>\.dsh\profiles\desktop
+pnpm add balance-dsh
+```
+
+### 方式二：从 tarball 安装
+
+```powershell
+cd C:\Users\<你的用户名>\.dsh\profiles\desktop
+pnpm add "file:C:\path\to\balance-dsh-1.0.0.tgz"
+```
+
+### 方式三：从 GitHub 安装
+
+```powershell
+cd C:\Users\<你的用户名>\.dsh\profiles\desktop
+dsh plugin --profile desktop add github:Rannist/balance-dsh
+```
+
+> 用 npm 安装后，插件自带 `dsh.bundle.patch`（`cordis.patch.yml`），安装即自动注册，**无需手动改 profile 的 cordis.patch.yml**。只有用旧版 tarball/手动方式时才需要手动注册：
+
+```yaml
+# profile 目录的 cordis.patch.yml（只有手动安装时才需要）
+- insert:
+    - id: balance
+      name: balance-dsh
+```
+
+### 设置 DeepSeek API Key（三选一）
+
+1. 环境变量 `DEEPSEEK_API_KEY`，或
+2. 在注册项的 `config.apiKey` 中设置，或
+3. 使用 DSH 凭据存储中的 `DEEPSEEK_API_KEY`
+
+### 重启
+
+服务端界面改动需**重启 DSH Desktop** 后生效。
+
+## 配置
+
+在插件注册项（或 `cordis.patch.yml`）中覆盖：
+
+```yaml
+- id: balance
+  name: balance-dsh
+  config:
+    apiKey: sk-xxxx                        # 可选；缺省用 DEEPSEEK_API_KEY 环境变量/凭据
+    peakWindows:                           # 可选；默认周一至周五，如下
+      - {start: 9, end: 12}
+      - {start: 14, end: 18}
+    peakWeekdays: [1, 2, 3, 4, 5]          # 可选；1=周一 … 5=周五，0/6=周末
+    price:                                 # 可选；逐项覆盖对应模型价格（元/百万 tokens）
+      inputCnyPerMillion: 1.5
+      cacheReadCnyPerMillion: 0.05
+      cacheWriteCnyPerMillion: 0
+      outputCnyPerMillion: 4.5
+```
+
+> 注意：插件已自动按高峰/空闲时段计费（高峰价 = 目录价 × 2），**不要再设置 `config.peak: true`**，否则会重复翻倍。
+
+## 卸载
+
+```powershell
+cd C:\Users\<你的用户名>\.dsh\profiles\desktop
+pnpm remove balance-dsh
+```
+
+如需删除手动注册行（若你手动加过），从 profile 的 `cordis.patch.yml` 移除对应的 `balance` 条目。
+
+## 权限 / 数据
+
+- 仅在你**主动刷新**或对话完成时，会向 `api.deepseek.com` 的 `/user/balance` 端点发起一次余额查询。
+- 插件需要你的 DeepSeek API Key（仅用于余额查询），不收集、不上传任何会话内容到第三方。
+- 消费统计完全基于本地会话事件（`request/header`、`assistant/message` 的 token usage）计算，不向 DeepSeek 之外的服务发送数据。
+
+## 价格表（2026-08-17 生效的 V4 峰谷定价·空闲时段价，元/百万 tokens）
+
+| 模型 | 输入（缓存未命中） | 输入（缓存命中） | 输出 |
+|---|---|---|---|
+| deepseek-v4-flash | 1.5 | 0.05 | 4.5 |
+| deepseek-v4-pro | 4.5 | 0.15 | 13.5 |
+| deepseek-chat（旧） | 2 | 0.5 | 3 |
+| deepseek-reasoner（旧） | 4 | 1 | 16 |
+
+未识别模型按 deepseek-v4-flash 兜底；DeepSeek 调价后需同步更新 `lib/index.js` 的 `MODEL_PRICING` 与 `lib/client.js` 的 `DEFAULT_PRICING`。
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,33 @@
+# balance-dsh bundle patch
+#
+# This is the `dsh.bundle.patch` layer of the published npm package. When the
+# plugin is installed through the official CLI:
+#
+#   dsh plugin --profile <name> add balance-dsh@<version>
+#
+# the command reconciles the profile bundle stack against installed packages
+# and, seeing this declaration, appends `balance-dsh` to the bundle stack.
+# The profile boot then merges this patch (a single `insert` of the plugin row)
+# exactly like a manual cordis.patch.yml mount line.
+#
+# NOTE: if a profile already carries the old manual mount line in its own
+# cordis.patch.yml (e.g. `- id: balance / name: balance-dsh`), remove it before
+# switching to the bundle channel to avoid double-mounting.
+#
+# To override DeepSeek API key / prices, add a `config` block to the inserted
+# row. All fields are optional; the plugin falls back to the DEEPSEEK_API_KEY
+# environment variable / credential store when `config.apiKey` is omitted.
+- insert:
+    - id: balance
+      name: balance-dsh
+      # config:
+      #   apiKey: sk-xxxx              # optional; else DEEPSEEK_API_KEY env/credential
+      #   peakWindows:                  # optional; default Mon-Fri 09-12 / 14-18 Beijing
+      #     - {start: 9, end: 12}
+      #     - {start: 14, end: 18}
+      #   peakWeekdays: [1, 2, 3, 4, 5] # optional; 1=Mon ... 5=Fri
+      #   price:                        # optional per-model overrides (CNY / 1M tokens)
+      #     inputCnyPerMillion: 1.5
+      #     cacheReadCnyPerMillion: 0.05
+      #     cacheWriteCnyPerMillion: 0
+      #     outputCnyPerMillion: 4.5

package/lib/client.js

@@ -0,0 +1,615 @@
+window.__ModuleLoader__.load({
+  id: "balance-dsh",
+  factory: (require) => {
+    var module = { exports: {} };
+    var exports = module.exports;
+    Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+    let react = require("react");
+    let jsx = require("react/jsx-runtime");
+    let primitives = require("@deepseek-ai/dsh-client-ui-primitives");
+
+    // ─── 样式 ────────────────────────────────────────────────────────────────
+    const css = `
+/* 兜底定义主题过渡变量：上游 deepsuite theme/global.css 未加载时，
+   恢复侧边栏/面板的滑动动画（AppFrame 宽度过渡依赖 --ds-transition-duration-slow） */
+:root{--ds-transition-duration-slow:.3s;--ds-transition-duration:.2s;--ds-transition-duration-fast:.1s;--ds-ease-in-out:cubic-bezier(.4,0,.2,1)}
+/* ── 基础元素（自定义类，稳定；纯文字样式，不用胶囊） ── */
+/* 完全复刻设置按钮（.VOzbGW_trigger）：width calc(100%+4px)、height 42px、margin 4px -2px、
+   padding 0 10px 0 8px、gap 8px、font 14px/22px、color label-primary；
+   左缘与设置按钮严格对齐，高度/颜色一致（图标与"余额"文字也统一 label-primary，金额 600 加粗） */
+.balance-footer{box-sizing:border-box;display:flex;align-items:center;justify-content:flex-start;gap:8px;width:calc(100% + 4px);min-width:0;height:42px;margin:0 -2px;padding:0 10px 0 8px;color:var(--dsw-alias-label-primary);font-size:14px;line-height:22px;text-decoration:none;cursor:pointer;white-space:nowrap;overflow:hidden;-webkit-user-select:none;user-select:none}
+.balance-footer__icon{display:inline-flex;flex:none;color:var(--dsw-alias-label-primary)}
+.balance-footer__label{white-space:nowrap;color:var(--dsw-alias-label-primary)}
+.balance-footer__value{font-variant-numeric:tabular-nums;font-weight:600;white-space:nowrap;padding:2px 8px;border-radius:999px;margin-left:auto;text-decoration:none;cursor:pointer;transition:transform .15s var(--ds-ease-in-out,.2s)}
+.balance-footer__value:hover{filter:brightness(.85);transform:scale(1.06)}
+.balance-footer__value--healthy{color:var(--dsw-alias-state-success-primary);background:rgba(34,197,94,.15)}
+.balance-footer__value--low{color:#d97706;background:rgba(217,119,6,.15)}
+.balance-footer__value--empty{color:var(--dsw-alias-state-error-primary,#e5484d);background:rgba(229,72,77,.15)}
+.balance-footer__topup{margin-left:auto;flex:none;box-sizing:border-box;padding:2px 10px;border-radius:999px;font-weight:500;white-space:nowrap;color:var(--dsw-alias-state-error-primary,#e5484d);text-decoration:none;background:rgba(229,72,77,.15);transition:transform .15s var(--ds-ease-in-out,.2s)}
+.balance-footer__topup:hover{filter:brightness(.85);transform:scale(1.06)}
+.balance-footer__period-inline{font-weight:500;white-space:nowrap}
+.balance-footer__period-inline--peak{color:var(--dsw-alias-state-error-primary,#e5484d)}
+.balance-footer__period-inline--offpeak{color:var(--dsw-alias-state-success-primary)}
+.balance-footer__period-inline--refreshing{color:var(--dsw-alias-label-secondary)}
+.balance-footer__error{color:var(--dsw-alias-state-error-primary)}
+.balance-topup{box-sizing:border-box;display:flex;align-items:center;justify-content:flex-start;gap:8px;width:calc(100% + 4px);min-width:0;height:42px;margin:0 -2px;padding:0 10px 0 8px;color:var(--dsw-alias-state-error-primary,#e5484d);font-size:14px;font-weight:600;line-height:22px;text-decoration:none;cursor:pointer;white-space:nowrap;overflow:hidden}
+.balance-topup:hover{text-decoration:underline}
+/* ── 收起态：悬浮 FAB（保持原样） ── */
+.balance-fab{box-sizing:border-box;position:fixed;left:68px;bottom:12px;z-index:40;height:32px;padding:0 14px;display:inline-flex;align-items:center;justify-content:center;color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-module-platform,var(--dsw-alias-bg-base));border:1px solid var(--dsw-alias-border-l2);border-radius:999px;cursor:pointer;font-size:12px;font-weight:600;line-height:1;text-decoration:none;white-space:nowrap;pointer-events:auto;box-shadow:0 4px 12px rgba(0,0,0,.10)}
+.balance-fab:hover{background:var(--dsw-alias-interactive-bg-hover)}
+.balance-fab-dark{color:#fff;background:var(--dsw-alias-state-error-primary,#e5484d);border-color:var(--dsw-alias-state-error-primary,#e5484d)}
+.balance-fab-dark:hover{background:#cf3a3f}
+.balance-usage-line{box-sizing:border-box;display:flex;justify-content:center;align-items:center;gap:10px;color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}
+.balance-usage-line strong{color:var(--dsw-alias-label-primary);font-weight:600}
+/* ── 展开态底部一行：[设置齿轮][余额胶囊]，余额在设置右边 ──
+   全部使用稳定锚点，不依赖 CSS Modules hash 类名（DSH 升级后仍有效）：
+   - wide 态特征：底部存在 .balance-footer / .balance-topup（收起态渲染 position:fixed 的 .balance-fab，不影响）
+   - footArea 改 row；footerActions 占满并把余额推向右端；settingsArea order:-1 排到最左
+   - [data-slot] = slot 出口契约（display:contents） */
+:has(> :has(> [data-slot="sidebar.footer.action"])):has(.balance-footer, .balance-topup){flex-direction:row;align-items:center;gap:4px}
+:has(> :has(> [data-slot="sidebar.footer.action"])):has(.balance-footer, .balance-topup) > :has(> [data-slot="sidebar.footer.action"]){flex:1 1 0;min-width:0;width:auto;flex-direction:row;justify-content:flex-end;align-items:center;gap:4px}
+:has(> :has(> [data-slot="sidebar.footer.action"])):has(.balance-footer, .balance-topup) > :has(> [data-slot="sidebar.settings"]){order:-1;flex:0 0 auto;width:32px;min-width:0}
+:has(> :has(> [data-slot="sidebar.footer.action"])):has(.balance-footer, .balance-topup) [data-slot="sidebar.settings"] button{width:32px;height:32px;margin:0;padding:0;justify-content:center;border-radius:50%;gap:0}
+:has(> :has(> [data-slot="sidebar.footer.action"])):has(.balance-footer, .balance-topup) [data-slot="sidebar.settings"] button span{display:none}
+`;
+
+    const tagId = "balance/balance-widget.css";
+    if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId) + "]") === null) {
+      const tag = document.createElement("style");
+      tag.dataset.plugin = "balance";
+      tag.dataset.pluginCss = tagId;
+      tag.textContent = css;
+      document.head.appendChild(tag);
+    }
+
+    // ─── 价格（与服务端默认保持一致；服务端 /balance-api 返回后会覆盖） ───
+    // 2026-08-17 生效的 DeepSeek V4-Flash 空闲时段价（元/百万 tokens）
+    const DEFAULT_PRICING = {
+      inputCnyPerMillion: 1.5, // 输入（缓存未命中）
+      cacheReadCnyPerMillion: 0.05, // 输入（缓存命中）
+      cacheWriteCnyPerMillion: 0, // DeepSeek 无缓存写入计费
+      outputCnyPerMillion: 4.5, // 输出
+    };
+
+    let pricing = DEFAULT_PRICING;
+    const pricingListeners = new Set();
+    function setPricing(next) {
+      if (!next) return;
+      pricing = {
+        inputCnyPerMillion: Number(next.inputCnyPerMillion ?? DEFAULT_PRICING.inputCnyPerMillion),
+        cacheReadCnyPerMillion: Number(next.cacheReadCnyPerMillion ?? DEFAULT_PRICING.cacheReadCnyPerMillion),
+        cacheWriteCnyPerMillion: Number(next.cacheWriteCnyPerMillion ?? DEFAULT_PRICING.cacheWriteCnyPerMillion),
+        outputCnyPerMillion: Number(next.outputCnyPerMillion ?? DEFAULT_PRICING.outputCnyPerMillion),
+      };
+      for (const listener of pricingListeners) listener();
+    }
+    function usePricing() {
+      const [, force] = react.useState(0);
+      react.useEffect(() => {
+        const listener = () => force((n) => n + 1);
+        pricingListeners.add(listener);
+        return () => pricingListeners.delete(listener);
+      }, []);
+      // 返回原始目录价（分时段计费时由 computeSplitCost 决定高峰×2）
+      return pricing;
+    }
+
+    function computeCost(usage, p) {
+      const input =
+        ((usage.uncachedInputTokens ?? 0) * p.inputCnyPerMillion +
+          (usage.cacheReadTokens ?? 0) * p.cacheReadCnyPerMillion +
+          (usage.cacheWriteTokens ?? 0) * p.cacheWriteCnyPerMillion) /
+        1_000_000;
+      const output = ((usage.outputTokens ?? 0) * p.outputCnyPerMillion) / 1_000_000;
+      return input + output;
+    }
+
+    /** 分时段金额：高峰桶按目录价 ×2、空闲桶按目录价（与服务端 estimateCost 口径一致）。 */
+    function computeSplitCost(usage, p) {
+      const costOf = (u) =>
+        ((u.inputTokens ?? 0) * p.inputCnyPerMillion +
+          (u.cacheReadTokens ?? 0) * p.cacheReadCnyPerMillion +
+          (u.cacheWriteTokens ?? 0) * p.cacheWriteCnyPerMillion) /
+          1_000_000 +
+        ((u.outputTokens ?? 0) * p.outputCnyPerMillion) / 1_000_000;
+      return costOf(usage.peak) * 2 + costOf(usage.offpeak);
+    }
+
+      function formatTokens(n) {
+        if (n >= 1_000_000) return (n / 1_000_000).toFixed(1).replace(/\.0$/, "") + "M";
+        if (n >= 1_000) return (n / 1_000).toFixed(1).replace(/\.0$/, "") + "K";
+        return String(n);
+      }
+
+    // ─── 当前会话模型：按模型取价（服务端 /balance-api 按 ?model= 返回对应价格） ───
+    let sessionsFace = void 0;
+    let currentModel = "";
+    const modelListeners = new Set();
+    const modelCache = new Map(); // sessionId -> model
+    function setCurrentModel(model) {
+      if (model === currentModel) return;
+      currentModel = model;
+      for (const listener of modelListeners) listener();
+    }
+    function useCurrentModel() {
+      const [model, force] = react.useState(currentModel);
+      react.useEffect(() => {
+        const listener = () => force(currentModel);
+        modelListeners.add(listener);
+        return () => modelListeners.delete(listener);
+      }, []);
+      return model;
+    }
+    /** 通过官方 sessions RPC 解析某会话使用的模型，缓存结果并广播；RPC 拿不到时回退到服务端 detectModel。
+     *  只缓存"取到模型"的结果；取到空串不缓存，以便会话后续可能产出模型时能重新解析。 */
+    async function resolveSessionModel(sessionId) {
+      if (typeof sessionId !== "string" || sessionId === "") return "";
+      if (modelCache.has(sessionId)) {
+        const cached = modelCache.get(sessionId);
+        if (cached !== "") setCurrentModel(cached);
+        return cached;
+      }
+      let model = "";
+      if (sessionsFace !== void 0) {
+        try {
+          const { result } = await sessionsFace.models({ sessionId });
+          model = result && result.ok ? (result.value?.current?.model ?? "") : "";
+        } catch {
+          model = "";
+        }
+      }
+      // 回退：服务端 /balance-api?session= 已检测实际模型（遍历会话事件）
+      if (model === "") model = await fetchServerModel(sessionId);
+      if (model !== "") modelCache.set(sessionId, model);
+      if (model !== "") setCurrentModel(model);
+      return model;
+    }
+    /** 请求服务端按会话检测模型（等价于 /balance-api?session= 返回的 model 字段），失败返回 "". */
+    async function fetchServerModel(sessionId) {
+      if (typeof sessionId !== "string" || sessionId === "") return "";
+      try {
+        const res = await fetch("/balance-api?session=" + encodeURIComponent(sessionId));
+        if (!res.ok) return "";
+        const data = await res.json();
+        return data && data.ok && typeof data.model === "string" ? data.model : "";
+      } catch {
+        return "";
+      }
+    }
+    function balanceApiUrl() {
+      return currentModel === "" ? "/balance-api" : "/balance-api?model=" + encodeURIComponent(currentModel);
+    }
+    /** 拉取余额 + 按当前模型计算的定价；成功后广播 pricing。 */
+    async function fetchBalanceData(controller) {
+      const res = await fetch(balanceApiUrl(), { signal: controller && controller.signal });
+      if (!res.ok) throw new Error("HTTP " + res.status);
+      const data = await res.json();
+      if (data && data.ok) {
+        if (data.pricing) setPricing(data.pricing);
+        return data;
+      }
+      throw new Error((data && data.error) || "余额查询失败");
+    }
+
+    /** 拉取指定会话的分时段 usage 及子代理 usage（/balance-api?session=...），失败返回 null。 */
+    async function fetchSessionUsage(sessionId) {
+      if (typeof sessionId !== "string" || sessionId === "") return null;
+      try {
+        const res = await fetch("/balance-api?session=" + encodeURIComponent(sessionId));
+        if (!res.ok) return null;
+        const data = await res.json();
+        if (!data || !data.ok) return null;
+        return {
+          usage: data.usage || null,
+          subagentUsage: data.subagentUsage || null,
+        };
+      } catch {
+        return null;
+      }
+    }
+
+    // ─── 高峰/空闲时段（纯客户端判断，无需服务端） ────────────────────────
+    // V4 峰谷定价（2026-08-17 生效）：高峰价 = 空闲价 × 2。
+    // 官方高峰窗口（北京时间）为 周一至周五 09:00-12:00、14:00-18:00；周末全天空闲。
+    const PEAK_WINDOWS = [
+      { start: 9, end: 12 },
+      { start: 14, end: 18 },
+    ];
+    const PEAK_WEEKDAYS = [1, 2, 3, 4, 5]; // 1=周一 … 5=周五，0/6=周末
+    function currentPeriod() {
+      const d = new Date(Date.now() + 8 * 60 * 60 * 1000); // 北京时间
+      const hour = d.getUTCHours();
+      const weekday = d.getUTCDay(); // 0=周日 … 6=周六
+      return PEAK_WEEKDAYS.includes(weekday) && PEAK_WINDOWS.some((w) => hour >= w.start && hour < w.end)
+        ? "peak"
+        : "offpeak";
+    }
+    /** 按当前时段调整价格：高峰 ×2、空闲原价。注意：若服务端已配 config.peak:true
+     *  （强制高峰价翻倍），此处会再乘一次，两种方式不要同时使用。 */
+    function periodAdjustedPricing(p) {
+      if (currentPeriod() !== "peak") return p;
+      return {
+        inputCnyPerMillion: p.inputCnyPerMillion * 2,
+        cacheReadCnyPerMillion: p.cacheReadCnyPerMillion * 2,
+        cacheWriteCnyPerMillion: p.cacheWriteCnyPerMillion * 2,
+        outputCnyPerMillion: p.outputCnyPerMillion * 2,
+      };
+    }
+
+    // ─── 余额数据：模块级共享缓存 + 60s 轮询 ──────────────────────────────
+    // 切换会话时 header 组件会重新挂载，若每个实例各自拉取会先消失再出现（闪烁）；
+    // 缓存全局存一份，任何实例挂载都直接读缓存，无需重新请求。
+    let balanceCache = { status: "loading", balance: null, error: null, refreshing: false };
+    let balancePollTimer = null;
+    const balanceListeners = new Set();
+
+    function emitBalance() {
+      for (const listener of balanceListeners) listener();
+    }
+
+    // 防抖/防并发：同一时刻只允许一个余额请求；两次刷新间隔不小于 800ms。
+    // 疯狂右键/轮询/对话刷新并发时自动合并，避免打爆 DeepSeek API。
+    let balanceFetchInFlight = false;
+    let lastBalanceFetchAt = 0;
+    const BALANCE_REFRESH_MIN_INTERVAL = 800;
+
+    async function fetchBalanceOnce() {
+      const now = Date.now();
+      if (balanceFetchInFlight || now - lastBalanceFetchAt < BALANCE_REFRESH_MIN_INTERVAL) return;
+      lastBalanceFetchAt = now;
+      balanceFetchInFlight = true;
+      try {
+        const data = await fetchBalanceData();
+        balanceCache = { status: "ready", balance: data.balance, error: null, refreshing: false };
+      } catch (error) {
+        balanceCache = { status: "error", balance: null, error: error && error.message ? error.message : String(error), refreshing: false };
+      } finally {
+        balanceFetchInFlight = false;
+      }
+      emitBalance();
+    }
+
+    function ensureBalancePolling() {
+      if (balancePollTimer !== null) return;
+      fetchBalanceOnce();
+      balancePollTimer = setInterval(fetchBalanceOnce, 60_000);
+    }
+
+    function useBalance() {
+      const [, force] = react.useState(0);
+      react.useEffect(() => {
+        const listener = () => force((n) => n + 1);
+        balanceListeners.add(listener);
+        ensureBalancePolling();
+        return () => balanceListeners.delete(listener);
+      }, []);
+      return balanceCache;
+    }
+
+    // 右键余额：阻止默认菜单、立即显示"刷新中"反馈（防止连按），并触发刷新（防抖合并）。
+    // 仅当本次点击真的会发起请求时才显示反馈，避免被防抖合并的点击留下悬挂的"刷新中"状态。
+    function onBalanceContextMenu(event) {
+      if (event && typeof event.preventDefault === "function") event.preventDefault();
+      const now = Date.now();
+      const willFetch = !balanceFetchInFlight && now - lastBalanceFetchAt >= BALANCE_REFRESH_MIN_INTERVAL;
+      if (willFetch && !balanceCache.refreshing) {
+        balanceCache = { ...balanceCache, refreshing: true };
+        emitBalance();
+      }
+      fetchBalanceOnce();
+    }
+
+    // ─── 余额显示：展开态侧栏底部文字（¥ 图标+金额）；收起态悬浮 FAB ──
+    function BalanceFooter({ wide }) {
+      const state = useBalance();
+
+      if (!wide) {
+        // 收起态：悬浮 FAB（原样保留）
+        if (state.status === "error" || !state.balance) return null;
+        const b = state.balance;
+        const total = Number.parseFloat(b.total_balance ?? "0");
+        const depleted = b.is_available === false || !Number.isFinite(total) || total <= 0;
+        if (depleted) {
+          return jsx.jsx("a", {
+            className: "balance-fab balance-fab-dark",
+            href: "https://platform.deepseek.com/top_up",
+            target: "_blank",
+            rel: "noreferrer",
+            onContextMenu: onBalanceContextMenu,
+            children: "去充值",
+          });
+        }
+        const currency = b.currency || "CNY";
+        const detailText = "总余额 " + b.total_balance + " " + currency + " · 充值余额 " + b.topped_up_balance + " " + currency;
+        return jsx.jsx("a", {
+          className: "balance-fab",
+          href: "https://platform.deepseek.com/usage",
+          target: "_blank",
+          rel: "noreferrer",
+          onContextMenu: onBalanceContextMenu,
+          children: "¥" + b.total_balance,
+        });
+      }
+
+      // 展开态：底部文字（加载中/失败/去充值/正常）
+      if (state.status === "error") {
+        return jsx.jsx("div", {
+          className: "balance-footer",
+          title: "余额查询失败：" + state.error,
+          onContextMenu: onBalanceContextMenu,
+          children: jsx.jsx("span", { className: "balance-footer__error", children: "余额查询失败" }),
+        });
+      }
+
+      if (!state.balance) {
+        return jsx.jsx("div", {
+          className: "balance-footer",
+          onContextMenu: onBalanceContextMenu,
+          children: "余额加载中…",
+        });
+      }
+
+      const b = state.balance;
+      const total = Number.parseFloat(b.total_balance ?? "0");
+      const depleted = b.is_available === false || !Number.isFinite(total) || total <= 0;
+      const currency = b.currency || "CNY";
+      const totalText = b.total_balance + " " + currency;
+      const detailText = "总余额 " + totalText + " · 充值余额 " + b.topped_up_balance + " " + currency;
+      const period = currentPeriod();
+      const low = total > 0 && total < 10;
+
+      // 金额胶囊：正常显示 金额•时段（语义色）；没余额显示 0（红色），并追加"去充值"胶囊
+      // 没余额：保留图标+"余额"字样，去掉具体金额，右侧只显示"去充值"按钮
+      if (depleted) {
+        return jsx.jsx("div", {
+          className: "balance-footer",
+          onContextMenu: onBalanceContextMenu,
+          children: [
+            jsx.jsx("span", {
+              className: "balance-footer__icon",
+              children: jsx.jsxs("svg", {
+                width: 16,
+                height: 16,
+                viewBox: "0 0 24 24",
+                fill: "none",
+                xmlns: "http://www.w3.org/2000/svg",
+                stroke: "currentColor",
+                strokeWidth: 2,
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                "aria-hidden": "true",
+                children: [
+                  jsx.jsx("path", { d: "M21 12V7H5a2 2 0 0 1 0-4h14v4" }),
+                  jsx.jsx("path", { d: "M3 5v14a2 2 0 0 0 2 2h16v-5" }),
+                  jsx.jsx("path", { d: "M18 12a2 2 0 0 0 0 4h4v-4Z" }),
+                ],
+              }),
+            }),
+            jsx.jsx("span", { className: "balance-footer__label", children: "余额" }),
+            jsx.jsx("a", {
+              className: "balance-footer__topup",
+              href: "https://platform.deepseek.com/top_up",
+              target: "_blank",
+              rel: "noreferrer",
+              onContextMenu: onBalanceContextMenu,
+              children: "去充值",
+            }),
+          ],
+        });
+      }
+
+      const valueClass = low ? " balance-footer__value--low" : " balance-footer__value--healthy";
+      const valueChildren = [
+        totalText,
+        " • ",
+        state.refreshing
+          ? jsx.jsx("span", { className: "balance-footer__period-inline balance-footer__period-inline--refreshing", children: "刷新中…" })
+          : jsx.jsx("span", { className: "balance-footer__period-inline balance-footer__period-inline--" + period, children: period === "peak" ? "高峰" : "空闲" }),
+      ];
+      const inner = [
+        jsx.jsx("span", {
+          className: "balance-footer__icon",
+          children: jsx.jsxs("svg", {
+            width: 16,
+            height: 16,
+            viewBox: "0 0 24 24",
+            fill: "none",
+            xmlns: "http://www.w3.org/2000/svg",
+            stroke: "currentColor",
+            strokeWidth: 2,
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            "aria-hidden": "true",
+            children: [
+              jsx.jsx("path", { d: "M21 12V7H5a2 2 0 0 1 0-4h14v4" }),
+              jsx.jsx("path", { d: "M3 5v14a2 2 0 0 0 2 2h16v-5" }),
+              jsx.jsx("path", { d: "M18 12a2 2 0 0 0 0 4h4v-4Z" }),
+            ],
+          }),
+        }),
+        jsx.jsx("span", { className: "balance-footer__label", children: "余额" }),
+        jsx.jsx("a", {
+          className: "balance-footer__value" + valueClass,
+          href: "https://platform.deepseek.com/usage",
+          target: "_blank",
+          rel: "noreferrer",
+          onContextMenu: onBalanceContextMenu,
+          children: valueChildren,
+        }),
+      ];
+      return jsx.jsx("div", {
+        className: "balance-footer",
+        onContextMenu: onBalanceContextMenu,
+        children: inner,
+      });
+    }
+
+    // ─── 当前会话消耗：输入区 dock ──────────────────────────────────────────
+    // ─── 关闭按钮：侧边栏底部，设置上方 ───────────────────────────────────
+function ShutdownButton({ wide }) {
+  return null;
+}
+
+function UsageCostLine({ useProjection, sessionId }) {
+      const p = usePricing();
+      const model = useCurrentModel();
+      const usage = typeof useProjection === "function" ? useProjection("tokenUsage") : undefined;
+      const [splitUsage, setSplitUsage] = react.useState(null);
+      const [subagentUsage, setSubagentUsage] = react.useState(null);
+      const [splitReady, setSplitReady] = react.useState(false);
+
+      // 会话 token 总量（未缓存输入 + 缓存读/写 + 输出）；为 0 时代表还没有消耗。
+      const usageKey = usage
+        ? (usage.uncachedInputTokens ?? 0) + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0) + (usage.outputTokens ?? 0)
+        : 0;
+
+      // 解析本会话使用的模型，并按模型刷新定价（/balance-api?model=...）
+      // 依赖 [sessionId, usageKey]：切对话或会话内容推进（新消息）都会触发；若还没解析到模型则总是重试。
+      react.useEffect(() => {
+        let disposed = false;
+        resolveSessionModel(sessionId).then((resolved) => {
+          if (disposed || resolved === "") return;
+          fetchBalanceData().catch(() => {});
+        });
+        return () => {
+          disposed = true;
+        };
+      }, [sessionId, usageKey]);
+
+      // 会话 token 总量变化（新消息/新消耗）时，拉取服务端分时段 usage，跨时段精确计费
+      // 同时"对话完成"即刷新一次余额（token 变化 = 一条新回复落库）
+      react.useEffect(() => {
+        if (usageKey === 0) return;
+        let disposed = false;
+        fetchSessionUsage(sessionId).then((u) => {
+          if (disposed) return;
+          if (u) {
+            setSplitUsage(u.usage);
+            setSubagentUsage(u.subagentUsage);
+          }
+          setSplitReady(true);
+        });
+        fetchBalanceData().catch(() => {});
+        return () => {
+          disposed = true;
+        };
+      }, [sessionId, usageKey]);
+
+      if (!usage) return null;
+
+      const uncachedInput = usage.uncachedInputTokens ?? 0;
+      const cacheRead = usage.cacheReadTokens ?? 0;
+      const cacheWrite = usage.cacheWriteTokens ?? 0;
+      const output = usage.outputTokens ?? 0;
+      // 新增内容 = 未缓存输入 + 输出（不含缓存重读）
+      const newTokens = uncachedInput + output;
+      // 计费总量 = 未缓存输入 + 缓存重读/写入 + 输出，与 DeepSeek 账单口径一致
+      const billedTotal = uncachedInput + cacheRead + cacheWrite + output;
+      if (newTokens === 0 && billedTotal === 0) return null;
+
+      // 金额：优先用服务端分时段 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;
+
+      // 子代理消耗（与主会话分开，同样跨时段精确计费）
+      const hasSubagent = splitReady && subagentUsage && subagentUsage.totalTokens > 0;
+      const subCost = hasSubagent ? computeSplitCost(subagentUsage, p) : 0;
+      const subNewTokens = hasSubagent
+        ? (subagentUsage.inputTokens ?? 0) + (subagentUsage.outputTokens ?? 0)
+        : 0;
+      const subCount = hasSubagent ? (subagentUsage.sessions ?? 0) : 0;
+
+      const detailLines = [
+        "模型：" + (model || "未知（按 deepseek-v4-flash 价估算）"),
+        "新增：" + formatTokens(newTokens) + " tokens（未缓存输入 " + formatTokens(uncachedInput) + " + 输出 " + formatTokens(output) + "）",
+        "计费：" + formatTokens(billedTotal) + " tokens（含缓存重读 " + formatTokens(cacheRead) + "、缓存写入 " + formatTokens(cacheWrite) + "）",
+      ];
+      if (split) {
+        detailLines.push(
+          "时段拆分：高峰 " + formatTokens(peakTokens) + " tokens + 空闲 " + formatTokens(offpeakTokens) + " tokens",
+          "估算金额：¥" + cost.toFixed(4) + "（高峰桶按目录价×2、空闲桶按目录价）",
+        );
+      } else {
+        detailLines.push("估算金额：¥" + cost.toFixed(4) + "（按当前时段价估算）");
+      }
+      if (hasSubagent) {
+        const subPeak = subagentUsage.peak.inputTokens + subagentUsage.peak.cacheReadTokens + subagentUsage.peak.cacheWriteTokens + subagentUsage.peak.outputTokens;
+        const subOff = subagentUsage.offpeak.inputTokens + subagentUsage.offpeak.cacheReadTokens + subagentUsage.offpeak.cacheWriteTokens + subagentUsage.offpeak.outputTokens;
+        detailLines.push(
+          "子代理消耗：新增 " + formatTokens(subNewTokens) + " tokens、计费 " + formatTokens(subagentUsage.totalTokens) + " tokens（" + subCount + " 个子代理）",
+          "子代理金额：¥" + subCost.toFixed(4) + "（高峰桶×2、空闲桶按目录价）",
+        );
+      }
+      const children = [
+        jsx.jsx("span", { children: "本会话消耗" }),
+        jsx.jsx("span", { children: jsx.jsx("strong", { children: formatTokens(newTokens) + " tokens" }) }),
+      ];
+      if (billedTotal > newTokens) {
+        children.push(jsx.jsx("span", { children: "计费 " + formatTokens(billedTotal) }));
+      }
+      children.push(jsx.jsxs("span", { children: ["≈ ", jsx.jsx("strong", { children: "¥" + cost.toFixed(4) })] }));
+      if (hasSubagent) {
+        children.push(jsx.jsx("span", { children: "子代理 +" + formatTokens(subNewTokens) + " ≈ ¥" + subCost.toFixed(4) }));
+      }
+      return jsx.jsx(primitives.Tooltip, {
+        label: detailLines.join("\n"),
+        side: "top",
+        delayMs: 300,
+        children: jsx.jsxs("div", {
+          className: "balance-usage-line",
+          children,
+        }),
+      });
+    }
+
+    // ─── 插件主体 ───────────────────────────────────────────────────────────
+    const inject = ["slots", "sessions"];
+
+    function apply(ctx) {
+      // 拿到 sessions 服务，用于解析当前会话使用的模型（按模型取价）
+      sessionsFace = ctx.sessions;
+      // 余额显示：展开态底部胶囊（order 20 排在市场 10 之后、紧挨设置）；收起态悬浮 FAB
+      ctx.slots.inject("sidebar.footer.action", () =>
+        ctx.slots.register(
+          {
+            name: "sidebar.footer.action",
+            id: "balance",
+            order: 20,
+          },
+          BalanceFooter,
+        ),
+      );
+
+
+        // 关闭按钮：显示在设置上方、余额右侧
+        ctx.slots.inject("sidebar.footer.action", () =>
+          ctx.slots.register(
+            {
+              name: "sidebar.footer.action",
+              id: "shutdown",
+              order: 10,
+            },
+            ShutdownButton,
+          ),
+        );
+
+      // 对话统计区（对话框下方）的会话消耗行
+      ctx.slots.inject("conversation.composer.dock", () =>
+        ctx.slots.register(
+          {
+            name: "conversation.composer.dock",
+            id: "balance-usage",
+            order: 30,
+          },
+          UsageCostLine,
+        ),
+      );
+    }
+
+    exports.apply = apply;
+    exports.inject = inject;
+    return module.exports;
+  },
+});

package/lib/index.js

@@ -0,0 +1,463 @@
+// dsh 插件：余额与当前会话消耗
+// 服务端：注册 /balance 命令 + /balance-api HTTP 接口（供 Web UI 插件直接渲染）
+import { inspectApiRemoteSession } from "@deepseek-ai/dsh-api-remotes";
+
+export const name = "balance-dsh";
+
+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
+const MODEL_PRICING = {
+  "deepseek-v4-flash": { inputCnyPerMillion: 1.5, cacheReadCnyPerMillion: 0.05, cacheWriteCnyPerMillion: 0, outputCnyPerMillion: 4.5 },
+  "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 },
+  "deepseek-reasoner": { inputCnyPerMillion: 4, cacheReadCnyPerMillion: 1, cacheWriteCnyPerMillion: 0, outputCnyPerMillion: 16 },
+};
+const FALLBACK_PRICING = MODEL_PRICING["deepseek-v4-flash"];
+
+// 高峰/空闲时段（V4 峰谷定价，2026-08-17 生效）：高峰价 = 空闲价 × 2。
+// 官方高峰窗口（北京时间）为 周一至周五 09:00-12:00、14:00-18:00；周末全天空闲。
+// 可用 config.peakWindows 覆盖小时窗口（如 [{start:9,end:12},{start:14,end:18}]），
+// 可用 config.peakWeekdays 覆盖周几（1=周一 … 5=周五，默认 [1,2,3,4,5]，0/6=周末）。
+const DEFAULT_PEAK_WINDOWS = [
+  { start: 9, end: 12 },
+  { start: 14, end: 18 },
+];
+const DEFAULT_PEAK_WEEKDAYS = [1, 2, 3, 4, 5];
+
+/** 判断某时间戳（毫秒）是否处于高峰时段（按北京时间 UTC+8 计算，含周几判断）。 */
+function isPeakAt(timeMs, config) {
+  const windows = (Array.isArray(config?.peakWindows) && config.peakWindows.length > 0
+    ? config.peakWindows
+    : DEFAULT_PEAK_WINDOWS
+  ).map((w) => ({ start: Number(w.start), end: Number(w.end) }));
+  const weekdays = Array.isArray(config?.peakWeekdays) && config.peakWeekdays.length > 0
+    ? config.peakWeekdays.map(Number)
+    : DEFAULT_PEAK_WEEKDAYS;
+  const d = new Date(Number(timeMs) + 8 * 60 * 60 * 1000); // 北京时间
+  const hour = d.getUTCHours();
+  const weekday = d.getUTCDay(); // 0=周日 … 6=周六
+  return weekdays.includes(weekday) && windows.some((w) => hour >= w.start && hour < w.end);
+}
+
+/** 把模型字符串规整到定价表键；未识别返回 ""（用 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("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;
+  const price = config?.price ?? {};
+  const multiplier = config?.peak === true ? 2 : 1;
+  const pick = (name, fallback) => Number(price[name] ?? fallback) * multiplier;
+  return {
+    inputCnyPerMillion: pick("inputCnyPerMillion", base.inputCnyPerMillion),
+    cacheReadCnyPerMillion: pick("cacheReadCnyPerMillion", base.cacheReadCnyPerMillion),
+    cacheWriteCnyPerMillion: pick("cacheWriteCnyPerMillion", base.cacheWriteCnyPerMillion),
+    outputCnyPerMillion: pick("outputCnyPerMillion", base.outputCnyPerMillion),
+  };
+}
+
+/** 从会话中识别实际使用的模型。
+ *  优先用 DSH 会话的 requestHeader()/requestContext() 折叠结果（即官方 session.models 取 current 的同一来源），
+ *  取不到再回退遍历 session.events 找 request/header / request/context 事件。 */
+function detectModel(session) {
+  if (!session) return "";
+  // 1) DSH 官方折叠 API：requestHeader().config.model 或 requestContext().model
+  if (typeof session.requestHeader === "function") {
+    const header = session.requestHeader();
+    const m = header?.config?.model;
+    if (typeof m === "string" && m !== "") return m;
+  }
+  if (typeof session.requestContext === "function") {
+    const ctx = session.requestContext();
+    const m = ctx?.model;
+    if (typeof m === "string" && m !== "") return m;
+  }
+  // 2) 兜底：遍历事件
+  let model = "";
+  for (const event of session?.events ?? []) {
+    if (event.type === "request/header") {
+      const m = event.data?.header?.config?.model;
+      if (typeof m === "string" && m !== "") model = m;
+    } else if (event.type === "request/context") {
+      const m = event.data?.model;
+      if (typeof m === "string" && m !== "") model = m;
+    }
+  }
+  return model;
+}
+
+async function resolveApiKey(ctx, config) {
+  if (typeof config?.apiKey === "string" && config.apiKey.trim() !== "") {
+    return config.apiKey.trim();
+  }
+  const credentials = ctx.get("credentials");
+  if (credentials !== void 0) {
+    const resolved = await credentials.resolve("DEEPSEEK_API_KEY");
+    if (resolved !== void 0 && resolved.value.length > 0) {
+      return resolved.value;
+    }
+  }
+  if (process.env.DEEPSEEK_API_KEY && process.env.DEEPSEEK_API_KEY.trim() !== "") {
+    return process.env.DEEPSEEK_API_KEY.trim();
+  }
+  return "";
+}
+
+async function fetchBalance(apiKey, signal) {
+  const response = await fetch(DEEPSEEK_BALANCE_URL, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      Accept: "application/json",
+    },
+    signal,
+  });
+  if (response.status === 401) {
+    throw new Error("DeepSeek API Key 无效或未授权");
+  }
+  if (response.status === 402) {
+    throw new Error("DeepSeek 账户余额不足或 API 未开通");
+  }
+  if (!response.ok) {
+    throw new Error(`余额查询失败：HTTP ${response.status}`);
+  }
+  return response.json();
+}
+
+function normalizeBalance(data) {
+  if (data?.is_available === false) {
+    return {
+      is_available: false,
+      currency: "",
+      total_balance: "0.00",
+      granted_balance: "0.00",
+      topped_up_balance: "0.00",
+    };
+  }
+  const infos = Array.isArray(data?.balance_infos) ? data.balance_infos : [];
+  if (infos.length === 0) {
+    return {
+      is_available: data?.is_available !== false,
+      currency: "",
+      total_balance: "0.00",
+      granted_balance: "0.00",
+      topped_up_balance: "0.00",
+    };
+  }
+  const info = infos[0];
+  return {
+    is_available: data?.is_available !== false,
+    currency: info.currency || "",
+    total_balance: info.total_balance ?? "0.00",
+    granted_balance: info.granted_balance ?? "0.00",
+    topped_up_balance: info.topped_up_balance ?? "0.00",
+  };
+}
+
+function formatBalance(balance) {
+  if (!balance.is_available) {
+    return "余额不可用：账户当前没有可用余额。";
+  }
+  if (!balance.total_balance || balance.total_balance === "0.00") {
+    return "余额查询成功，但暂无余额明细。";
+  }
+  return `余额（${balance.currency || "CNY"}）：${balance.total_balance}\n  充值余额：${balance.topped_up_balance}\n  赠送余额：${balance.granted_balance}`;
+}
+
+/** 从事件数组汇总 usage（跨时段分桶）。供 live 会话与持久化（子代理）会话复用。 */
+function sumEventsUsage(events, config) {
+  const latestByStep = new Map();
+  for (const event of events) {
+    if (event.type !== "assistant/message") continue;
+    const usage = event.data?.usage;
+    if (usage === void 0 || usage === null) continue;
+    const turn = event.data?.turn;
+    const step = event.data?.step;
+    if (turn === void 0 || step === void 0) continue;
+    // 事件带毫秒时间戳（event.time），用于按高峰/空闲时段分桶
+    latestByStep.set(`${turn}/${step}`, { usage, time: event.time ?? Date.now() });
+  }
+  const add = (bucket, usage) => {
+    bucket.inputTokens += usage.inputTokens ?? 0;
+    bucket.outputTokens += usage.outputTokens ?? 0;
+    bucket.cacheReadTokens += usage.cacheReadTokens ?? 0;
+    bucket.cacheWriteTokens += usage.cacheWriteTokens ?? 0;
+  };
+  const empty = () => ({ inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 });
+  const peak = empty();
+  const offpeak = empty();
+  for (const { usage, time } of latestByStep.values()) {
+    add(isPeakAt(time, config) ? peak : offpeak, usage);
+  }
+  const inputTokens = peak.inputTokens + offpeak.inputTokens;
+  const outputTokens = peak.outputTokens + offpeak.outputTokens;
+  const cacheReadTokens = peak.cacheReadTokens + offpeak.cacheReadTokens;
+  const cacheWriteTokens = peak.cacheWriteTokens + offpeak.cacheWriteTokens;
+  const billedInputTokens = inputTokens + cacheReadTokens + cacheWriteTokens;
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheWriteTokens,
+    billedInputTokens,
+    totalTokens: billedInputTokens + outputTokens,
+    peak,
+    offpeak,
+  };
+}
+
+function sumSessionUsage(session, config) {
+  if (session == null) return null;
+  return sumEventsUsage(session.events ?? [], config);
+}
+
+function estimateCost(usage, pricing) {
+  const costOf = (u) =>
+    (u.inputTokens * pricing.inputCnyPerMillion +
+      u.cacheReadTokens * pricing.cacheReadCnyPerMillion +
+      u.cacheWriteTokens * pricing.cacheWriteCnyPerMillion) /
+      1_000_000 +
+    (u.outputTokens * pricing.outputCnyPerMillion) / 1_000_000;
+  // 跨时段精确计费：高峰桶按高峰价（= 目录价 × 2）、空闲桶按目录价。
+  // 注意：若 config.peak:true（resolvePricing 已统一翻倍），高峰桶会再乘一次，两种方式不要同时用。
+  return costOf(usage.peak) * 2 + costOf(usage.offpeak);
+}
+
+/** 汇总某会话的所有子代理后代会话的 usage（跨时段精确计费，与主会话分开）。
+ *  @param ctx DSH 上下文（用于 subagents 服务 + inspectApiRemoteSession）
+ *  @param sessionId 父会话 id
+ *  @param config 插件配置
+ *  说明：子代理会话结束后会被从 live 会话 store 移除，故不能用 store.list() 枚举；
+ *  这里用 subagents 服务的 listDescendants（含已结束/嵌套子代理）取后代 id，
+ *  再对每个子代理用 inspectApiRemoteSession 读取持久化事件计算 usage。无子代理返回 {usage:null,debug}。 */
+async function sumSubagentUsage(ctx, sessionId, config) {
+  if (ctx == null || sessionId === "") return { usage: null };
+  // subagents 需通过 ctx.inject(["subagents"]) 注入后才可访问（见 apply 里的 webServer 注入列表）。
+  const subagentsSvc = ctx.subagents != null ? ctx.subagents : (typeof ctx.get === "function" ? ctx.get("subagents") : void 0);
+  const listDescendants = subagentsSvc != null && typeof subagentsSvc.listDescendants === "function" ? subagentsSvc.listDescendants.bind(subagentsSvc) : void 0;
+  // 1) 用 subagents.listDescendants 一次取完整后代树（含编号/层级/已结束）
+  let descendants = [];
+  if (listDescendants != null) {
+    try {
+      descendants = await listDescendants(sessionId);
+    } catch {
+      descendants = [];
+    }
+  }
+  const childIds = new Set();
+  for (const e of descendants) {
+    if (e == null || typeof e !== "object") continue;
+    if (typeof e.id !== "string" || e.id === "") continue;
+    childIds.add(e.id);
+  }
+  if (childIds.size === 0) return { usage: null };
+
+  // 2) 对每个子代理读取持久化事件并求和
+  const empty = () => ({ inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 });
+  const peak = empty();
+  const offpeak = empty();
+  let count = 0;
+  for (const id of childIds) {
+    try {
+      const inspected = await inspectApiRemoteSession(ctx, id);
+      const events = Array.isArray(inspected?.events) ? inspected.events : [];
+      const u = sumEventsUsage(events, config);
+      if (u === null || u === void 0) continue;
+      count++;
+      peak.inputTokens += u.peak.inputTokens;
+      peak.outputTokens += u.peak.outputTokens;
+      peak.cacheReadTokens += u.peak.cacheReadTokens;
+      peak.cacheWriteTokens += u.peak.cacheWriteTokens;
+      offpeak.inputTokens += u.offpeak.inputTokens;
+      offpeak.outputTokens += u.offpeak.outputTokens;
+      offpeak.cacheReadTokens += u.offpeak.cacheReadTokens;
+      offpeak.cacheWriteTokens += u.offpeak.cacheWriteTokens;
+    } catch {
+      // 该子代理读取失败则跳过
+    }
+  }
+  if (count === 0) return { usage: null };
+  const inputTokens = peak.inputTokens + offpeak.inputTokens;
+  const outputTokens = peak.outputTokens + offpeak.outputTokens;
+  const cacheReadTokens = peak.cacheReadTokens + offpeak.cacheReadTokens;
+  const cacheWriteTokens = peak.cacheWriteTokens + offpeak.cacheWriteTokens;
+  const billedInputTokens = inputTokens + cacheReadTokens + cacheWriteTokens;
+  const usage = {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheWriteTokens,
+    billedInputTokens,
+    totalTokens: billedInputTokens + outputTokens,
+    peak,
+    offpeak,
+    sessions: count,
+  };
+  return { usage };
+}
+
+function formatUsage(usage, pricing, model = "") {
+  const cost = 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;
+  const modelLine = model === "" ? "" : `（模型 ${model}）`;
+  const lines = [
+    `当前会话消耗${modelLine}：`,
+    `  新增 tokens：${newTokens}（未缓存输入 ${usage.inputTokens} + 输出 ${usage.outputTokens}）`,
+    `  计费 tokens：${usage.totalTokens}（含缓存重读 ${usage.cacheReadTokens}、缓存写入 ${usage.cacheWriteTokens}）`,
+    `    - 未缓存输入：${usage.inputTokens}`,
+    `    - 缓存读取：${usage.cacheReadTokens}`,
+    `    - 缓存写入：${usage.cacheWriteTokens}`,
+    `    - 输出 tokens：${usage.outputTokens}`,
+    `  估算消耗：¥${cost.toFixed(4)}（按 ${modelKey(model) || "deepseek-v4-flash"} 目录价估算，实际以账单为准）`,
+    `  时段拆分：高峰 ${peakTokens} tokens、空闲 ${offpeakTokens} tokens（跨时段按各自时段价计费）`,
+  ];
+  return lines.join("\n");
+}
+
+function writeJson(res, status, payload) {
+  const body = JSON.stringify(payload);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-store",
+  });
+  res.end(body);
+}
+
+export function apply(ctx, config = {}) {
+  // 1) /balance 命令：保留命令行查询入口
+  ctx.inject(["commands"], (commandCtx) => {
+    commandCtx.commands.register({
+      name: "balance",
+      description: "查询 DeepSeek 余额与当前会话消耗",
+      handler: async ({ agent, signal }) => {
+        const apiKey = await resolveApiKey(ctx, config);
+        if (apiKey === "") {
+          return {
+            kind: "error",
+            text: "未找到 DeepSeek API Key，请设置环境变量 DEEPSEEK_API_KEY 后重试。",
+          };
+        }
+
+        const usage = sumSessionUsage(agent.session, config);
+        const model = detectModel(agent.session);
+        const pricing = resolvePricing(config, model);
+
+        try {
+          const data = await fetchBalance(apiKey, signal);
+          const balanceText = formatBalance(normalizeBalance(data));
+          return {
+            kind: "success",
+            text: `${balanceText}\n\n${formatUsage(usage, pricing, model)}`,
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return {
+            kind: "error",
+            text: `${message}\n\n${formatUsage(usage, pricing, model)}`,
+          };
+        }
+      },
+    });
+  });
+
+  // 2) /balance-api HTTP 接口：供客户端插件直接渲染余额（不经过命令，不污染会话日志）
+  ctx.inject(["webServer", "subagents"], (httpCtx) => {
+    httpCtx.webServer.register({
+      kind: "exact",
+      path: "/balance-api",
+      handler: async (req, res) => {
+        if (req.method !== "GET") {
+          writeJson(res, 405, { ok: false, error: "method not allowed" });
+          return;
+        }
+        // 客户端把当前会话使用的模型通过 ?model= 传入，服务端按模型取价；
+        // 可选 ?session= 传入会话 id，服务端返回该会话的分时段 usage（跨时段精确计费用）
+        let model = "";
+        let sessionParam = "";
+        try {
+          const search = new URL(req.url, "http://localhost").searchParams;
+          model = search.get("model") ?? "";
+          sessionParam = search.get("session") ?? "";
+        } catch {
+          model = "";
+          sessionParam = "";
+        }
+        const apiKey = await resolveApiKey(ctx, config);
+        if (apiKey === "") {
+          writeJson(res, 200, { ok: false, error: "未设置 DEEPSEEK_API_KEY" });
+          return;
+        }
+        // 按 session id 取会话并分时段汇总 usage（拿不到则返回 null，客户端回退用本地投影）
+        let usage = null;
+        // 子代理后代会话的 usage 汇总（与主会话分开）
+        let subagentUsage = null;
+        // 从会话事件识别实际使用模型（客户端未传 ?model= 时兜底）
+        let detectedModel = "";
+        if (sessionParam !== "") {
+          try {
+            const sessions = ctx.get("sessions");
+            const session = sessions && typeof sessions.get === "function" ? sessions.get(sessionParam) : void 0;
+            if (session !== void 0) {
+              usage = sumSessionUsage(session, config);
+              detectedModel = detectModel(session);
+            }
+            // 子代理枚举走持久化目录（不依赖 live 会话），即使父会话不在内存也能拿到
+            const subRes = await sumSubagentUsage(httpCtx, sessionParam, config);
+            subagentUsage = subRes.usage;
+          } catch {
+            usage = null;
+            subagentUsage = null;
+          }
+        }
+        // 客户端优先用自己解析的 model；为空则回退到服务端 detectModel
+        const effectiveModel = model || detectedModel;
+        try {
+          const data = await fetchBalance(apiKey);
+          writeJson(res, 200, {
+            ok: true,
+            balance: normalizeBalance(data),
+            pricing: resolvePricing(config, effectiveModel),
+            model: effectiveModel,
+            usage,
+            subagentUsage,
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          writeJson(res, 200, { ok: false, error: message });
+        }
+      },
+    });
+
+
+      httpCtx.webServer.register({
+        kind: "exact",
+        path: "/shutdown-api",
+        handler: async (req, res) => {
+          if (req.method !== "POST") {
+            writeJson(res, 405, { ok: false, error: "method not allowed" });
+            return;
+          }
+          writeJson(res, 200, { ok: true });
+          const exit = ctx.get("appExit");
+          setTimeout(() => {
+            if (typeof exit === "function") exit(0);
+            else process.exit(0);
+          }, 150);
+        },
+      });
+  });
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "balance-dsh",
+  "version": "1.0.0",
+  "description": "查询 DeepSeek 余额并显示当前会话 token 消耗。DeepSeek 账户余额 + 会话 token/费用显示，含高峰/空闲峰谷计费。",
+  "author": "Rannist",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek",
+    "deepseek-harness",
+    "balance",
+    "usage",
+    "cost",
+    "token",
+    "billing"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime"
+      ],
+      "immediately": true
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rannist/balance-dsh"
+  },
+  "homepage": "https://github.com/Rannist/balance-dsh#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "dependencies": {}
+}