dsh-bottom-info-bar 1.7.0 → 1.8.0

package/lib/client.js

@@ -25,6 +25,12 @@ const HIDE_SPEED_FIELDS = true;
 // RPC 超时兜底：host 侧 15s 超时之上再留余量；端点挂起时 20s 内必失败，杜绝永久"加载中…"
 const RPC_TIMEOUT_MS = 20000;
 
+// 首启强制刷新窗口：页面刚打开/用户手动刷新后的这几秒内，快照请求带 force=true，
+// host 会绕过缓存与失败退避当场重查服务商——用户刷新页面立即看到最新余额/额度，
+// 不必干等后台 60s 自动周期。覆盖窗口需容纳会话模型从空到确定的短暂翻转期。
+const BOOT_AT = Date.now();
+const FORCE_REFRESH_WINDOW_MS = 6000;
+
 // rpc(method, args, externalSignal)：
 // - 超时：20s 未响应 → abort 并以"请求超时"失败（fetch 挂起不阻塞界面）
 // - 可中止：传入外部 AbortSignal（组件卸载时 abort）→ 立即取消并拒绝"请求已取消"
@@ -343,11 +349,14 @@ module.exports = {
         const requestVersion = ++loadVersionRef.current;
         const activeSelection = selection || activeSessionModel;
         const selectionArgs = activeSelection ? { selection: { provider: activeSelection.provider, model: activeSelection.model } } : {};
+        // 首启窗口内（打开/刷新网页头几秒）→ 快照类请求强制重查；之后的 30s 周期轮询走常规缓存节奏
+        const force = Date.now() - BOOT_AT < FORCE_REFRESH_WINDOW_MS;
+        if (force) { selectionArgs.force = true; }
         const signal = abortRef.current ? abortRef.current.signal : null;
         // 逐接口容错：allSettled 等全部 settle（最坏 20s 超时兜底），任一失败只降级该端点，
         // 不拖垮其他成功数据；合并逻辑在 mergeLoadResults（失败端点保留旧值 + 记录错误）
         Promise.allSettled([
-          rpc('getBalanceSnapshot', activeSelection ? { provider: activeSelection.provider } : null, signal),
+          rpc('getBalanceSnapshot', activeSelection ? { provider: activeSelection.provider, force: force } : (force ? { force: true } : null), signal),
           rpc('getPricing', selectionArgs, signal),
           rpc('getUsageSummary', Object.assign({ sessionId: sessionId }, selectionArgs), signal),
           rpc('getBillingMode', selectionArgs, signal),
@@ -656,33 +665,39 @@ module.exports = {
             metric('距' + (peakNow ? '空闲' : '高峰'), fmtCountdown(pr.nextSwitch.at - now))));
         }
 
-        // 本会话花费（只显示钱；hover 浮窗显示 本会话（含子代理）+ 今天 / 近一月 / 全部；金额数字加粗）
+        // 本会话花费（公共小部件 pushSessionCost：只显示钱；hover 显示 今天/近一月/全部）
         // 始终显示：新会话/对话刚开始尚无记账时显示 ¥0.000，hover 仍可查看持久化的 今天/近一月/全部
+        pushSessionCost(groups, trailingErrorGroups, !!(bal && bal.currency === 'USD'));
+      }
+
+      // 本会话花费块（余额制 与 订阅·充值余额 形态共用的小部件）：
+      // 只显示钱；hover 浮窗显示 含子代理说明 + 今天 / 近一月 / 全部；金额数字加粗。
+      // usdSymbol：账户币种为美元时，hover 汇总行用 $ 前缀（本会话单值仍按其真实计价币种）
+      function pushSessionCost(groups, trailingErrorGroups, usdSymbol) {
         const usg = state.usage;
+        const errs = state.errors || {};
         if (usg) {
           const cs = usg.currentSession;
           const costCNY = cs && cs.costs && cs.costs.CNY != null ? cs.costs.CNY : null;
           const costUSD = cs && cs.costs && cs.costs.USD != null ? cs.costs.USD : null;
-          const zeroTxt = (bal && bal.currency === 'USD' ? '$' : '¥') + (0).toFixed(3);
+          const symbol = usdSymbol ? '$' : '¥';
           const costTxt = costCNY != null ? '¥' + costCNY.toFixed(3)
-            : (costUSD != null ? '$' + costUSD.toFixed(3) : zeroTxt);
-          const symbol = bal && bal.currency === 'USD' ? '$' : '¥';
+            : (costUSD != null ? '$' + costUSD.toFixed(3) : symbol + (0).toFixed(3));
           const today = usg.todaySpend != null ? '今天 ' + symbol + fmt(usg.todaySpend, 3) : '';
           const month = usg.monthSpend != null ? '近一月 ' + symbol + fmt(usg.monthSpend, 3) : '';
           const total = usg.totalSpend != null ? '全部 ' + symbol + fmt(usg.totalSpend, 3) : '';
           const detail = [today, month, total].filter(function (s) { return s.length > 0; }).join(' · ');
-          // v1.7 发布前微调：hover 明确标注"含子代理"——本会话聚合同账户所有记录（同起点后）
           groups.push(React.createElement('span', { key: 'convo',
             title: '本会话 ' + costTxt + '（含子代理）' + (detail ? '\n' + detail : '') },
             metric('本会话', costTxt)));
-        } else if (errors.usage) {
-          // 本次 RPC 失败且无旧数据：只降级花费块，其余端点数据照常渲染
+        } else if (errs.usage) {
           trailingErrorGroups.push(React.createElement('span', { className: 'bi-err', key: 'usageerr', title: '花费暂不可用；不会影响对话。' }, '花费获取失败'));
         }
       }
 
