@chenlongapps/opencode-token-usage 0.4.8 → 0.4.10

package/dist/runtime-monitor.js

@@ -0,0 +1,155 @@
+const timestamp = (value) => typeof value === "number" && value >= 0
+    && Number.isFinite(new Date(value).getTime());
+/** Shared server-time anchor and display clock; no wall clock, execution log or periodic reads. */
+export class RuntimeMonitor {
+    monotonic;
+    anchor;
+    latest = new Map();
+    stopped = new Set();
+    listeners = new Set();
+    ticks = new Set();
+    timer;
+    synchronization;
+    disposed = false;
+    unsubscribe;
+    constructor(subscribe, monotonic = () => performance.now()) {
+        this.monotonic = monotonic;
+        this.unsubscribe = subscribe?.(event => this.handle(event));
+    }
+    now() {
+        if (!this.anchor)
+            return undefined;
+        const now = this.anchor.server + Math.max(0, this.monotonic() - this.anchor.local);
+        return timestamp(now) ? now : undefined;
+    }
+    /** One optional read-only RPC supplies an anchor even when opening a quiet active tool. */
+    async synchronize(read) {
+        if (this.disposed)
+            return;
+        this.synchronization?.abort();
+        const request = new AbortController();
+        this.synchronization = request;
+        const start = this.monotonic();
+        const signal = AbortSignal.any([request.signal, AbortSignal.timeout(5_000)]);
+        try {
+            const server = await read(signal);
+            if (this.disposed || signal.aborted || !timestamp(server))
+                return;
+            // Midpoint correction bounds the initial network-delay estimate without
+            // ever assuming the client and a remote server share an epoch clock.
+            this.observe(server + Math.max(0, this.monotonic() - start) / 2);
+            this.publish();
+        }
+        catch { /* Without a trusted anchor, retain native totals until a live event arrives. */ }
+        finally {
+            request.abort();
+            if (this.synchronization === request)
+                this.synchronization = undefined;
+        }
+    }
+    listen(listener) {
+        if (this.disposed)
+            return () => { };
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    }
+    /** Only views actually projecting a live turn keep this single 500ms ticker alive. */
+    tick(listener) {
+        if (this.disposed)
+            return () => { };
+        this.ticks.add(listener);
+        this.timer ??= setInterval(() => {
+            const now = this.now();
+            for (const tick of this.ticks)
+                tick(now);
+        }, 500);
+        this.timer.unref?.();
+        return () => {
+            this.ticks.delete(listener);
+            if (!this.ticks.size) {
+                clearInterval(this.timer);
+                this.timer = undefined;
+            }
+        };
+    }
+    canEstimate(sessionID, messageID) {
+        const latest = this.latest.get(sessionID);
+        return !this.disposed && !this.stopped.has(sessionID)
+            && (!latest || (latest.messageID === messageID && !latest.settled));
+    }
+    handle(event) {
+        if (this.disposed)
+            return;
+        if (event.type === "server.connected") {
+            this.anchor = undefined;
+            this.latest.clear();
+            this.stopped.clear();
+        }
+        const firstAnchor = !this.anchor && timestamp(event.created);
+        if (timestamp(event.created))
+            this.observe(event.created);
+        const data = (event.data && typeof event.data === "object" ? event.data : {});
+        const sessionID = data.sessionID;
+        if (event.type === "global.disposed" || event.type === "location.shutdown") {
+            this.anchor = undefined;
+            this.publish();
+            return;
+        }
+        if (sessionID) {
+            const latest = this.latest.get(sessionID);
+            // Late/replayed endings cannot stop a newer step.
+            const older = timestamp(event.created) && timestamp(latest?.created) && event.created < latest.created;
+            if (event.type === "session.deleted") {
+                this.latest.delete(sessionID);
+                this.stopped.add(sessionID);
+                this.publish(sessionID);
+            }
+            else if (!older && event.type === "session.step.started" && typeof data.assistantMessageID === "string") {
+                this.latest.set(sessionID, { messageID: data.assistantMessageID, settled: false,
+                    ...(timestamp(event.created) ? { created: event.created } : {}) });
+                this.stopped.delete(sessionID);
+                this.publish(sessionID);
+            }
+            else if (!older && (event.type === "session.step.failed"
+                || (event.type === "session.step.ended" && data.finish && !["tool-calls", "unknown"].includes(data.finish)))) {
+                if (typeof data.assistantMessageID === "string" && (!latest || latest.messageID === data.assistantMessageID)) {
+                    this.latest.set(sessionID, { messageID: data.assistantMessageID, settled: true,
+                        ...(timestamp(event.created) ? { created: event.created } : {}) });
+                    this.publish(sessionID);
+                }
+            }
+            else if (!older && event.type === "session.retry.scheduled" && latest && latest.messageID === data.assistantMessageID) {
+                latest.settled = false;
+                this.publish(sessionID);
+            }
+            else if (!older && ["session.execution.succeeded", "session.execution.failed", "session.execution.interrupted", "session.idle"].includes(event.type)) {
+                this.stopped.add(sessionID);
+                this.publish(sessionID);
+            }
+        }
+        if (firstAnchor || event.type === "server.connected")
+            this.publish();
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.synchronization?.abort();
+        this.unsubscribe?.();
+        clearInterval(this.timer);
+        this.timer = undefined;
+        this.anchor = undefined;
+        this.listeners.clear();
+        this.ticks.clear();
+        this.latest.clear();
+        this.stopped.clear();
+    }
+    observe(server) {
+        // Do not move the live estimate backwards for old/duplicated stream events.
+        if (!timestamp(server))
+            return;
+        this.anchor = { server: Math.max(this.now() ?? server, server), local: this.monotonic() };
+    }
+    publish(sessionID) { for (const listener of this.listeners)
+        listener(sessionID); }
+}

