dsh-tokenlens 1.6.0 → 1.6.2

package/CHANGELOG.md

@@ -4,15 +4,26 @@
 
 **版本记录约定**：同一发布日只保留一个章节，标题取当日**最后一个**已发布版本号；当日多次发布的改动合并到该章节，并在标题下注明当日实际发布过的版本号（npm 上仍可安装这些独立版本）。若当日已有发布，后续小改动不再单独增加版本号，而是并入下一篇日志。这样日志按天规整、不出现同日多个小版本。
 
+## 1.6.2 — 2026-11-04
+
+（当日已发布版本：v1.6.2。v1.6.1 的混合模型修复未单独发版，已并入本节）
+
+- **fix(open-design): 混合模型按 credits 加权取额度，不再取最高倍率**——原实现取「用过的最高倍率」当口径，实测 0.5× 与 4× 各占一半 credits 时会把月额度报成 $15（正确应为 **$67.50**），严重低估。现改为按实际消耗加权的调和平均：`m_eff = Σcredits / Σ(credits/m)`，`月额度 = $60 / m_eff`。90% credits 走 0.5× 时是 **$97.89**，99% 时 **$117.92**，偶尔用一次 4× 模型不再摧毁额度
+- fix(open-design): 单一模型时加权公式**精确退化**为官方表格值（0.5×→$120、1×→$60、2×→$30、4×→$15），纯模型场景不受影响
+- fix(open-design): 无消费权重（仅知道模型列表）时回退到最高倍率，即保守口径（承诺最少剩余额度）
+- **fix(open-design): 未收录价格的模型不再静默少算金额**——`unpricedModels` 此前算出来却没有用上，含未知模型时金额会**偏低却不提示**。现在置 `partial: true`，弹窗显示「含未收录价格的模型，金额为下限」，绝不把下限当完整值
+- 测试：328 → 332（切换模型时金额与额度反向变化、未收录模型使金额成为下限、加权混合三种比例、单一模型退化、无权重回退最高倍率）
+- 备注：`600,000 credits/月` 是插件由「7 天窗口上限 × 4」推算的值（官方定价表月/周 = $120/$30 = 4），**不是服务端字段**；服务端只返回 5 小时 50,000 与 7 天 150,000 两个窗口
+
 ## 1.6.0 — 2026-11-03
 
 - **feat(open-design): 「本期 Design Plan 累计」改按官方定价表的模型单价计算**——原来是 `usedCredits ÷ creditsPerUsd`，这个算法隐含「按 1× 倍率消耗」的假设，而官方倍率表跨度 0.25×–4×：对 DeepSeek V4.1 Flash（0.5×）会**少算一半**，对 GPT-6 Luna（4×）会**多算 4 倍**。现在按每个模型的实际 Token × 官方单价（输入/输出/缓存读分别计价）累加，结果可直接与定价表比对
 - **feat(open-design): 给出与倍率匹配的月额度**——定价表里 $120 是**列表价**口径且按倍率消耗：只用 0.5× 模型（DeepSeek V4.1 Flash）可动用**完整 $120**，1× 用 $60，2× 用 $30，4× 用 $15。弹窗改为显示「**已用 / 月额度 + 百分比**」（如 `$27.31 / $120.00  22.8%`），并注明「按 0.5× 倍率模型计价」
-- feat(open-design): 混合模型时按**最高**倍率取额度（不是平均）——4× 模型的每一单位消耗其份额的速度是 4 倍，约束由它决定
+- feat(open-design): 混合模型取额度口径（v1.6.2 修正为按 credits 加权，不再是最高倍率）
 - feat(wire): `designPlan` 新增 `monthlyCapUsd` / `capPercent` / `multiplier` / `creditsUsd`；`estimatedUsd` 语义改为「官方单价口径的消费额」，旧算法结果保留在 `creditsUsd` 便于对照
 - feat(stats): `models[].last30Days` 增加 `input` / `output` / `cacheRead` / `cacheWrite` 拆分，供按单价计价使用（此前只有 total）
 - fix(open-design): 单价表按官方文档转录 13 个 Design Plan 模型；`hunyuan-h4-preview` / `glm-5.3-flash-x` 不在公开价目接口里，价格缺失时按「未定价」处理并如实上报，绝不臆造