-      // ---- 订阅制模式（互斥替换余额制版，row2 只三类信息）：
-      //      订阅服务+模型 → 三窗口额度 → 距重置倒计时（最紧窗口）；余额/时段/花费/token 均不显示 ----
+      // ---- 订阅制模式（互斥替换余额制版）：
+      //      套餐额度型：订阅服务+模型 → 三窗口额度 → 距重置倒计时（余额/时段/花费/token 不显示）
+      //      充值余额型（如智谱按量账户，windows 空且有 sub.balance）：服务商+模型 → 余额 → 本会话花费 ----
        function subscriptionFailureHint(error, source) {
          const kind = error && error.kind;
          const serviceName = subscriptionServiceName(source);
@@ -726,6 +741,22 @@ module.exports = {
           trailingErrorGroups.push(React.createElement('span', { className: 'bi-stale', key: 'substale', title: subscriptionFailureHint(sub.error, sub.source || (visibleBillingMode && visibleBillingMode.provider)) }, '刷新失败'));
           return;
         }
+        // v1.8：充值余额模式——无额度窗口但有 balance 字段（如智谱普通 API 余额用户）
+        // 显示"余额 ¥XX.XX"，与 Coding Plan 额度窗口互斥
+        if (!hasData && typeof sub.balance === 'number' && isFinite(sub.balance)) {
+          const balTxt = '¥' + fmt(sub.balance, 2);
+          const titleLines = ['订阅源：' + subscriptionServiceName(visibleBillingMode && visibleBillingMode.provider) + '（' + (sub.plan || '充值余额') + '）',
+            '可用余额：' + balTxt];
+          groups.push(React.createElement('span', { key: 'subbal', title: titleLines.join('\n') },
+            metric('余额', balTxt)));
+          // 充值余额用户按量付费，花销与余额同等重要 → 追加公共花费块（含子代理聚合）
+          pushSessionCost(groups, trailingErrorGroups, false);
+          // host 快照失败（sub.error）或本次 RPC 失败（errors.sub）→ 保留旧数据 + 降级标记
+          if (sub.error || errors.sub) {
+            trailingErrorGroups.push(React.createElement('span', { className: 'bi-stale', key: 'substale', title: subscriptionFailureHint(sub.error || { kind: 'exception', message: String(errors.sub || '') }, sub.source || (visibleBillingMode && visibleBillingMode.provider)) }, '刷新失败'));
+          }
+          return;
+        }
         // 窗口缺失（如 Codex 无 5 小时窗口）→ 跳过窗口组，不占位、不报错
         if (hasData) {
           // 简洁模式下选择"时间最短且有重置时刻"的窗口（刷新最快，用户最需关注）：

package/lib/index.js

@@ -107,6 +107,11 @@ function accountForProvider(pid) {
   return null
 }
 
+// 服务商在账单（usage）里直接报告真实金额时，按服务商固定币种回填。
+// 仅列明确用美元计价的聚合商（如 OpenRouter）；未登记的走价目表币种回退。
+// 动机：聚合商路由模型数量庞大、价目无法静态维护——官方报出的钱 > 本地任何换算。
+const PROVIDER_REPORTED_CURRENCY = { openrouter: 'USD' }
+
 // ---------- 双模式纯逻辑（模式检测 / 窗口映射 / 响应解析；单测直接提取） ----------
 
 // 窗口时长（秒）→ 窗口键：18000≈5小时 / 604800≈7天 / 2592000≈30天，5% 容差；未知返回 null
@@ -765,13 +770,135 @@ export default {
       'deepseek-chat': { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.5, inputCacheMiss: 2.0, output: 8.0 } },
       'gpt-4o':        { currency: 'USD', mode: 'flat', price: { inputCacheHit: 1.25, inputCacheMiss: 2.5, output: 10.0 } },
       'gpt-4o-mini':   { currency: 'USD', mode: 'flat', price: { inputCacheHit: 0.15, inputCacheMiss: 0.15, output: 0.6 } },
+      // ---------- 智谱 BigModel 官方按量价（CNY/百万 tokens；来源 open.bigmodel.cn/pricing，
+      // 采集记录与全档分段备注见 docs/research/bigmodel-pricing-202608.md）----------
+      // 分段模型主条目取基础档（输入≤32K 等），长上下文档暂不计入——影响与限制见体系审计报告。
+      'glm-5.3':       { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 2,    inputCacheMiss: 8,   output: 28 } },
+      // flash 存在"5折限时两周"双价：内置表取刊例价 0.8/0.23/2.8（保守）；
+      // 远程目录按用户当前实扣配促销价（活动窗口约至 2026-09 初，详见 catalog/pricing.json notes）
+      'glm-5.3-flash': { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.23, inputCacheMiss: 0.8, output: 2.8 } },
+      'glm-5.2':       { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 2,    inputCacheMiss: 8,   output: 28 } },
+      'glm-5.1':       { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 1.3,  inputCacheMiss: 6,   output: 24 } },
+      'glm-5-turbo':   { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 1.2,  inputCacheMiss: 5,   output: 22 } },
+      'glm-5v-turbo':  { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 1.2,  inputCacheMiss: 5,   output: 22 } },
+      'glm-4.7':       { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.4,  inputCacheMiss: 2,   output: 8 } },
+      'glm-4.5-air':   { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.16, inputCacheMiss: 0.8, output: 2 } },
+      // ---------- 小米 MiMo 按量官方价（mimo.mi.com/docs/zh-CN/price/pay-as-you-go，2026-08-06 调价后 CNY；
+      // 本机 pi-ai 目录里的 cost 字段是 USD 数字——严禁混用，详见体系审计报告）----------
+      'mimo-v2-flash':  { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.02,  inputCacheMiss: 1,   output: 2 } },
+      'mimo-v2-omni':   { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.02,  inputCacheMiss: 1,   output: 2 } },
+      'mimo-v2-pro':    { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.025, inputCacheMiss: 3,   output: 6 } },
+      'mimo-v2.5':      { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.02,  inputCacheMiss: 1,   output: 2 } },
+      'mimo-v2.5-pro':  { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.025, inputCacheMiss: 3,   output: 6 } },
+      // mimo-v2.5-pro-ultraspeed：官方仅美元口径、人民币数未独立确认 → 按"不臆测"暂不收录
+      // ---------- 阶跃 StepFun 在售文本模型（platform.stepfun.com 定价详情；step-1/2/3 系已于 2026-07 下线）----------
+      'step-3.7-flash': { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.27,  inputCacheMiss: 1.35, output: 8.1 } },
+      'step-3.5-flash': { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.14,  inputCacheMiss: 0.7,  output: 2.1 } },
+      // ---------- Kimi 国内站（provider=moonshotai-cn → api.moonshot.cn 计费 ¥）----------
+      // 同型号在 api.moonshot.ai 国际站按 $ 另计：官方 USD 数字待采集后以 'moonshotai:kimi-*'
+      // 作用域键收录；裸 kimi-* 键刻意留空，防止币种串档。
+      'moonshotai-cn:kimi-k3':                 { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 2,    inputCacheMiss: 20,   output: 100 } },
+      'moonshotai-cn:kimi-k2.5':               { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.7,  inputCacheMiss: 4,    output: 21 } },
+      'moonshotai-cn:kimi-k2.6':               { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 1.1,  inputCacheMiss: 6.5,  output: 27 } },
+      'moonshotai-cn:kimi-k2.7-code':          { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 1.3,  inputCacheMiss: 6.5,  output: 27 } },
+      'moonshotai-cn:kimi-k2.7-code-highspeed':{ currency: 'CNY', mode: 'flat', price: { inputCacheHit: 2.6,  inputCacheMiss: 13,   output: 54 } },
+      'moonshotai-cn:kimi-k2-0711-preview':    { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.15, inputCacheMiss: 0.6,  output: 2.5 } },
+      'moonshotai-cn:kimi-k2-0905-preview':    { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.15, inputCacheMiss: 0.6,  output: 2.5 } },
+      'moonshotai-cn:kimi-k2-thinking':        { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.15, inputCacheMiss: 0.6,  output: 2.5 } },
+      'moonshotai-cn:kimi-k2-thinking-turbo':  { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.15, inputCacheMiss: 1.15, output: 8 } },
+      'moonshotai-cn:kimi-k2-turbo-preview':   { currency: 'CNY', mode: 'flat', price: { inputCacheHit: 0.6,  inputCacheMiss: 2.4,  output: 10 } },
     };
