@chenlongapps/opencode-token-usage 0.2.3 → 0.2.4

package/ROADMAP.md

@@ -59,6 +59,7 @@ TTFT  2.7s
 目标：提供可查询的价格目录，便于用户了解不同模型的计费档位。
 
 * [ ] 构建公开价格目录，包含模型、价格档位及阈值
+* [ ] 只收录半年内发布的模型
 <!-- TODO -->
 
 ## v0.4.0 — 用量命令

package/dist/controller.d.ts

@@ -1,4 +1,5 @@
 import type { UsageSource } from "./source.js";
+import { PerformanceMonitor } from "./performance.js";
 import type { PerformanceSummary } from "./performance.js";
 import type { ContextUsage, Summary } from "./usage.js";
 export interface UsageState {
@@ -30,11 +31,14 @@ export declare class UsageController {
     private timer;
     private retry;
     private performanceTimer;
+    private sessions;
     private pending;
     private disposed;
     private unsubscribe;
+    private readonly unsubscribePerformance;
     private readonly performance;
-    constructor(source: UsageSource, subscribe: Subscribe, publish: (state: UsageState) => void, delay?: number, retryDelay?: number, performanceDelay?: number);
+    private readonly ownsPerformance;
+    constructor(source: UsageSource, subscribe: Subscribe, publish: (state: UsageState) => void, delay?: number, retryDelay?: number, performanceDelay?: number, performance?: PerformanceMonitor);
     select(sessionID: string): void;
     refresh(): void;
     dispose(): void;

package/dist/controller.js

@@ -1,10 +1,6 @@
 import { loadSnapshot, uniqueMessages, viewedMessages } from "./source.js";
-import { PerformanceTracker } from "./performance.js";
+import { PerformanceMonitor } from "./performance.js";
 import { contextUsage, summarize } from "./usage.js";
-const performanceEvents = new Set([
-    "session.step.started", "session.step.streamed", "session.step.ended", "session.step.failed",
-    "session.text.delta", "session.reasoning.delta", "session.tool.input.delta",
-]);
 const sessionEvents = new Set([
     "session.created", "session.deleted", "session.forked", "session.moved",
     "session.model.selected", "session.agent.selected", "session.step.ended", "session.step.failed",
@@ -31,22 +27,32 @@ export class UsageController {
     timer;
     retry;
     performanceTimer;
+    sessions = new Set();
     pending = false;
     disposed = false;
     unsubscribe;
-    performance = new PerformanceTracker();
-    constructor(source, subscribe, publish, delay = 80, retryDelay = 3_000, performanceDelay = 100) {
+    unsubscribePerformance;
+    performance;
+    ownsPerformance;
+    constructor(source, subscribe, publish, delay = 80, retryDelay = 3_000, performanceDelay = 100, performance) {
         this.source = source;
         this.publish = publish;
         this.delay = delay;
         this.retryDelay = retryDelay;
         this.performanceDelay = performanceDelay;
+        this.ownsPerformance = performance === undefined;
+        this.performance = performance ?? new PerformanceMonitor(subscribe);
+        this.unsubscribePerformance = this.performance.listen(sessionID => {
+            if (this.sessions.has(sessionID))
+                this.refreshPerformance();
+        });
         this.unsubscribe = subscribe(event => {
             const data = (event.data && typeof event.data === "object" ? event.data : {});
-            if (event.type === "session.created")
-                this.performance.addSession(data.sessionID, data.parentID);
-            if (performanceEvents.has(event.type) && this.performance.handle(event))
-                this.refreshPerformance();
+            if (event.type === "session.created" && data.sessionID && data.parentID && this.sessions.has(data.parentID)) {
+                this.sessions.add(data.sessionID);
+            }
+            if (event.type === "session.deleted" && data.sessionID)
+                this.sessions.delete(data.sessionID);
             if (globalEvents.has(event.type))
                 return this.refresh();
             if (!sessionEvents.has(event.type))
@@ -69,6 +75,7 @@ export class UsageController {
         this.performanceTimer = undefined;
         this.pending = false;
         this.snapshot = undefined;
+        this.sessions.clear();
         this.sessionID = sessionID;
         this.update({ status: "loading" });
         void this.run();
@@ -95,7 +102,10 @@ export class UsageController {
         clearTimeout(this.timer);
         clearTimeout(this.retry);
         clearTimeout(this.performanceTimer);
+        this.unsubscribePerformance();
         this.unsubscribe();
+        if (this.ownsPerformance)
+            this.performance.dispose();
     }
     update(state) { this.state = state; this.publish(state); }
     refreshPerformance() {
@@ -105,7 +115,7 @@ export class UsageController {
             this.performanceTimer = undefined;
             if (this.disposed || !this.snapshot || !this.state.summary)
                 return;
-            this.update({ ...this.state, performance: this.performance.summary(uniqueMessages(this.snapshot)) });
+            this.update({ ...this.state, performance: this.performance.summary(uniqueMessages(this.snapshot), this.sessions) });
         }, this.performanceDelay);
     }
     async run() {
@@ -121,15 +131,15 @@ export class UsageController {
                 return;
             this.snapshot = snapshot;
             const messages = [...uniqueMessages(snapshot)];
-            this.performance.setTree(snapshot.rootID, snapshot.sessions.keys());
-            this.performance.reconcile(messages);
+            this.sessions = new Set(snapshot.sessions.keys());
+            this.performance.reconcile(messages, this.sessions);
             clearTimeout(this.performanceTimer);
             this.performanceTimer = undefined;
             this.update({
                 status: "ready",
                 summary: summarize(messages, snapshot.model.prices),
                 context: contextUsage(viewedMessages(snapshot), snapshot.model.context),
-                performance: this.performance.summary(messages),
+                performance: this.performance.summary(messages, this.sessions),
                 model: snapshot.model.label,
             });
         }

package/dist/performance.d.ts

@@ -17,17 +17,29 @@ export interface PerformanceEvent {
     id?: string;
     created?: number;
 }
+export type PerformanceSubscribe = (listener: (event: PerformanceEvent) => void) => () => void;
+export type PerformanceListener = (sessionID: string) => void;
 /** Exact completed-run TPS and the average of only measurable TTFT samples. */
 export declare function historicalPerformance(messages: Iterable<UsageMessage>, observations?: Iterable<FirstTokenObservation>): PerformanceSummary;
-/** Tracks ephemeral streaming events without fetching the full session tree. */
-export declare class PerformanceTracker {
-    private rootID;
-    private sessions;
+/** Captures streaming performance for every session for one plugin lifetime. */
+export declare class PerformanceMonitor {
+    private readonly retention;
+    private readonly now;
     private active;
     private observed;
-    setTree(rootID: string, sessionIDs: Iterable<string>): void;
-    addSession(sessionID: string | undefined, parentID: string | undefined): void;
+    private listeners;
+    private cleanupTimer;
+    private disposed;
+    private readonly unsubscribe;
+    constructor(subscribe?: PerformanceSubscribe, retention?: number, now?: () => number);
+    listen(listener: PerformanceListener): () => void;
+    dispose(): void;
+    private key;
+    private publish;
+    private deleteSession;
+    private prune;
+    private scheduleCleanup;
     handle(event: PerformanceEvent): boolean;
-    reconcile(messages: Iterable<UsageMessage>): void;
-    summary(messages: Iterable<UsageMessage>): PerformanceSummary;
+    reconcile(messages: Iterable<UsageMessage>, sessionIDs: Iterable<string>): void;
+    summary(messages: Iterable<UsageMessage>, sessionIDs: Iterable<string>): PerformanceSummary;
 }

package/dist/performance.js

@@ -68,56 +68,134 @@ export function historicalPerformance(messages, observations = []) {
         result.ttft = ttft / ttftSamples;
     return result;
 }
-/** Tracks ephemeral streaming events without fetching the full session tree. */
-export class PerformanceTracker {
-    rootID;
-    sessions = new Set();
+/** Captures streaming performance for every session for one plugin lifetime. */
+export class PerformanceMonitor {
+    retention;
+    now;
     active = new Map();
     observed = new Map();
-    setTree(rootID, sessionIDs) {
-        if (this.rootID !== rootID) {
-            this.active.clear();
-            this.observed.clear();
-            this.rootID = rootID;
-        }
-        this.sessions = new Set(sessionIDs);
-        for (const [id, step] of this.active)
-            if (!this.sessions.has(step.sessionID))
-                this.active.delete(id);
-        for (const [id, sample] of this.observed)
-            if (!this.sessions.has(sample.sessionID))
-                this.observed.delete(id);
+    listeners = new Set();
+    cleanupTimer;
+    disposed = false;
+    unsubscribe;
+    constructor(subscribe, retention = 60_000, now = Date.now) {
+        this.retention = retention;
+        this.now = now;
+        this.unsubscribe = subscribe?.(event => this.handle(event));
     }
-    addSession(sessionID, parentID) {
-        if (sessionID && parentID && this.sessions.has(parentID))
-            this.sessions.add(sessionID);
+    listen(listener) {
+        if (this.disposed)
+            return () => { };
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.unsubscribe?.();
+        clearTimeout(this.cleanupTimer);
+        this.cleanupTimer = undefined;
+        this.listeners.clear();
+        this.active.clear();
+        this.observed.clear();
+    }
+    key(sessionID, messageID) { return `${sessionID}\0${messageID}`; }
+    publish(sessionID) {
+        for (const listener of this.listeners)
+            listener(sessionID);
+    }
+    deleteSession(sessionID) {
+        for (const [key, step] of this.active)
+            if (step.sessionID === sessionID)
+                this.active.delete(key);
+        for (const [key, sample] of this.observed)
+            if (sample.sessionID === sessionID)
+                this.observed.delete(key);
+    }
+    prune() {
+        const now = this.now();
+        const changed = new Set();
+        for (const [key, step] of this.active) {
+            if (step.finishedAt !== undefined && step.finishedAt + this.retention <= now) {
+                this.active.delete(key);
+                changed.add(step.sessionID);
+            }
+        }
+        for (const [key, sample] of this.observed) {
+            if (sample.expiresAt !== undefined && sample.expiresAt <= now) {
+                this.observed.delete(key);
+                changed.add(sample.sessionID);
+            }
+        }
+        return changed;
+    }
+    scheduleCleanup() {
+        clearTimeout(this.cleanupTimer);
+        if (this.disposed || !Number.isFinite(this.retention) || this.retention < 0)
+            return;
+        let next = Infinity;
+        for (const step of this.active.values()) {
+            if (step.finishedAt !== undefined)
+                next = Math.min(next, step.finishedAt + this.retention);
+        }
+        for (const sample of this.observed.values()) {
+            if (sample.expiresAt !== undefined)
+                next = Math.min(next, sample.expiresAt);
+        }
+        if (!Number.isFinite(next))
+            return;
+        this.cleanupTimer = setTimeout(() => {
+            this.cleanupTimer = undefined;
+            for (const sessionID of this.prune())
+                this.publish(sessionID);
+            this.scheduleCleanup();
+        }, Math.max(0, next - this.now()));
+        this.cleanupTimer.unref?.();
     }
     handle(event) {
+        if (this.disposed)
+            return false;
+        for (const sessionID of this.prune())
+            this.publish(sessionID);
         const data = (event.data && typeof event.data === "object" ? event.data : {});
         const sessionID = typeof data.sessionID === "string" ? data.sessionID : undefined;
+        if (event.type === "session.deleted") {
+            if (sessionID)
+                this.deleteSession(sessionID);
+            return false;
+        }
         const messageID = typeof data.assistantMessageID === "string" ? data.assistantMessageID : undefined;
-        if (!sessionID || !messageID || !this.sessions.has(sessionID))
+        if (!sessionID || !messageID)
             return false;
+        const key = this.key(sessionID, messageID);
         if (event.type === "session.step.started") {
             if (!finite(data.started))
                 return false;
-            if (this.active.has(messageID))
+            if (this.active.has(key))
                 return false;
-            this.active.set(messageID, {
+            this.active.set(key, {
                 messageID, sessionID, started: data.started, bytes: 0, events: new Set(),
             });
             return false;
         }
-        const step = this.active.get(messageID);
+        const step = this.active.get(key);
         if (!step)
             return false;
         if (event.type === "session.step.streamed") {
             if (!finite(event.created) || event.created < step.started)
                 return false;
             step.streamed = event.created;
+            if (step.bytes > 0)
+                this.publish(sessionID);
             return step.bytes > 0;
         }
         if (event.type === "session.step.ended" || event.type === "session.step.failed") {
+            step.finishedAt = this.now();
+            const sample = this.observed.get(key);
+            if (sample)
+                sample.expiresAt = step.finishedAt + this.retention;
+            this.scheduleCleanup();
             return false;
         }
         if (event.type !== "session.text.delta" && event.type !== "session.reasoning.delta"
@@ -133,29 +211,33 @@ export class PerformanceTracker {
         step.last = Math.max(step.last ?? event.created, event.created);
         if (step.first === undefined) {
             step.first = event.created;
-            this.observed.set(messageID, { messageID, sessionID, started: step.started, first: event.created });
+            this.observed.set(key, { messageID, sessionID, started: step.started, first: event.created });
         }
+        this.publish(sessionID);
         return true;
     }
-    reconcile(messages) {
+    reconcile(messages, sessionIDs) {
+        const sessions = new Set(sessionIDs);
         const represented = new Set();
         for (const message of messages) {
             if (message.type === "assistant" && (message.tokens || message.time?.streamed !== undefined
                 || message.time?.completed !== undefined))
                 represented.add(message.id);
         }
-        for (const [id, step] of this.active) {
-            if (represented.has(id))
-                this.active.delete(id);
+        for (const [key, step] of this.active) {
+            if (sessions.has(step.sessionID) && represented.has(step.messageID)
+                && (step.finishedAt !== undefined || step.streamed !== undefined))
+                this.active.delete(key);
         }
     }
-    summary(messages) {
-        const samples = [...this.observed.values()].filter(sample => this.sessions.has(sample.sessionID));
+    summary(messages, sessionIDs) {
+        const sessions = new Set(sessionIDs);
+        const samples = [...this.observed.values()].filter(sample => sessions.has(sample.sessionID));
         const result = historicalPerformance(messages, samples);
         let bytes = 0;
         let duration = 0;
         for (const step of this.active.values()) {
-            if (!this.sessions.has(step.sessionID) || step.bytes <= 0)
+            if (!sessions.has(step.sessionID) || step.bytes <= 0)
                 continue;
             const last = step.streamed ?? step.last;
             if (!finite(last) || last <= step.started)

package/dist/tui.js

@@ -8,6 +8,7 @@ import { createElement as _$createElement } from "@opentui/solid";
 import { Plugin } from "@opencode/plugin/tui";
 import { createEffect, createMemo, createSignal, For, onCleanup, Show } from "solid-js";
 import { UsageController } from "./controller.js";
+import { PerformanceMonitor } from "./performance.js";
 import { createSource } from "./source.js";
 import { usageRows } from "./usage.js";
 function UsagePanel(props) {
@@ -16,7 +17,7 @@ function UsagePanel(props) {
   });
   const controller = new UsageController(createSource(props.context.client), listener => props.context.data.listen(({
     details
-  }) => listener(details)), setState);
+  }) => listener(details)), setState, 80, 3_000, 100, props.performance);
   const unregister = props.register(controller);
   createEffect(() => controller.select(props.sessionID));
   onCleanup(() => {
@@ -89,6 +90,9 @@ function UsagePanel(props) {
 export default Plugin.define({
   id: "opencode-token-usage.tui",
   setup(context) {
+    const performance = new PerformanceMonitor(listener => context.data.listen(({
+      details
+    }) => listener(details)));
     const controllers = new Set();
     const register = controller => {
       controllers.add(controller);
@@ -103,6 +107,7 @@ export default Plugin.define({
         get sessionID() {
           return props.sessionID;
         },
+        performance: performance,
         register: register
       })
     });
@@ -130,6 +135,7 @@ export default Plugin.define({
             get sessionID() {
               return props.sessionID;
             },
+            performance: performance,
             register: register
           }));
           return _el$9;
@@ -141,6 +147,7 @@ export default Plugin.define({
       controllers.clear();
       remove();
       removeChild();
+      performance.dispose();
     };
   }
 });

package/docs/verification.md

@@ -2,26 +2,28 @@
 
 ## 未发布（SDK 2.0.11）
 
-验证日期：2026-09-20。环境：macOS、Node.js v22.23.2、npm 10.9.8、OpenCode v2.0.11；`@opencode/plugin`、`@opencode/client`、`@opencode/schema` 和 `@opencode/theme` 均精确锁定为 2.0.11。
+验证日期：2026-09-22。环境：macOS、Node.js v22.23.2、npm 10.9.8、OpenCode v2.0.11；`@opencode/plugin`、`@opencode/client`、`@opencode/schema` 和 `@opencode/theme` 均精确锁定为 2.0.11。
 
 ### 自动化检查
 
 | 检查 | 结果 |
 | --- | --- |
 | `npm run typecheck` | 通过 |
-| `npm test` | 29 项通过 |
+| `npm test` | 31 项通过 |
 | `npm run build` | 通过，输出 ESM 与类型声明 |
 | `npm run test:smoke` | 通过，使用实际 `.tgz` 安装产物和真实 OpenCode 2.0.11 |
 
 SDK 从 2.0.9 升级到 2.0.11 后，四个顶层 OpenCode 包及锁文件中的传递依赖均已统一到 2.0.11。`@opencode/plugin` 两版的导出结构一致；包内容差异除依赖版本外，仅为 `ToastOptions` 新增可选的 `sessionID` 类型字段。
 
+新增共享性能监视器测试覆盖：查看会话 A 时捕获独立会话 B 的流，切换到 B 后立即恢复实时 TPS/TTFT；生成中切走、继续接收 delta 再切回；控制器销毁重建后恢复共享流；不同会话树隔离、新子代理即时纳入，以及删除会话清理运行期状态。既有重复事件去重与完成后收敛为精确 TPS 的断言继续通过。
+
 ### 真实 OpenCode 集成
 
-隔离 smoke 测试确认打包插件可加载；空会话隐藏无数据行；活动 TPS 估算会收敛为精确值；TTFT、token、上下文与费用正常刷新；真实子代理用量可从父子视图累计且上下文保持会话局部；切换活动模型会同步更新价格选择与上下文上限。测试产物保存在 `/var/folders/rw/bmx6c8hd737brl55m0_ff_b80000gn/T/token-usage-smoke-JXe1KG`。
+隔离 smoke 测试确认打包插件可加载；空会话隐藏无数据行；在独立会话已经开始慢速流后，同一 TUI 切换过去会立即显示 `TPS ~…` 与 TTFT，完成后变为无 `~` 的精确 TPS；既有 token、上下文与费用刷新、真实子代理全树累计、会话局部上下文及模型切换验证均继续通过。测试产物保存在 `/var/folders/rw/bmx6c8hd737brl55m0_ff_b80000gn/T/token-usage-smoke-cgsCK2`。
 
 ### 验证边界
 
-当前 SDK 2.0.11 与宿主 2.0.11 的组合已完整验证。2.0.9 和 2.0.10 宿主的历史验证记录保留在下方，但升级 SDK 后未重新执行这两个旧宿主的打包矩阵：本地仅有 2.0.11，官方 GitHub Releases 也没有可获取的对应旧版本资产。后续升级 SDK 或宿主时，仍需重新核对分叉副本、compaction 排序及 step/delta 事件语义。
+当前 SDK 2.0.11 与宿主 2.0.11 的组合已完整验证。验证时机器默认宿主已是 2.0.12，因此 smoke 使用校验完整性的官方 `@opencode/cli-darwin-arm64@2.0.11` 隔离二进制，没有放宽宿主版本断言。2.0.9 和 2.0.10 宿主的历史验证记录保留在下方，但升级 SDK 后未重新执行这两个旧宿主的打包矩阵。后续升级 SDK 或宿主时，仍需重新核对分叉副本、compaction 排序及 step/delta 事件语义。
 
 ## v0.2.1（TPS 与 TTFT）
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chenlongapps/opencode-token-usage",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Session-tree token usage, live performance, context window and estimated cost for OpenCode 2",
   "keywords": [
     "opencode",