-- 测试：318 → 328（倍率阶梯 0.5×→$120 / 1×→$60 / 2×→$30 / 4×→$15、混合取最高倍率、未知模型不臆造倍率与额度、按 token 种类计价、**用控制台真实账单核对：$0.0048 列表价 × 0.5 = $0.0024 实扣**、未定价模型上报）
+- 测试：318 → 328（倍率阶梯 0.5×→$120 / 1×→$60 / 2×→$30 / 4×→$15、未知模型不臆造倍率与额度、按 token 种类计价、**用控制台真实账单核对：$0.0048 列表价 × 0.5 = $0.0024 实扣**、未定价模型上报）
 
 ## 1.5.3 — 2026-11-03
 

package/README.md

@@ -440,7 +440,7 @@ Host 半注册 `tokenlens_usage`，参数 `action`（默认 `snapshot`）与可
 
 ## 验证
 
-- `node --test`：**328 个自动化用例**，覆盖 Host 数据层、供应商适配器、统计折叠、各 harness 读取、Design Plan 周期账本与官方单价计价、窗口锚点切片、工作区自动识别、插件集成与浏览器端渲染 / 交互。
+- `node --test`：**332 个自动化用例**，覆盖 Host 数据层、供应商适配器、统计折叠、各 harness 读取、Design Plan 周期账本与官方单价计价、窗口锚点切片、工作区自动识别、插件集成与浏览器端渲染 / 交互。
 - 在真实环境中验证过 **5 个 harness** 的数据源；本机统计与独立的 SQLite 查询、独立的日志解析逐项对账（差额为 0），跨 harness 合并与供应商映射算术自洽。
 - 供应商接口按各官方文档与参考客户端行为验证；未配置凭据时 chip 静默隐藏，接口异常时按可重试错误降级。
 

package/client.js

