@chenlongapps/opencode-token-usage 0.4.8 → 0.4.9

package/dist/performance.js

@@ -1,30 +1,39 @@
 import { normalize } from "./usage.js";
 export const LIVE_WINDOW_MS = 2_000;
+export const LIVE_MIN_SPAN_MS = 500;
+export const LIVE_SAMPLE_MS = 100;
 export const LIVE_EWMA_ALPHA = 0.35;
 export const LIVE_BYTES_PER_TOKEN = 4;
-/** Raw live throughput from one step's recent observable deltas. */
+/** The first batch is a counter baseline, not bytes generated after its timestamp. */
 export function estimatedLiveTps(samples) {
     if (samples.length < 2)
         return undefined;
     const first = samples[0];
     const last = samples[samples.length - 1];
     const duration = last.time - first.time;
-    if (!Number.isFinite(duration) || duration <= 0)
+    if (!Number.isFinite(duration) || duration < LIVE_MIN_SPAN_MS)
         return undefined;
     let bytes = 0;
+    let time = first.time;
     for (const sample of samples) {
-        if (!Number.isFinite(sample.time) || !Number.isFinite(sample.bytes) || sample.bytes < 0)
+        if (!Number.isFinite(sample.time) || sample.time < time || !Number.isFinite(sample.bytes) || sample.bytes < 0)
             return undefined;
-        bytes += sample.bytes;
+        if (sample.time > first.time)
+            bytes += sample.bytes;
+        time = sample.time;
     }
-    if (bytes <= 0)
+    if (!Number.isFinite(bytes) || bytes <= 0)
         return undefined;
     return (bytes / LIVE_BYTES_PER_TOKEN) / (duration / 1_000);
 }
