@chenlongapps/opencode-token-usage 0.4.2 → 0.4.4

package/dist/usage.js

@@ -10,10 +10,13 @@ export function normalize(tokens) {
 export const incoming = (t) => t.input + t.cache.read + t.cache.write;
 export const total = (t) => incoming(t) + t.output + t.reasoning;
 // Matches OpenCode 2.0.11 SessionUsage.calculateCost: thresholds are exclusive.
-export function estimate(tokens, prices = []) {
+function selectedPrice(tokens, prices) {
     const tier = prices.filter(p => p.tier && incoming(tokens) > p.tier.size)
         .sort((a, b) => b.tier.size - a.tier.size)[0];
-    const price = tier ?? prices.find(p => !p.tier);
+    return tier ?? prices.find(p => !p.tier);
+}
+export function estimate(tokens, prices = []) {
+    const price = selectedPrice(tokens, prices);
     const rates = [price?.input, price?.output, price?.reasoning ?? price?.output, price?.cache?.read, price?.cache?.write];
     const quantities = [tokens.input, tokens.output, tokens.reasoning, tokens.cache.read, tokens.cache.write];
     return {
@@ -25,13 +28,41 @@ export function estimate(tokens, prices = []) {
 function priceMessage(tokens, model, catalog) {
     if (!model)
         return undefined;
-    let value = estimate(tokens, catalog.get(modelKey(model)));
+    let prices = catalog.get(modelKey(model)) ?? [];
+    let source = "OpenCode";
+    let value = estimate(tokens, prices);
     if (value.defaultPrice || value.cost === 0) {
-        const snapshot = estimate(tokens, officialPrice(model)?.prices);
-        if (!snapshot.defaultPrice)
+        const fallback = officialPrice(model)?.prices ?? [];
+        const snapshot = estimate(tokens, fallback);
+        if (!snapshot.defaultPrice) {
             value = snapshot;
+            prices = fallback;
+            source = "Built-in snapshot";
+        }
     }
-    return value.defaultPrice ? undefined : value.cost;
+    const price = selectedPrice(tokens, prices);
+    return value.defaultPrice || !price ? undefined : { cost: value.cost, source, price, prices };
+}
+const validRate = (value) => value !== undefined && Number.isFinite(value) && value >= 0 ? value : undefined;
+function appliedRates(value) {
+    const lowerExclusive = value.price.tier?.size;
+    const next = value.prices.reduce((size, price) => {
+        const threshold = price.tier?.size;
+        return threshold !== undefined && threshold > (lowerExclusive ?? -Infinity) && threshold < size ? threshold : size;
+    }, Infinity);
+    return {
+        source: value.source,
+        lowerExclusive,
+        upperInclusive: Number.isFinite(next) ? next : undefined,
+        calls: 1,
+        rates: {
+            input: validRate(value.price.input),
+            output: validRate(value.price.output),
+            reasoning: validRate(value.price.reasoning ?? value.price.output),
+            cacheRead: validRate(value.price.cache?.read),
+            cacheWrite: validRate(value.price.cache?.write),
+        },
+    };
 }
 function costStatus(known, missing) {
     if (missing > 0)
@@ -69,7 +100,7 @@ export function summarize(messages, catalog = new Map()) {
         if (value === undefined)
             missingCosts++;
         else {
-            cost += value;
+            cost += value.cost;
             knownCosts++;
         }
     }
@@ -89,21 +120,33 @@ export function summarizeModels(messages, catalog = new Map()) {
         if (count === 0)
             continue;
         const key = message.model && modelKey(message.model);
-        const group = groups.get(key) ?? { calls: 0, tokens: 0, cost: 0, known: 0, missing: 0 };
+        const group = groups.get(key) ?? { calls: 0, tokens: 0, cost: 0, known: 0, missing: 0, rates: new Map() };
         group.calls++;
         group.tokens += count;
         const value = priceMessage(tokens, message.model, catalog);
         if (value === undefined)
             group.missing++;
         else {
-            group.cost += value;
+            group.cost += value.cost;
             group.known++;
+            const applied = appliedRates(value);
+            const rateKey = JSON.stringify([applied.source, applied.lowerExclusive, applied.upperInclusive, ...Object.values(applied.rates)]);
+            const existing = group.rates.get(rateKey);
+            if (existing)
+                existing.calls++;
+            else
+                group.rates.set(rateKey, applied);
         }
         groups.set(key, group);
     }
     return [...groups].map(([model, group]) => ({
         model: model ?? "Unknown model", calls: group.calls, tokens: group.tokens,
         cost: group.cost, costStatus: costStatus(group.known, group.missing),
+        appliedRates: [...group.rates.values()].sort((a, b) => {
+            const lowerA = a.lowerExclusive ?? -Infinity, lowerB = b.lowerExclusive ?? -Infinity;
+            return lowerA === lowerB ? a.source.localeCompare(b.source) : lowerA - lowerB;
+        }),
+        unpricedCalls: group.missing,
     })).sort((a, b) => b.cost - a.cost || a.model.localeCompare(b.model));
 }
 const usableLimit = (value) => value !== undefined && Number.isFinite(value) && value > 0;
@@ -111,18 +154,25 @@ const usableLimit = (value) => value !== undefined && Number.isFinite(value) &&
 // the last completed compaction carries the current context size. Running or failed
 // compactions do not reset it, and a last message without usage hides the row entirely
 // instead of falling back to pre-compaction history.
-export function contextDetails(messages, limit) {
+export function contextDetails(messages, limit, revertMessageID) {
     if (!usableLimit(limit))
         return undefined;
+    // The staged revert excludes its boundary message and every later message.
+    // Session.message.list is ascending; an absent marker can occur during a
+    // concurrent commit, in which case the ordered ID still gives the cutoff.
+    const found = revertMessageID ? messages.findIndex(message => message.id === revertMessageID) : -1;
+    const next = revertMessageID && found < 0 ? messages.findIndex(message => message.id > revertMessageID) : -1;
+    const end = !revertMessageID ? messages.length : found >= 0 ? found
+        : next >= 0 ? next : messages.length;
     let boundary = -1;
-    for (let index = messages.length - 1; index >= 0; index--) {
+    for (let index = end - 1; index >= 0; index--) {
         const message = messages[index];
         if (message.type === "compaction" && message.status === "completed") {
             boundary = index;
             break;
         }
     }
-    for (let index = messages.length - 1; index > boundary; index--) {
+    for (let index = end - 1; index > boundary; index--) {
         const message = messages[index];
         if (message.type !== "assistant" || !message.tokens)
             continue;
@@ -132,8 +182,8 @@ export function contextDetails(messages, limit) {
     }
     return undefined;
 }
-export function contextUsage(messages, limit) {
-    return contextDetails(messages, limit)?.usage;
+export function contextUsage(messages, limit, revertMessageID) {
+    return contextDetails(messages, limit, revertMessageID)?.usage;
 }
 export function formatTokens(value) {
     return Math.round(safe(value)).toLocaleString("en-US");
@@ -146,6 +196,33 @@ export function formatEstimatedCost(cost, status) {
         return "—";
     return `${formatCost(cost)}${status === "partial" ? " · partial" : ""}`;
 }
+/** Per-million rates need more precision than a rounded total cost. */
+export function formatRate(value) {
+    if (value === undefined || !Number.isFinite(value) || value < 0)
+        return "—";
+    if (value === 0)
+        return "$0.00";
+    const decimal = value.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 12 });
+    return `$${decimal === "0.00" ? value.toExponential(2) : decimal}`;
+}
+export function formatRateTier(value) {
+    const lower = value.lowerExclusive, upper = value.upperInclusive;
+    if (lower === undefined && upper === undefined)
+        return "all incoming sizes";
+    if (lower === undefined)
+        return `≤${formatTokens(upper)} incoming`;
+    if (upper === undefined)
+        return `>${formatTokens(lower)} incoming`;
+    return `>${formatTokens(lower)} to ≤${formatTokens(upper)} incoming`;
+}
+export function rateRows(value) {
+    const rates = value.rates;
+    return [
+        ["Input", formatRate(rates.input)], ["Output", formatRate(rates.output)],
+        ["Reasoning", formatRate(rates.reasoning)], ["Cache Read", formatRate(rates.cacheRead)],
+        ["Cache Write", formatRate(rates.cacheWrite)],
+    ];
+}
 /** Compact display for scan-first views: 812, 139.4K, 3.70M. Detailed views keep formatTokens. */
 export function formatCompact(value) {
     const n = safe(value);

package/docs/pricing.md

@@ -24,6 +24,7 @@ npm run build
 - 每条 assistant / compaction 消息使用自身记录的模型和五类 token 用量计价。OpenCode 当前解析出的完整非零价格优先；价格不完整时，整条消息回退到快照；完整零价只有在快照能覆盖该消息实际使用的类别时才被替换。两套价格不混用。
 - 上下文档位按该条消息的 `input + cache read + cache write` 选择，档位阈值为**严格大于**。输出与推理分开统计；原厂明确提供不同 `reasoning` 单价时分别计费，否则沿用输出单价。
 - 缺少实际用到的 token 类别费率就不能按该来源完整计价，不把缺价填作零。无法计价显示 `—`，部分可计价显示 `partial`，明确零价显示 `$0.00`。
+- `/usage` 的 By Model 详细模式仅列出有用量模型在**当前估算**中实际采用的费率，按来源与上下文档位归组，并显示每组调用数；无法定价的调用单独计数。五类费率均为美元／百万文本 token，缺少某类价格显示 `—`，Reasoning 未单列价格时沿用 Output。这里使用当前解析出的模型目录或打包快照重新估算历史消息，不代表消息生成时的实际价格或提供商账单。
 - 网关仅通过精确原厂 ID、唯一的完整裸 ID、明确别名及已知包装格式匹配。终尾 `-free` / `:free` 可在精确匹配失败后再去掉；不剥离 `-fast`、`-pro` 等其他后缀。Fast 模式只匹配支持它的原厂 Provider；不会把普通费率借给网关 Fast 变体。
 - 导入文本输入与文本输出的 token 费率；图片、音频、视频、存储时长、搜索和工具调用等独立计费项无法由五类 token 可靠还原。音频输出另有不同价格的型号不会导入；其余多模态请求仍可能超出此文本估算范围。
 

package/docs/verification.md

@@ -1,5 +1,59 @@
 # 验证记录
 
+## 2026-10-02 · smoke 宿主版本策略与兼容性
+
+环境：macOS、Node.js v22.23.2、插件包 0.4.3。OpenCode SDK 仍精确锁定 2.0.11，未随本机 CLI 升级；本机默认宿主为 Homebrew 安装的 OpenCode 2.0.22。旧版基准使用校验 npm SHA-512 完整性的官方 `@opencode/cli-darwin-arm64@2.0.11` 独立二进制，没有降级或修改日常安装。
+
+| 检查 | 结果 |
+| --- | --- |
+| `npm run typecheck` | 通过 |
+| `npm test` | 85 项通过，含 6 项 smoke 版本与二进制选择回归测试 |
+| `npm run build` | 通过，两版 smoke 的 `npm pack` 均执行真实构建 |
+| `npm run test:smoke`，默认宿主 2.0.22 | 完整通过 |
+| `OPENCODE_BIN=… npm run test:smoke`，独立宿主 2.0.11 | 完整通过 |
+
+版本检查不再把补丁版本列为白名单：允许稳定版 `>=2.0.9 <3.0.0` 运行实际集成检查。尚未与当前 SDK 验证的宿主会输出警告，但不被提前拒绝；当前已验证列表为 2.0.11、2.0.22。低于最低版本、其他主版本以及无法解析的稳定版输出仍会失败。版本检查通过本身不代表兼容性已验证。`OPENCODE_BIN` 统一用于版本探测、隔离服务端与 TUI；相对路径在切换到临时项目之前解析，结果文件记录实际宿主版本与所选二进制。
+
+本轮保留全部原有 token、费用、上下文、布局、子代理、TPS 与 TTFT 断言，并修正测试夹具的时序：实时场景提供多段、300ms 间隔的模拟文本，避免短片段被宿主批处理合并或跨出 2s TPS 窗口；模拟流在 TUI 观察到实时指标后才结束。隔离 CLI 配置关闭持久标签页，避免不同 TUI 进程复用其他会话的焦点；详细模式滚动持续等待真实目标行可见，避免旧宿主在重新排版前处理 End。压缩模拟响应使用宿主要求的结构化摘要格式。现有 OpenCode 配置未修改，也未调用付费模型。
+
+两版真实宿主新增验证：分叉为独立根，继承 assistant ID 保留 `_序号` 后缀；继承消息仍占被查看会话的 Context，但不重复累计用量或 Steps；分叉自己的调用单独计价。真实压缩投影为 `status === "completed"`，`order: "asc"` 的完整历史仍保留压缩前消息，压缩后没有新 assistant 时隐藏旧 Context，新消息恢复 Context，compaction 不计为 assistant step。原有全树 Total 5,080、成本 `$0.00504`、上下文上限 128,000 → 32,000 与原厂回退价 `$0.000149` 均保持通过。
+
+验证产物：
+- OpenCode 2.0.22：`/private/var/folders/rw/bmx6c8hd737brl55m0_ff_b80000gn/T/opencode/token-usage-smoke-93KAN2`。
+- OpenCode 2.0.11：`/private/var/folders/rw/bmx6c8hd737brl55m0_ff_b80000gn/T/opencode/token-usage-smoke-p0SsRF`。
+
+产物包含 `result.json`、终端捕获、已隐藏服务器密码的日志，以及流式事件、生成中的消息和压缩消息诊断文件。2.0.9、2.0.10 的历史记录保留在下方，本轮未重新执行这两个宿主；后续版本仍需实际运行 smoke，不能据版本范围宣称兼容。
+
+## v0.4.3 开发验证（`/usage` 模型费率展示）
+
+验证日期：2026-09-29。Node.js v22.23.2；SDK 2.0.11；真实宿主使用隔离的 `@opencode/cli-darwin-arm64@2.0.11`，包版本仍为 0.4.2。
+
+| 检查 | 结果 |
+| --- | --- |
+| `npm run typecheck` | 通过 |
+| `npm test` | 69 项通过 |
+| `npm run build` | 通过 |
+| `npm run test:smoke` | 通过，打包产物 + 真实 OpenCode 2.0.11 + 本地模拟提供商 |
+
+`/usage` 的 By Model 详细模式按逐消息估算实际采用的 OpenCode／内置快照价格及上下文档位列出五类 token 费率和调用数；紧凑模式不显示费率。自动化测试覆盖同模型跨来源／档位、Reasoning 沿用 Output、零价、缺价和 `partial`，并核对逐模型与全树费用。真实宿主测试验证 160 × 54 与 100 × 28 终端的展开／收起、48 × 28 终端的单列费率，以及内置快照回退来源；未向付费模型发送请求。测试产物保存在 `/var/folders/rw/bmx6c8hd737brl55m0_ff_b80000gn/T/token-usage-smoke-4RnnLf`。
+
+## v0.4.2（正确性与刷新性能）
+
+验证日期：2026-09-26。Node.js v22.23.2；SDK 2.0.11；真实宿主使用校验 npm SHA-512 完整性的 `@opencode/cli-darwin-arm64@2.0.11` 隔离二进制。
+
+| 检查 | 结果 |
+| --- | --- |
+| `npm run typecheck` | 通过 |
+| `npm test` | 67 项通过 |
+| `npm run build` | 通过 |
+| `npm run test:smoke` | 通过，打包产物 + 真实 OpenCode 2.0.11 + 本地模拟提供商；新增删除会话后的 context 清理断言 |
+
+TTFT 的快照先到、step 结束先到，以及缺少结束事件三种情况都有保留期清理测试；快照后继续收到 delta 时恢复实时估算，不提前丢失 TTFT。无关会话的创建与分叉不触发当前树刷新；新子代理仍立即纳入，切换会话仍隔离旧请求。流式性能更新使用每次完整快照预计算的历史基线，不再为每个 delta 遍历全部历史。
+
+大会话树测试包含根会话和 80 个子会话：首次完整读取 161 个消息页；单个子会话变化后的完整快照只重读该会话的 1 页，跨会话读取同时最多 4 个。每次仍重新枚举子会话，以发现新增与删除；分页失败或请求超时不会替换上一次完整快照，重试后恢复。被查看会话的 Context 按 `SessionInfo.revert.messageID` 截断有效消息，再应用最后一次已完成 compaction 边界；测试覆盖回退、重新生成和压缩，阶段性回退不会扣除已产生的全树费用。
+
+`context` 钩子累计记录 MCP 等待与存储写入耗时；MCP 名称缓存 30 秒，并在连接状态变化时失效。存储写入按会话顺序异步执行，模型请求不等待持久化完成；删除事件会等待该会话未完成的写入后清理 `context/<sessionID>`。自动化测试验证缓存、写入顺序、延迟与删除竞争；打包集成测试确认真实宿主删除会话后 RPC 返回空估算。
+
 ## v0.4.0（子代理用量浮窗）
 
 验证日期：2026-09-24。Node.js v22.23.2；SDK 2.0.11，隔离的真实 OpenCode 2.0.11 宿主。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chenlongapps/opencode-token-usage",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Session-tree token usage, live performance, context window and estimated cost for OpenCode 2",
   "keywords": [
     "opencode",
@@ -47,7 +47,7 @@
   "scripts": {
     "build": "node scripts/build.mjs",
     "typecheck": "tsc --noEmit",
-    "test": "tsx --test test/*.test.ts",
+    "test": "tsx --test test/*.test.ts test/*.test.mjs",
     "test:smoke": "node scripts/smoke.mjs",
     "prices:update": "tsx scripts/update-prices.ts",
     "release:patch": "npm version patch",