@@ -343,6 +343,7 @@ window.__ModuleLoader__.load({
       designPlanHint:
         '按官方定价表的模型单价换算本机实际消耗的 Token（不是 usedCredits ÷ 汇率）。Open Design 没有月度用量接口，此值由插件在本机累计观测到的 7 天窗口得出，仅供参考',
       designPlanMultiplier: '按 {multiplier}× 倍率模型计价',
+      designPlanPartialPricing: '含未收录价格的模型，金额为下限',
       designPlanComplete: '已覆盖本账期全部窗口',
       designPlanPartial: '仅统计已观测的 {count} 个窗口',
       providerSave: '保存',
@@ -605,6 +606,7 @@ window.__ModuleLoader__.load({
       designPlanHint:
         'Priced from the official per-model rates over the tokens this machine actually consumed (not usedCredits ÷ rate). Open Design serves no period-usage endpoint, so the window total is accumulated locally; treat it as an estimate.',
       designPlanMultiplier: 'priced at the {multiplier}× model rate',
+      designPlanPartialPricing: 'includes models with no documented price; the amount is a lower bound',
       designPlanComplete: 'covers every window of this period',
       designPlanPartial: 'only {count} observed window(s)',
       providerConsoleURLPlaceholder: 'Leave empty for the built-in default',
@@ -1107,6 +1109,9 @@ window.__ModuleLoader__.load({
         monthlyCapUsd: monthlyCapUsd !== null && monthlyCapUsd > 0 ? monthlyCapUsd : null,
         capPercent,
         multiplier: multiplier !== null && multiplier > 0 ? multiplier : null,
+        // v1.6.2: some consumed model had no documented price, so the dollar
+        // figure is a lower bound and must not read as complete.
+        partial: raw.partial === true,
       }
     }
 
@@ -4073,6 +4078,9 @@ window.__ModuleLoader__.load({
       if (designPlan.multiplier !== null) {
         notes.push(t('designPlanMultiplier', { multiplier: designPlan.multiplier }))
       }
+      // v1.6.2: a model without a documented price makes the figure a lower bound.
+      // Say it rather than letting the number read as complete.
+      if (designPlan.partial === true) notes.push(t('designPlanPartialPricing'))
       if (designPlan.complete === true) notes.push(t('designPlanComplete'))
       else if (designPlan.windows > 0) notes.push(t('designPlanPartial', { count: designPlan.windows }))
       return h(

package/index.js

@@ -84,7 +84,7 @@ export const inject = []
 export const PLUGIN_NAME = 'dsh-tokenlens'
 
 /** Plugin version; mirrors package.json (kept here so diagnostics need no fs read). */
-export const PLUGIN_VERSION = '1.6.0'
+export const PLUGIN_VERSION = '1.6.2'
 
 /** Documented defaults; every field of the raw row config is optional. */
 const DEFAULTS = {
@@ -483,12 +483,16 @@ export function apply(ctx, rawConfig) {
       models[modelId] = bucket
     }
     const cost = designPlanCostUsd(models)
-    const caps = capsForModels(Object.keys(models))
+    // v1.6.1: weight the cap by actual per-model consumption, not the worst
+    // multiplier. The caps are credit-denominated, so a mostly-0.5x account that
+    // touched a 4x model once keeps nearly the full $120.
+    const caps = capsForModels(Object.keys(models), cost.mixes)
     return {
       listPriceUsd: cost.priced === true ? cost.usd : null,
       monthlyCapUsd: caps.monthlyCapUsd,
       multiplier: caps.multiplier,
       unpricedModels: cost.unpricedModels,
+      partial: cost.unpricedModels.length > 0,
     }
   }
 

package/lib/design-plan-cost.mjs

@@ -73,30 +73,73 @@ export const DESIGN_PLAN_CAPS_USD = { rolling: 10, weekly: 30, monthly: 120 }
  * The $120 monthly cap is entirely Design Plan value and is consumed at the
  * model's multiplier, so using ONLY a 0.5x model (DeepSeek V4.1 Flash) unlocks
  * the full $120 of list-price usage; a 1x model reaches $60; 2x reaches $30.
- * With a mixed history the binding constraint is the WORST (highest) multiplier
- * the account actually used, because every unit of that model spends its share
- * faster. That is why this returns the max multiplier seen, not an average.
+ * With a mixed history the binding constraint is NOT simply the highest
+ * multiplier: the caps are denominated in credits (600,000/month at 10,000
+ * credits per list-price dollar), and each model burns those credits at its own
+ * rate. The account's spendable list-price value is therefore
  *
+ *   600,000 credits / m_effective
+ *
+ * where `m_effective` is the credit-weighted harmonic mean of the multipliers
+ * actually used:
+ *
+ *   m_eff = Σ credits_i / Σ (credits_i / m_i),  credits_i = listUsd_i × 10000 × m_i
+ *
+ * Using the plain maximum would understate a mostly-0.5x account that touched a
+ * 4x model once: 90% of the credits at 0.5x plus 10% at 4x gives $97.89, not
+ * $15. With a single model the formula reduces exactly to that model's
+ * documented cap, so the pure cases still match the pricing page.
+ *
+ * @param modelIds - the model ids in the mix, or
+ * @param mixes - a per-model `{ listUsd, multiplier }` split (preferred: it
+ *   weights by real consumption). `modelIds` is used only when no split is given.
  * @returns `{ monthlyCapUsd, weeklyCapUsd, fiveHourCapUsd, multiplier }` where
- *   `multiplier` is the max documented multiplier among `modelIds` (0 when none),
- *   or all-null caps when no model is known.
+ *   `multiplier` is the effective multiplier, or all-null caps when no model is
+ *   known.
  */
-export function capsForModels(modelIds) {
-  let worst = 0
-  for (const id of Array.isArray(modelIds) ? modelIds : []) {
-    const model = DESIGN_PLAN_MODELS[normalizeModelId(id)]
-    if (model === undefined || !Number.isFinite(model.multiplier) || model.multiplier <= 0) continue
-    if (model.multiplier > worst) worst = model.multiplier
+export function capsForModels(modelIds, mixes = null) {
+  const rows = Array.isArray(mixes)
+    ? mixes
+        .map((mix) => ({
+          listUsd: typeof mix?.listUsd === 'number' && Number.isFinite(mix.listUsd) && mix.listUsd > 0 ? mix.listUsd : 0,
+          multiplier:
+            typeof mix?.multiplier === 'number' && Number.isFinite(mix.multiplier) && mix.multiplier > 0
+              ? mix.multiplier
+              : null,
+        }))
+        .filter((row) => row.multiplier !== null && row.listUsd > 0)
+    : null
+  let effective = 0
+  if (rows !== null && rows.length > 0) {
+    // Credit-weighted harmonic mean (see the doc comment).
+    let credits = 0
+    let inverse = 0
+    for (const row of rows) {
+      const rowCredits = row.listUsd * row.multiplier
+      credits += rowCredits
+      inverse += rowCredits / row.multiplier
+    }
+    effective = credits > 0 && inverse > 0 ? credits / inverse : 0
+  } else {
+    // No consumption weighting available: fall back to the highest multiplier,
+    // the conservative reading (it promises the LEAST remaining capacity).
+    let worst = 0
+    for (const id of Array.isArray(modelIds) ? modelIds : []) {
+      const model = DESIGN_PLAN_MODELS[normalizeModelId(id)]
+      if (model === undefined || !Number.isFinite(model.multiplier) || model.multiplier <= 0) continue
+      if (model.multiplier > worst) worst = model.multiplier
+    }
+    effective = worst
   }
-  if (worst === 0) {
+  if (!(effective > 0)) {
     return { monthlyCapUsd: null, weeklyCapUsd: null, fiveHourCapUsd: null, multiplier: null }
   }
   return {
-    // 600,000 credits / mult at 10,000 credits per dollar == $60 / mult.
-    monthlyCapUsd: 60 / worst,
-    weeklyCapUsd: 15 / worst,
-    fiveHourCapUsd: 5 / worst,
-    multiplier: worst,
+    // 600,000 credits / m at 10,000 credits per list-price dollar == $60 / m.
+    monthlyCapUsd: 60 / effective,
+    weeklyCapUsd: 15 / effective,
+    fiveHourCapUsd: 5 / effective,
+    multiplier: effective,
   }
 }
 
@@ -153,6 +196,7 @@ export function designPlanCostUsd(models) {
   let usd = 0
   let priced = false
   const unpricedModels = []
+  const mixes = []
   for (const [modelId, bucket] of Object.entries(models ?? {})) {
     const total = tokens(bucket?.input) + tokens(bucket?.output) + tokens(bucket?.cacheRead) + tokens(bucket?.cacheWrite)
     if (total === 0) continue
@@ -163,6 +207,11 @@ export function designPlanCostUsd(models) {
     }
     usd += cost.usd
     priced = true
+    // Per-model list-price spend, so the cap can be weighted by real consumption.
+    const model = designPlanModel(modelId)
+    if (model !== null && Number.isFinite(model.multiplier) && model.multiplier > 0 && cost.usd > 0) {
+      mixes.push({ modelId: normalizeModelId(modelId), listUsd: cost.usd, multiplier: model.multiplier })
+    }
   }
-  return { usd, priced, unpricedModels }
+  return { usd, priced, unpricedModels, mixes }
 }

package/lib/design-plan-ledger.mjs

@@ -292,6 +292,9 @@ export function summarizeDesignPlan(ledger, periodStart, input = null) {
     monthlyCapUsd,
     multiplier: Number.isFinite(input?.multiplier) ? input.multiplier : null,
     capPercent,
+    // v1.6.2: true when some consumed model has no documented price, so
+    // `estimatedUsd` is a lower bound and the UI must say so.
+    partial: input?.partial === true,
     windows,
     complete: since === key,
     since,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tokenlens",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "type": "module",
   "description": "dsh-TokenLens (词元透镜) — provider-aware plan capacity plus local token statistics (today/7d/30d/all-time, by harness/provider/model/workspace) for DSH.",
   "license": "MIT",