package/dist/runtime.d.ts

@@ -3,13 +3,35 @@ export interface RuntimeSummary {
     status: "loading" | "ready" | "stale" | "unavailable";
     /** Sum of one native response duration per turn in the viewed session's retained history. */
     milliseconds?: number | undefined;
+    /** Display-only projection; never becomes part of the native historical subtotal. */
+    estimatedMilliseconds?: number | undefined;
+}
+export interface PreparedRuntime {
+    summary: RuntimeSummary;
+    /** Only a response/continuation at the open tail can be projected while the host is running. */
+    turn?: {
+        messageID: string;
+        started: number;
+        milliseconds: number;
+    };
+}
+/** Native session metadata from the existing session read; omitted metadata is unknown. */
+export interface RuntimeTime {
+    created: number;
+    idle?: number;
 }
 /**
  * OpenCode 2.0.26's TUI turnDuration/inputIndex: completed assistant time minus
  * the first user/synthetic input after the previous idle marker, or the nearest
- * input in legacy histories with no idle markers. With no input it falls back
- * to the assistant's creation time. Take only the final response in each turn:
+ * input in legacy histories with no idle markers. Native session metadata with
+ * no previous idle identifies the first turn, even before its first marker.
+ * With no input it falls back to the assistant's creation time.
+ * Take only the final response in each turn:
  * intermediate footer durations overlap and must never be added separately.
  * No execution-log API, client clock, child history, or additional reads.
  */
-export declare function summarizeRuntime(messages: readonly UsageMessage[], fork?: boolean): RuntimeSummary;
+export declare function summarizeRuntime(messages: readonly UsageMessage[], fork?: boolean, time?: RuntimeTime): RuntimeSummary;
+/** Scan history once per snapshot, keeping the current turn's overlapping subtotal separate. */
+export declare function prepareRuntime(messages: readonly UsageMessage[], fork?: boolean, time?: RuntimeTime): PreparedRuntime;
+/** Replace, rather than add to, an already-counted footer in the same steered turn. */
+export declare function projectRuntime(prepared: PreparedRuntime, now: number | undefined): RuntimeSummary;

package/dist/runtime.js

@@ -3,19 +3,31 @@ const timestamp = (value) => typeof value === "number" && value >= 0
 /**
  * OpenCode 2.0.26's TUI turnDuration/inputIndex: completed assistant time minus
  * the first user/synthetic input after the previous idle marker, or the nearest
- * input in legacy histories with no idle markers. With no input it falls back
- * to the assistant's creation time. Take only the final response in each turn:
+ * input in legacy histories with no idle markers. Native session metadata with
+ * no previous idle identifies the first turn, even before its first marker.
+ * With no input it falls back to the assistant's creation time.
+ * Take only the final response in each turn:
  * intermediate footer durations overlap and must never be added separately.
  * No execution-log API, client clock, child history, or additional reads.
  */