-export function smoothLiveTps(previous, raw) {
+/** Time-based EWMA: elapsed time determines the weight, never delta count. */
+export function smoothLiveTps(previous, raw, elapsed = LIVE_MIN_SPAN_MS) {
     if (previous === undefined || !Number.isFinite(previous))
         return raw;
-    return previous * (1 - LIVE_EWMA_ALPHA) + raw * LIVE_EWMA_ALPHA;
+    if (!Number.isFinite(elapsed) || elapsed <= 0)
+        return previous;
+    const alpha = 1 - (1 - LIVE_EWMA_ALPHA) ** (elapsed / LIVE_MIN_SPAN_MS);
+    return previous * (1 - alpha) + raw * alpha;
 }
 const finite = (value) => typeof value === "number" && Number.isFinite(value);
 function historicalFirst(message) {
@@ -109,15 +118,17 @@ function performanceWithObservations(prepared, observations) {
 export class PerformanceMonitor {
     retention;
     now;
+    monotonic;
     active = new Map();
     observed = new Map();
     listeners = new Set();
     cleanupTimer;
     disposed = false;
     unsubscribe;
-    constructor(subscribe, retention = 60_000, now = Date.now) {
+    constructor(subscribe, retention = 60_000, now = Date.now, monotonic = () => performance.now()) {
         this.retention = retention;
         this.now = now;
+        this.monotonic = monotonic;
         this.unsubscribe = subscribe?.(event => this.handle(event));
     }
     listen(listener) {
@@ -149,9 +160,19 @@ export class PerformanceMonitor {
         for (const [key, sample] of this.observed)
             if (sample.sessionID === sessionID)
                 this.observed.delete(key);
+        this.scheduleCleanup();
+    }
+    resetLive(step) {
+        step.samples = [];
+        delete step.bucketStarted;
+        delete step.observedAt;
+        delete step.liveTps;
+        delete step.liveDuration;
+        delete step.smoothedAt;
     }
     prune() {
         const now = this.now();
+        const monotonic = this.monotonic();
         const changed = new Set();
         for (const [key, step] of this.active) {
             if ((step.finishedAt ?? step.reconciledAt) !== undefined
@@ -159,6 +180,10 @@ export class PerformanceMonitor {
                 this.active.delete(key);
                 changed.add(step.sessionID);
             }
+            else if (step.observedAt !== undefined && monotonic - step.observedAt >= LIVE_WINDOW_MS) {
+                this.resetLive(step);
+                changed.add(step.sessionID);
+            }
         }
         for (const [key, sample] of this.observed) {
             if (sample.expiresAt !== undefined && sample.expiresAt <= now) {
@@ -170,17 +195,24 @@ export class PerformanceMonitor {
     }
     scheduleCleanup() {
         clearTimeout(this.cleanupTimer);
-        if (this.disposed || !Number.isFinite(this.retention) || this.retention < 0)
+        this.cleanupTimer = undefined;
+        if (this.disposed)
             return;
         let next = Infinity;
+        const now = this.now();
+        const monotonic = this.monotonic();
+        const retain = Number.isFinite(this.retention) && this.retention >= 0;
         for (const step of this.active.values()) {
             const settled = step.finishedAt ?? step.reconciledAt;
-            if (settled !== undefined)
-                next = Math.min(next, settled + this.retention);
+            if (retain && settled !== undefined)
+                next = Math.min(next, settled + this.retention - now);
+            // Local monotonic age, never client epoch minus a remote event timestamp.
+            if (step.observedAt !== undefined)
+                next = Math.min(next, step.observedAt + LIVE_WINDOW_MS - monotonic);
         }
         for (const sample of this.observed.values()) {
-            if (sample.expiresAt !== undefined)
-                next = Math.min(next, sample.expiresAt);
+            if (retain && sample.expiresAt !== undefined)
+                next = Math.min(next, sample.expiresAt - now);
         }
         if (!Number.isFinite(next))
             return;
@@ -189,7 +221,7 @@ export class PerformanceMonitor {
             for (const sessionID of this.prune())
                 this.publish(sessionID);
             this.scheduleCleanup();
-        }, Math.max(0, next - this.now()));
+        }, Math.max(0, Math.ceil(next)));
         this.cleanupTimer.unref?.();
     }
     handle(event) {
@@ -244,6 +276,8 @@ export class PerformanceMonitor {
             return false;
         if (typeof data.delta !== "string" || data.delta.length === 0 || !finite(event.created) || event.created < step.started)
             return false;
+        if (step.last !== undefined && event.created < step.last)
+            return false;
         if (event.id && step.events.has(event.id))
             return false;
         if (event.id)
@@ -258,19 +292,39 @@ export class PerformanceMonitor {
         }
         const sampleBytes = new TextEncoder().encode(data.delta).byteLength;
         step.bytes += sampleBytes;
-        step.samples.push({ time: event.created, bytes: sampleBytes });
+        if (step.last !== undefined && event.created - step.last >= LIVE_WINDOW_MS)
+            this.resetLive(step);
+        const last = step.samples.at(-1);
+        if (last && step.bucketStarted !== undefined && event.created - step.bucketStarted < LIVE_SAMPLE_MS) {
+            // Include a whole delivery burst in one batch, including the initial baseline.
+            last.time = event.created;
+            last.bytes += sampleBytes;
+        }
+        else {
+            step.bucketStarted = event.created;
+            step.samples.push({ time: event.created, bytes: sampleBytes });
+        }
         const cutoff = event.created - LIVE_WINDOW_MS;
         while (step.samples.length > 0 && step.samples[0].time < cutoff)
             step.samples.shift();
-        // Advance smoothing once per accepted delta, independently of summary readers.
         const raw = estimatedLiveTps(step.samples);
-        if (raw !== undefined)
-            step.liveTps = smoothLiveTps(step.liveTps, raw);
+        if (raw === undefined) {
+            delete step.liveTps;
+            delete step.liveDuration;
+            delete step.smoothedAt;
+        }
+        else if (step.smoothedAt === undefined || event.created - step.smoothedAt >= LIVE_SAMPLE_MS) {
+            step.liveTps = smoothLiveTps(step.liveTps, raw, event.created - (step.smoothedAt ?? event.created));
+            step.liveDuration = event.created - step.samples[0].time;
+            step.smoothedAt = event.created;
+        }
+        step.observedAt = this.monotonic();
         step.last = Math.max(step.last ?? event.created, event.created);
         if (step.first === undefined) {
             step.first = event.created;
             this.observed.set(key, { messageID, sessionID, started: step.started, first: event.created });
         }
+        this.scheduleCleanup();
         this.publish(sessionID);
         return true;
     }
@@ -310,15 +364,15 @@ export class PerformanceMonitor {
         // completed provider usage still replaces this estimate via reconcile().
         let weighted = 0;
         let durationTotal = 0;
+        const monotonic = this.monotonic();
         for (const step of this.active.values()) {
             if (!sessions.has(step.sessionID) || step.reconciledAt !== undefined)
                 continue;
-            if (step.liveTps === undefined || step.samples.length < 2)
+            if (step.liveTps === undefined || step.observedAt === undefined
+                || monotonic - step.observedAt >= LIVE_WINDOW_MS)
                 continue;
-            const first = step.samples[0];
-            const last = step.samples[step.samples.length - 1];
-            const duration = last.time - first.time;
-            if (!finite(duration) || duration <= 0)
+            const duration = step.liveDuration;
+            if (!finite(duration) || duration < LIVE_MIN_SPAN_MS)
                 continue;
             weighted += step.liveTps * duration;
             durationTotal += duration;

package/dist/runtime-monitor.d.ts

@@ -0,0 +1,34 @@
+export interface RuntimeEvent {
+    type: string;
+    data: unknown;
+    created?: number;
+}
+type Subscribe = (listener: (event: RuntimeEvent) => void) => () => void;
+type Listener = (sessionID?: string) => void;
+type Tick = (now: number | undefined) => void;
+/** Shared server-time anchor and display clock; no wall clock, execution log or periodic reads. */
+export declare class RuntimeMonitor {
+    private readonly monotonic;
+    private anchor;
+    private latest;
+    private stopped;
+    private listeners;
+    private ticks;
+    private timer;
+    private synchronization;
+    private disposed;
+    private readonly unsubscribe;
+    constructor(subscribe?: Subscribe, monotonic?: () => number);
+    now(): number | undefined;
+    /** One optional read-only RPC supplies an anchor even when opening a quiet active tool. */
+    synchronize(read: (signal: AbortSignal) => Promise<unknown>): Promise<void>;
+    listen(listener: Listener): () => void;
+    /** Only views actually projecting a live turn keep this single 500ms ticker alive. */
+    tick(listener: Tick): () => void;
+    canEstimate(sessionID: string, messageID: string): boolean;
+    handle(event: RuntimeEvent): void;
+    dispose(): void;
+    private observe;
+    private publish;
+}
+export {};

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,6 +3,17 @@ 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;
+    };
 }
 /**
  * OpenCode 2.0.26's TUI turnDuration/inputIndex: completed assistant time minus
@@ -13,3 +24,7 @@ export interface RuntimeSummary {
  * No execution-log API, client clock, child history, or additional reads.
  */
 export declare function summarizeRuntime(messages: readonly UsageMessage[], fork?: boolean): RuntimeSummary;
+/** Scan history once per snapshot, keeping the current turn's overlapping subtotal separate. */
+export declare function prepareRuntime(messages: readonly UsageMessage[], fork?: boolean): 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

@@ -9,6 +9,10 @@ const timestamp = (value) => typeof value === "number" && value >= 0
  * No execution-log API, client clock, child history, or additional reads.
  */
 export function summarizeRuntime(messages, fork = false) {
+    return prepareRuntime(messages, fork).summary;
+}
+/** Scan history once per snapshot, keeping the current turn's overlapping subtotal separate. */
+export function prepareRuntime(messages, fork = false) {
     // Even a copied marker identifies the host's turn semantics for an open fork.
     const legacy = !messages.some(message => message.type === "idle");
     // Fork copies belong to the original session, including copied turn boundaries.
@@ -16,6 +20,8 @@ export function summarizeRuntime(messages, fork = false) {
     let milliseconds = 0, unavailable = false;
     let input;
     let response, completedResponse;
+    let lastAssistant;
+    let turnMilliseconds = 0;
     const finish = (closed) => {
         if (!response)
             return;
@@ -40,23 +46,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 +79,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;
 }