-    function modelCurrency(model) {
-      const entry = PRICING[model];
+    function modelCurrency(provider, model) {
+      // 服务商作用域键优先：同名模型跨计费域时（Kimi 国内外），币种必须跟作用域走
+      const entry = pricingEntryFor(provider, model);
       if (entry && entry.currency) return entry.currency;
       return model && model.indexOf('gpt') === 0 ? 'USD' : 'CNY';
     }
     const DEFAULT_MODEL = 'deepseek-v4-flash';
+
+    // ---------- 远程价目目录（v1.8）：内置表兜底 + 启动/定时增量更新 ----------
+    // 设计目标（用户铁律）：接入新模型/新价格不再依赖插件发版。
+    // 机制：启动时先用磁盘缓存离线合并，再异步拉取远程 catalog/pricing.json 增量合并；
+    //       每合并一次立即重跑 unpriced 回填 → 新覆盖的模型的历史账目自动补算。
+    // 安全边界：仅接受"声明式数字"（统一价 + 白名单币种），绝不执行远程代码；
+    //          匿名 GET 不携带任何密钥/用户标识；失败静默降级缓存与内置表，不影响信息栏。
+    const REMOTE_PRICING_URL = process.env.DSH_BOTTOM_INFO_BAR_PRICING_URL
+      || 'https://raw.githubusercontent.com/songoao25/dsh-bottom-info-bar/main/catalog/pricing.json';
+    const REMOTE_PRICING_REFRESH_MS = 6 * 60 * 60 * 1000; // 定时刷新：6 小时
+    const PRICING_CACHE_FILE = join(DATA_DIR, 'pricing-cache.json');
+    let remotePricingEtag = null;
+
+    // 校验目录条目：只放行可安全参与计算的声明式数据
+    function sanitizeRemotePricingEntries(raw) {
+      if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+      const entries = {};
+      for (const key of Object.keys(raw)) {
+        if (Object.keys(entries).length >= 512) break; // 容量上限，防滥用
+        if (!/^[A-Za-z0-9._:-]{1,64}$/.test(key)) continue; // 允许 "provider:model" 作用域键（跨币种同名模型）
+        const e = raw[key];
+        if (!e || typeof e !== 'object') continue;
+        // v1 仅接受统一价（flat）；分时价的窗口规则须随框架参数化后再开放远程下发
+        if (e.mode !== 'flat' || !e.price || typeof e.price !== 'object') continue;
+        if (e.currency !== 'CNY' && e.currency !== 'USD') continue; // 白名单币种
+        const hit = Number(e.price.inputCacheHit);
+        const miss = Number(e.price.inputCacheMiss);
+        const out = Number(e.price.output);
+        if (!Number.isFinite(hit) || !Number.isFinite(miss) || !Number.isFinite(out)) continue;
+        if (miss <= 0 || hit < 0 || out < 0) continue;
+        if (hit > miss) continue; // 缓存命中不可能比未命中更贵：脏数据拒收
+        entries[key] = { currency: e.currency, mode: 'flat', price: { inputCacheHit: hit, inputCacheMiss: miss, output: out } };
+      }
+      return Object.keys(entries).length > 0 ? entries : null;
+    }
+
+    // 合并进运行时价目表并触发回填；返回本次新增/更新的条数
+    function applyRemotePricingEntries(entries) {
+      if (!entries) return 0;
+      let n = 0;
+      for (const key of Object.keys(entries)) {
+        PRICING[key] = entries[key];
+        n++;
+      }
+      if (n > 0) backfillUnpricedRecords();
+      return n;
+    }
+
+    function loadPricingCacheFromDisk() {
+      try {
+        const parsed = JSON.parse(readFileSync(PRICING_CACHE_FILE, 'utf8'));
+        return sanitizeRemotePricingEntries(parsed && parsed.entries);
+      } catch (err) { /* 无缓存/损坏 → 内置表兜底 */ }
+      return null;
+    }
+
+    function savePricingCacheToDisk(entries) {
+      try {
+        mkdirSync(DATA_DIR, { recursive: true, mode: 0o700 });
+        writeAndSync(PRICING_CACHE_FILE, JSON.stringify({ fetchedAt: Date.now(), etag: remotePricingEtag, entries: entries }), 'w');
+      } catch (err) { /* 缓存写失败不致命 */ }
+    }
+
+    async function refreshRemotePricing(reason) {
+      try {
+        const headers = {};
+        if (remotePricingEtag) headers['If-None-Match'] = remotePricingEtag;
+        const res = await fetch(REMOTE_PRICING_URL, { headers, signal: AbortSignal.timeout(10000) });
+        if (res.status === 304) return { status: 'fresh' }; // 目录未变
+        if (!res.ok) throw new Error('HTTP ' + res.status);
+        const body = await res.json();
+        const entries = sanitizeRemotePricingEntries(body);
+        if (!entries) throw new Error('目录格式不符合规范');
+        remotePricingEtag = res.headers.get('etag');
+        savePricingCacheToDisk(entries);
+        const merged = applyRemotePricingEntries(entries);
+        console.warn('[dsh-bottom-info-bar] 远程价目已合并（' + reason + '）：' + merged + ' 条有效条目');
+        return { status: 'merged', count: merged };
+      } catch (err) {
+        console.warn('[dsh-bottom-info-bar] 远程价目获取失败（' + reason + '），沿用缓存/内置表：' + String((err && err.message) || err));
+        return { status: 'error', message: String((err && err.message) || err) };
+      }
+    }
+
     const SCENARIOS = [
       { id: 'qa',       label: '日常问答',            outputK: 2,   inputK: 4 },
       { id: 'coding',   label: '中等编码任务',        outputK: 15,  inputK: 30 },
@@ -911,7 +1038,7 @@ export default {
 
     function refreshProviderBalance(pid) {
       const prov = PROVIDERS[pid];
-      if (!prov) return;
+      if (!prov) return Promise.resolve();
       const seq = (balanceSeq[pid] || 0) + 1;
       balanceSeq[pid] = seq;
       if (!prov.balanceAPI) {
@@ -919,9 +1046,10 @@ export default {
         const spend = providerSpend(pid);
         const total = Math.max(0, prov.initialTopUp - spend);
         balances[pid] = { data: { currency: 'USD', total: total, granted: 0, toppedUp: prov.initialTopUp }, fetchedAt: Date.now(), error: null };
-        return;
+        return Promise.resolve();
       }
-      (async function () {
+      // 返回本次刷新 Promise：强制刷新路径（客户端打开页面）需等待最新结果落快照后再返回
+      return (async function () {
         let cred = null;
         try {
           cred = await ctx.credentials.resolve(prov.credential);
@@ -967,6 +1095,7 @@ export default {
     const subscriptionSeq = {}; // 每 source 刷新序号：仅最新一次请求可写入快照
     const subscriptionInFlight = {}; // { [sourceKey]: Promise } 并发去重（同一时刻只发一个请求）
     const subscriptionRequested = {}; // 仅"客户端请求过"的源进入 60s 周期刷新（余额制下不打扰订阅接口）
+    const subscriptionSourceProvider = {}; // { [sourceKey]: providerId }——记住请求该源时的 provider（zai 系按 provider 路由 host/凭据）
     const subscriptionLastFailAt = {}; // { [sourceKey]: ms } 上次订阅刷新失败时刻（失败退避：期内不重试）
 
     // FR-8 / D7：Codex / ChatGPT 订阅卡（纯本地通道）
@@ -1038,12 +1167,17 @@ export default {
     // host：zai-coding-cn → https://open.bigmodel.cn；zai → https://api.z.ai
     // 认证：两者均 Authorization 裸 API Key，绝无 Bearer 前缀（加 Bearer 会 401）
     async function resolveZaiKey(providerId) {
+      // 凭据与 host 匹配：zai（国际）→ 优先 ZAI_API_KEY；zai-coding-cn（国内）→ 优先 ZAI_CODING_CN_API_KEY。
+      // 用户通常只配一个，回退另一名防止误配。
+      const isCn = providerId === 'zai-coding-cn';
+      const primary = isCn ? 'ZAI_CODING_CN_API_KEY' : 'ZAI_API_KEY';
+      const fallback = isCn ? 'ZAI_API_KEY' : 'ZAI_CODING_CN_API_KEY';
       try {
-        const cred = await ctx.credentials.resolve('ZAI_CODING_CN_API_KEY');
+        const cred = await ctx.credentials.resolve(primary);
         if (cred && typeof cred.value === 'string' && cred.value.length > 0) return cred.value;
       } catch (err) { /* 回退 */ }
       try {
-        const cred = await ctx.credentials.resolve('ZAI_API_KEY');
+        const cred = await ctx.credentials.resolve(fallback);
         if (cred && typeof cred.value === 'string' && cred.value.length > 0) return cred.value;
       } catch (err) { /* 未配置 */ }
       return null;
@@ -1096,36 +1230,82 @@ export default {
       return { plan: planName, windows: windows };
     }
 
-    async function fetchZaiUsage() {
-      // 从当前 provider 决定用哪个 host（zai-coding-cn vs zai）
-      // 这里通过 subscriptionSourceFor 反推，但实际 RPC 调用时 selection 会传 provider
-      // 为简化，先尝试两个 host
-      const key = await resolveZaiKey();
+    // 解析智谱充值余额响应（/api/biz/account/query-customer-account-report）
+    // 被 CodexBar PR#3109、CodexMeter PR#2 等多个项目验证的非公开控制台 API
+    function parseZaiBalance(body) {
+      if (!body || typeof body !== 'object') return null;
+      if (body.success === false || body.code !== 200) return null;
+      const d = body.data;
+      if (!d || typeof d !== 'object') return null;
+      // availableBalance 优先（可用余额），fallback 到 balance
+      const bal = typeof d.availableBalance === 'number' ? d.availableBalance
+        : (typeof d.balance === 'number' ? d.balance : null);
+      if (bal === null || !isFinite(bal)) return null;
+      return { balance: bal };
+    }
+
+    async function fetchZaiUsage(providerId) {
+      // 按 provider 路由 host 与凭据：zai-coding-cn → open.bigmodel.cn（国内密钥）；
+      // zai → api.z.ai（国际密钥）。两端均裸 API Key（无 Bearer 前缀）。
+      // 自动检测用户类型：先尝试 Coding Plan 额度接口，失败后回退充值余额接口。
+      const resolvedProvider = providerId === 'zai-coding-cn' ? 'zai-coding-cn' : 'zai';
+      const key = await resolveZaiKey(resolvedProvider);
       if (!key) {
-        return { error: { kind: 'no-key', message: '未配置智谱 API Key（ZAI_CODING_CN_API_KEY 或 ZAI_API_KEY）' } };
+        return { error: { kind: 'no-key', message: '未配置智谱 API Key（ZAI_API_KEY 或 ZAI_CODING_CN_API_KEY）' } };
       }
-      // 尝试两个 host，优先国内
-      const hosts = ['https://open.bigmodel.cn', 'https://api.z.ai'];
-      for (let i = 0; i < hosts.length; i++) {
-        try {
-          const res = await fetch(hosts[i] + '/api/monitor/usage/quota/limit', {
-            headers: { Authorization: key }, // 裸 API Key，无 Bearer 前缀
-            signal: AbortSignal.timeout(15000),
-          });
-          if (!res.ok) {
-            if (i < hosts.length - 1) continue; // 尝试下一个 host
-            return { error: { kind: 'http', message: '请求失败（HTTP ' + res.status + '）' } };
+      const host = zaiHostForProvider(resolvedProvider);
+
+      // ---- 第一步：尝试 Coding Plan 额度接口 ----
+      try {
+        const res = await fetch(host + '/api/monitor/usage/quota/limit', {
+          headers: { Authorization: key }, // 裸 API Key，无 Bearer 前缀
+          signal: AbortSignal.timeout(15000),
+        });
+        const body = await res.json().catch(() => null);
+        // 智谱 API 常在 HTTP 200 内返回业务错误（{code:401, success:false, msg:...}），需先检查
+        if (body && body.success === false) {
+          const msg = body.msg || body.message || '';
+          // "当前用户不存在 coding plan" → 非订阅用户，回退到充值余额接口
+          if (/不存在.*coding\s*plan|no.*coding\s*plan/i.test(msg)) {
+            return fetchZaiBalanceFallback(host, key, resolvedProvider);
           }
-          const body = await res.json();
-          const parsed = parseZaiQuota(body);
-          if (!parsed) return { error: { kind: 'parse', message: '响应格式异常' } };
-          return { data: { provider: 'zai', plan: parsed.plan, windows: parsed.windows } };
-        } catch (err) {
-          if (i < hosts.length - 1) continue; // 尝试下一个 host
-          return { error: { kind: 'exception', message: String((err && err.message) || err) } };
+          if (body.code === 401 || /过期|不正确|unauthorized|expired/i.test(msg))
+            return { error: { kind: 'auth', message: '智谱 API 认证失败（密钥过期或不正确）' } };
+          return { error: { kind: 'http', message: '请求失败（' + (body.code || '') + ' ' + msg + '）' } };
+        }
+        if (!res.ok) return { error: { kind: 'http', message: '请求失败（HTTP ' + res.status + '）' } };
+        const parsed = parseZaiQuota(body);
+        if (!parsed) return { error: { kind: 'parse', message: '响应格式异常' } };
+        return { data: { provider: 'zai', plan: parsed.plan, windows: parsed.windows } };
+      } catch (err) {
+        return { error: { kind: 'exception', message: String((err && err.message) || err) } };
+      }
+    }
+
+    // 智谱充值余额回退：Coding Plan 接口报"不存在 coding plan"时自动查询充值余额
+    async function fetchZaiBalanceFallback(host, key, resolvedProvider) {
+      try {
+        // open.bigmodel.cn 与 www.bigmodel.cn 均可用；国际站 api.z.ai 无此接口
+        const balanceHost = host === 'https://api.z.ai' ? 'https://open.bigmodel.cn' : host;
+        const res = await fetch(balanceHost + '/api/biz/account/query-customer-account-report', {
+          headers: { Authorization: 'Bearer ' + key }, // Bearer 认证（与裸 Key 均可）
+          signal: AbortSignal.timeout(15000),
+        });
+        const body = await res.json().catch(() => null);
+        if (body && body.success === false) {
+          const msg = body.msg || body.message || '';
+          if (body.code === 401 || body.code === 1000 || /过期|不正确|unauthorized|expired/i.test(msg))
+            return { error: { kind: 'auth', message: '智谱 API 认证失败（密钥过期或不正确）' } };
+          return { error: { kind: 'http', message: '请求失败（' + (body.code || '') + ' ' + msg + '）' } };
         }
+        if (!res.ok) return { error: { kind: 'http', message: '请求失败（HTTP ' + res.status + '）' } };
+        const parsed = parseZaiBalance(body);
+        if (!parsed) return { error: { kind: 'parse', message: '响应格式异常' } };
+        // 返回充值余额：balance 字段携带金额，windows 为空（无额度窗口）
+        return { data: { provider: 'zai', plan: '充值余额', windows: [], balance: parsed.balance } };
+      } catch (err) {
+        return { error: { kind: 'exception', message: String((err && err.message) || err) } };
       }
-      return { error: { kind: 'exception', message: '所有 host 均失败' } };
     }
 
     // v1.7 通用凭据读取：缺失/读取失败一律 null（错误信息不含密钥）
@@ -1361,13 +1541,14 @@ export default {
     };
 
     // 触发一次刷新（并发去重 + seq 防旧覆盖）；返回本次刷新 Promise
-    function kickSubscriptionRefresh(sourceKey) {
+    // providerId：需要按 provider 路由 host/凭据的源（如 zai 系）使用；其余源忽略
+    function kickSubscriptionRefresh(sourceKey, providerId) {
       const src = SUBSCRIPTION_SOURCES[sourceKey];
       if (!src) return Promise.resolve();
       if (subscriptionInFlight[sourceKey]) return subscriptionInFlight[sourceKey];
       const seq = (subscriptionSeq[sourceKey] || 0) + 1;
       subscriptionSeq[sourceKey] = seq;
-      subscriptionInFlight[sourceKey] = src.fetch().then(function (result) {
+      subscriptionInFlight[sourceKey] = src.fetch(providerId).then(function (result) {
         if (subscriptionSeq[sourceKey] === seq) {
           subscriptions[sourceKey] = mergeSubscriptionResult(subscriptions[sourceKey], result);
           // 失败退避记录：失败记时刻（期内不重试），成功清零
@@ -1394,7 +1575,7 @@ export default {
         if (!subscriptionRequested[sourceKey]) continue;
         const lastFailAt = subscriptionLastFailAt[sourceKey] || 0;
         if (nowMs - lastFailAt < SUBSCRIPTION_RETRY_BACKOFF_MS) continue;
-        kickSubscriptionRefresh(sourceKey);
+        kickSubscriptionRefresh(sourceKey, subscriptionSourceProvider[sourceKey]);
       }
     }
 
@@ -1455,15 +1636,16 @@ export default {
     }
 
     // RPC：当前订阅额度快照 + 模式判定（非订阅模式直接返回，不发任何订阅请求）
-    async function getSubscriptionSnapshotRpc(selection) {
+    async function getSubscriptionSnapshotRpc(selection, force) {
       const sel = selection || modelSelection();
       const bm = detectBillingMode(sel.provider, config.billingMode);
-      const out = { mode: bm.mode, provider: sel.provider, reason: bm.reason, source: null, plan: null, planType: null, expiryAt: null, windows: [], fetchedAt: null, error: null };
+      const out = { mode: bm.mode, provider: sel.provider, reason: bm.reason, source: null, plan: null, planType: null, expiryAt: null, windows: [], balance: null, fetchedAt: null, error: null };
       if (bm.mode !== 'subscription') return out;
       const sourceKey = subscriptionSourceFor(sel.provider);
       if (!sourceKey) return out;
       out.source = sourceKey;
       subscriptionRequested[sourceKey] = true; // 该源进入 60s 周期刷新
+      subscriptionSourceProvider[sourceKey] = sel.provider; // 记住 provider（zai 系路由需要）
       const snap = subscriptions[sourceKey] || { data: null, fetchedAt: null, error: null };
       const nowMs = Date.now();
       const lastFailAt = subscriptionLastFailAt[sourceKey] || 0;
@@ -1471,11 +1653,13 @@ export default {
       // 减少对未公开 wham 接口的请求，也避免"刷新失败"提示随每次轮询反复闪烁（失败期内直接读缓存快照）
       const stale = (!snap.fetchedAt || (nowMs - snap.fetchedAt) > SUBSCRIPTION_REFRESH_MS)
         && (nowMs - lastFailAt) >= SUBSCRIPTION_RETRY_BACKOFF_MS;
-      if (stale) {
-        const inflight = kickSubscriptionRefresh(sourceKey);
-        // 从未成功过（无旧数据）→ 等本次刷新返回最新结果（含错误），避免退避重试后仍返回旧失败快照；
-        // 已有旧数据 → 后台刷新，本次直接返回快照（不阻塞轮询）
-        if (!snap.data) await inflight;
+      // force（客户端打开/刷新网页后的首启窗口）绕过新鲜度与失败退避，当场重查，
+      // 让用户手动刷新页面时立刻拿到最新额度/余额，而不是干等下一轮自动刷新
+      if (force || stale) {
+        const inflight = kickSubscriptionRefresh(sourceKey, subscriptionSourceProvider[sourceKey]);
+        // 从未成功过（无旧数据）或强制刷新 → 等本次结果返回最新数据（含错误）；
+        // 已有旧数据的普通刷新 → 后台刷新，本次直接返回快照（不阻塞轮询）
+        if (!snap.data || force) await inflight;
       }
       const cur = subscriptions[sourceKey] || { data: null, fetchedAt: null, error: null };
       if (cur.data) {
@@ -1483,6 +1667,7 @@ export default {
         out.windows = cur.data.windows;
         out.planType = cur.data.planType;
         out.expiryAt = cur.data.expiryAt;
+        out.balance = typeof cur.data.balance === 'number' ? cur.data.balance : null;
       }
       out.fetchedAt = cur.fetchedAt;
       out.error = cur.error;
@@ -1497,7 +1682,7 @@ export default {
       cloudflare: { fetch: fetchCloudflareBilling }, // cloudflare-ai-gateway / cloudflare-workers-ai 共用
     };
 
-    async function getBillingSnapshotRpc(selection) {
+    async function getBillingSnapshotRpc(selection, force) {
       const sel = selection || modelSelection();
       const bm = detectBillingMode(sel.provider, config.billingMode);
       const out = { mode: bm.mode, provider: sel.provider, reason: bm.reason, type: null, data: null, fetchedAt: null, error: null, now: Date.now() };
@@ -1511,9 +1696,10 @@ export default {
       const lastFailAt = billingLastFailAt[key] || 0;
       const stale = (!snap.fetchedAt || (nowMs - snap.fetchedAt) > BILLING_REFRESH_MS)
         && (nowMs - lastFailAt) >= BILLING_RETRY_BACKOFF_MS;
-      if (stale) {
+      // force（客户端打开/刷新网页后的首启窗口）绕过新鲜度与失败退避，当场重查最新账单
+      if (force || stale) {
         const inflight = kickBillingRefresh(key);
-        if (!snap.data) await inflight;
+        if (!snap.data || force) await inflight;
       }
       const cur = billingSnapshots[key] || { data: null, fetchedAt: null, error: null };
       out.data = cur.data;
@@ -1705,9 +1891,18 @@ export default {
     }
 
     // ---------- 定价计算 ----------
+    // 价目键解析：优先"服务商:模型"作用域键（解决同名模型跨计费域价格/币种不同的问题，
+    // 如 Kimi 同一型号在 api.moonshot.cn=¥ 与 api.moonshot.ai=$ 两套价）；
+    // 无作用域键时回退裸模型键。远程目录可下发任意一种形态。
+    function pricingEntryFor(provider, model) {
+      const scoped = PRICING[provider + ':' + model];
+      if (scoped && typeof scoped === 'object') return scoped;
+      return PRICING[model] || null;
+    }
+
     function computePricing(nowMs, selection) {
       const sel = selection || modelSelection();
-      const entry = PRICING[sel.model];
+      const entry = pricingEntryFor(sel.provider, sel.model);
       const period = entry && entry.mode === 'peak-valley' ? currentPeriod(nowMs) : 'flat';
       let prices = null;
       if (entry) {
@@ -1782,6 +1977,35 @@ export default {
     let dirty = loadedUsageRecords.migratedLegacyRecord;
     let ledgerError = null;
 
+    // ---------- 一次性回填：unpriced 历史记录按当前价目表补算 ----------
+    // 背景：价目表随适配逐步收录；收录之前落账的记录 pricingStatus='unpriced'（cost=null），
+    // 导致本会话/今日/累计花费长期漏算（例如接入智谱后其历史对话金额恒为 0）。
+    // 规则：① 只补"从未有过价格"的记录，绝不改写已 priced 的历史金额；
+    //      ② 仅限带稳定 id 的记录（无 id 的远古记录在快照+流水双源下无法安全幂等）；
+    //      ③ 补算结果一次性写入快照，此后与正常记录同权参与全部汇总。
+    function backfillUnpricedRecords() {
+      let count = 0;
+      for (let i = 0; i < usageRecords.length; i++) {
+        const rec = usageRecords[i];
+        if (!rec || rec.pricingStatus === 'priced') continue;
+        if (!(typeof rec.id === 'string' && rec.id.length > 0)) continue;
+        if (Number.isFinite(rec.cost) && rec.cost >= 0) continue;
+        const billed = costOf(rec, false);
+        if (billed == null) continue; // 价目表仍无该模型 → 维持 unpriced
+        rec.cost = billed;
+        rec.currency = modelCurrency(rec.provider, rec.model);
+        rec.pricingStatus = 'priced';
+        rec.pricingVersion = 'builtin-backfill-' + packageVersion();
+        count++;
+      }
+      if (count > 0) {
+        dirty = true;
+        scheduleSave();
+        console.warn('[dsh-bottom-info-bar] 价目表回填：' + count + ' 条 unpriced 记录已按官方单价补算');
+      }
+      return count;
+    }
+
     function writeAndSync(filePath, content, flags) {
       let fd = null;
       try {
@@ -1855,6 +2079,8 @@ export default {
       });
     }
 
+    const unpricedWarnedModels = new Set(); // 每个模型只提醒一次，避免高频 warn 刷日志
+
     function recordUsage(options, usage, status) {
       const u = usage || {};
       // 数值清洗：uncachedInputTokens 的 != null 对 NaN 恒真、|| 0 挡不住 Infinity/负值——
@@ -1875,14 +2101,28 @@ export default {
       // Freeze the actual price at usage time.  Historical totals must not
       // change merely because the plugin's reference price table is updated.
       const billed = costOf(rec, false);
-      if (billed != null) {
-        rec.currency = modelCurrency(rec.model);
+      // ① 聚合商在 usage 中直接给出的真实金额（如 OpenRouter 的 usage.cost）——
+      //    官方报出的钱优先级最高，聚合商场景从此免维护静态价目表；
+      // ② 价目表换算（当前各家官方单价）；③ 都没有 → unpriced 待启动回填。
+      if (billed == null && typeof u.cost === 'number' && Number.isFinite(u.cost) && u.cost >= 0) {
+        rec.cost = u.cost;
+        rec.currency = PROVIDER_REPORTED_CURRENCY[rec.provider] || modelCurrency(rec.provider, rec.model);
+        rec.pricingStatus = 'priced';
+        rec.pricingVersion = 'provider-reported-' + packageVersion();
+      } else if (billed != null) {
+        rec.currency = modelCurrency(rec.provider, rec.model);
         rec.cost = billed;
         rec.pricingStatus = 'priced';
         rec.pricingVersion = 'builtin-' + packageVersion();
       } else {
         rec.pricingStatus = 'unpriced';
         rec.pricingVersion = null;
+        // 诊断：理论上本插件任一实例的 PRICING 均应同步；若此处为 false 说明存在多副本或键名不匹配。
+        // 每个模型仅首次出现时提醒一次，防止未收录模型（如订阅目录下的混合路由）高频刷日志
+        if (!unpricedWarnedModels.has(rec.model)) {
+          unpricedWarnedModels.add(rec.model);
+          console.warn('[dsh-bottom-info-bar] 记账未计价（每模型仅提示一次）：model="' + rec.model + '" 价目表含该模型=' + Boolean(PRICING[rec.model] || PRICING[rec.provider + ':' + rec.model]));
+        }
       }
       const writeError = appendUsageJournal(rec);
       if (writeError) {
@@ -1945,7 +2185,7 @@ export default {
       // v2 ledger records carry the charge as observed.  Use it for normal
       // reporting; only the "all-offpeak" forecast intentionally recalculates.
       if (!forceOffpeak && Number.isFinite(record.cost) && record.cost >= 0) return record.cost;
-      const entry = PRICING[record.model];
+      const entry = pricingEntryFor(record.provider, record.model);
       if (!entry) return null;
       let p;
       if (entry.mode === 'peak-valley') {
@@ -2063,13 +2303,13 @@ export default {
       const key = balanceProviderKey(sel.provider || config.activeProvider);
       const snap = balances[key];
       if (snap && snap.data && snap.data.currency) return snap.data.currency;
-      return modelCurrency(sel.model);
+      return modelCurrency(sel.provider, sel.model);
     }
 
     function recordCurrency(record) {
       return record && typeof record.currency === 'string' && record.currency.length > 0
         ? record.currency
-        : modelCurrency(record && record.model);
+        : modelCurrency(record && record.provider, record && record.model);
     }
 
     function spendSummary(nowMs, selection) {
@@ -2203,8 +2443,9 @@ export default {
       let scenarios = [];
       if (balance != null && pricing.prices) {
         const p = pricing.prices;
-        const peakPrices = pricing.mode === 'peak-valley' ? PRICING[pricing.model].peak : p;
-        const offpeakPrices = pricing.mode === 'peak-valley' ? PRICING[pricing.model].offpeak : p;
+        const pvEntry = pricing.mode === 'peak-valley' ? pricingEntryFor(pricing.provider, pricing.model) : null;
+        const peakPrices = pvEntry ? pvEntry.peak : p;
+        const offpeakPrices = pvEntry ? pvEntry.offpeak : p;
         scenarios = SCENARIOS.map(function (sc) {
           return {
             id: sc.id, label: sc.label, outputK: sc.outputK, inputK: sc.inputK,
@@ -2349,8 +2590,14 @@ export default {
       getUpdateInfo: function () {
         return updateInfoPromise
       },
-      getBalanceSnapshot: function (args) {
+      getBalanceSnapshot: async function (args) {
         const pid = args && typeof args === 'object' && args.provider ? String(args.provider) : '';
+        // force：客户端刚打开/刷新网页时的强制刷新——当场重查服务商，不等 60s 周期缓存
+        const force = !!(args && typeof args === 'object' && args.force === true);
+        if (force) {
+          const key = balanceProviderKey(pid || undefined);
+          if (key) await refreshProviderBalance(key);
+        }
         return activeBalanceSummary(pid || undefined, Date.now());
       },
       getPricing: async function (args) {
@@ -2394,11 +2641,13 @@ export default {
         return Object.assign(detectBillingMode(sel.provider, config.billingMode), { model: sel.model });
       },
       getSubscriptionSnapshot: function (args) {
-        return getSubscriptionSnapshotRpc(selectionFromArgs(args));
+        const force = !!(args && typeof args === 'object' && args.force === true);
+        return getSubscriptionSnapshotRpc(selectionFromArgs(args), force);
       },
       // v1.7 FR-14：账单型快照（云账单 provider）
       getBillingStatus: function (args) {
-        return getBillingSnapshotRpc(selectionFromArgs(args));
+        const force = !!(args && typeof args === 'object' && args.force === true);
+        return getBillingSnapshotRpc(selectionFromArgs(args), force);
       },
       setDisplayMode: function (args) {
         const mode = args && typeof args === 'object' ? args.mode : null;
@@ -2500,7 +2749,13 @@ export default {
       }, 'dsh-bottom-info-bar: Web routes');
     });
 
-    // ---------- 启动即刷 + 60s 定时刷新 ----------
+    // ---------- 启动即刷 + 定时刷新 ----------
+    // 价目目录：① 离线兜底（磁盘缓存先同步合并）→ ② 回填 → ③ 异步拉远程增量（成功后再回填一次）
+    const cachedPricing = loadPricingCacheFromDisk();
+    if (cachedPricing) applyRemotePricingEntries(cachedPricing);
+    backfillUnpricedRecords(); // 内置表已覆盖的部分先补算
+    refreshRemotePricing('启动'); // 网络刷新异步进行；成功后内部会再次触发回填
+    ctx.interval(function () { refreshRemotePricing('定时'); }, REMOTE_PRICING_REFRESH_MS);
     refreshAllBalances();
     refreshActiveSubscriptions(); // 惰性：无客户端请求过订阅源则不发起网络请求
     refreshActiveBilling(); // v1.7：账单型同样惰性

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-bottom-info-bar",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "DeepSeek Harness 底部信息栏插件：替换对话输入框下方的原生统计栏，显示服务商/具体模型、真实余额、高峰/空闲价格与倒计时、本会话（含子代理）·今日·近一月·全部花费。安装一次，每次打开 DSH 自动生效。",
   "keywords": [
     "deepseek",