-export function summarizeRuntime(messages, fork = false) {
+export function summarizeRuntime(messages, fork = false, time) {
+    return prepareRuntime(messages, fork, time).summary;
+}
+/** Scan history once per snapshot, keeping the current turn's overlapping subtotal separate. */
+export function prepareRuntime(messages, fork = false, time) {
+    // A new session has not recorded an idle yet. Merely missing a message marker
+    // must not turn synthetic deliveries/steers into new turns during that run.
+    // Unknown metadata retains the native legacy fallback, as does a past idle.
+    const firstTurn = timestamp(time?.created) && time?.idle === undefined;
     // Even a copied marker identifies the host's turn semantics for an open fork.
-    const legacy = !messages.some(message => message.type === "idle");
+    const legacy = !firstTurn && !messages.some(message => message.type === "idle");
     // Fork copies belong to the original session, including copied turn boundaries.
     const history = fork ? messages.filter(message => !/_\d+$/.test(message.id)) : messages;
     let milliseconds = 0, unavailable = false;
     let input;
     let response, completedResponse;
+    let lastAssistant;
+    let turnMilliseconds = 0;
     const finish = (closed) => {
         if (!response)
             return;
@@ -40,23 +52,29 @@ export function summarizeRuntime(messages, fork = false) {
             unavailable = true;
             return;
         }
-        milliseconds += Math.max(0, completed - created);
+        turnMilliseconds = Math.max(0, completed - created);
+        milliseconds += turnMilliseconds;
     };
     for (const message of history) {
         if (message.type === "idle") {
             finish(true);
             input = undefined;
             response = completedResponse = undefined;
+            lastAssistant = undefined;
+            turnMilliseconds = 0;
         }
         else if (message.type === "user" || message.type === "synthetic") {
             if (legacy) {
                 finish(true);
                 input = undefined;
                 response = completedResponse = undefined;
+                lastAssistant = undefined;
+                turnMilliseconds = 0;
             }
             input ??= message;
         }
         else if (message.type === "assistant") {
+            lastAssistant = message;
             // Matches native footer eligibility. Older imported messages can lack
             // finish metadata; their completed timestamp still permits a duration.
             if (!message.error && !message.retry && (message.finish === "tool-calls" || message.finish === "unknown"))
@@ -67,6 +85,25 @@ export function summarizeRuntime(messages, fork = false) {
         }
     }
     finish(false);
-    return unavailable || !Number.isFinite(milliseconds)
-        ? { status: "unavailable" } : { status: "ready", milliseconds };
+    if (unavailable || !Number.isFinite(milliseconds))
+        return { summary: { status: "unavailable" } };
+    const summary = { status: "ready", milliseconds };
+    const started = input ? input.time?.created : lastAssistant?.time?.created;
+    // Tool steps and scheduled retries can be completed without ending the turn.
+    // A terminal response must not keep growing during the later idle/cleanup transition.
+    const continuing = lastAssistant && (lastAssistant.retry || (!lastAssistant.error
+        && (lastAssistant.finish === "tool-calls" || lastAssistant.finish === "unknown"
+            || (!lastAssistant.finish && lastAssistant.time?.completed === undefined))));
+    if (!lastAssistant || !continuing || !timestamp(started) || !timestamp(lastAssistant.time?.created))
+        return { summary };
+    return { summary, turn: { messageID: lastAssistant.id, started, milliseconds: turnMilliseconds } };
+}
+/** Replace, rather than add to, an already-counted footer in the same steered turn. */
+export function projectRuntime(prepared, now) {
+    const { summary, turn } = prepared;
+    if (summary.status !== "ready" || summary.milliseconds === undefined || !turn || !timestamp(now))
+        return summary;
+    const elapsed = Math.max(turn.milliseconds, now - turn.started, 0);
+    const estimatedMilliseconds = Math.round(summary.milliseconds - turn.milliseconds + elapsed);
+    return Number.isFinite(estimatedMilliseconds) ? { ...summary, estimatedMilliseconds } : summary;
 }

package/dist/source.d.ts

@@ -1,7 +1,8 @@
 import type { OpenCodeClient, SessionInfo } from "@opencode/client";
 import type { ContextSources } from "./context-sources.js";
+import type { ReadActiveSessions } from "./performance.js";
 import type { PriceCatalog, UsageMessage } from "./usage.js";
-export type Session = Pick<SessionInfo, "id" | "parentID" | "fork" | "model" | "location" | "title" | "revert">;
+export type Session = Pick<SessionInfo, "id" | "parentID" | "fork" | "model" | "location" | "title" | "revert"> & Partial<Pick<SessionInfo, "time">>;
 export interface Page<T> {
     data: T[];
     cursor: {
@@ -21,6 +22,7 @@ export interface UsageSource {
     messages(id: string, cursor: string | undefined, signal: AbortSignal): Promise<Page<UsageMessage>>;
     model(session: Session, signal: AbortSignal): Promise<ActiveModel>;
     composition?(session: Session, signal: AbortSignal): Promise<ContextSources | undefined>;
+    active?: ReadActiveSessions;
 }
 export declare function createSource(client: OpenCodeClient): UsageSource;
 export declare function pages<T>(read: (cursor?: string) => Promise<Page<T>>, signal: AbortSignal): Promise<T[]>;

package/dist/source.js

@@ -3,6 +3,16 @@ import { parseContextSources } from "./context-sources.js";
 import { modelKey } from "./usage.js";
 export function createSource(client) {
     return {
+        async active(signal) {
+            // V2 returns the complete process-wide foreground-drain set, already unwrapped
+            // by the Promise client. Cached TUI status can still be stale after reconnect.
+            const active = await client.session.active({ signal });
+            if (!active || typeof active !== "object" || Array.isArray(active)
+                || Object.values(active).some(value => !value || value.type !== "running")) {
+                throw new Error("Invalid active session snapshot");
+            }
+            return new Set(Object.keys(active));
+        },
         session: (sessionID, signal) => client.session.get({ sessionID }, { signal }),
         children: (parentID, cursor, signal) => client.session.list(cursor ? { cursor } : { parentID, order: "asc", limit: 100 }, { signal }),
         // Unlike session.context(), message.list() includes pre-compaction history.