@chenlongapps/opencode-token-usage 0.4.2 → 0.4.4

package/dist/performance.js

@@ -1,4 +1,31 @@
 import { normalize } from "./usage.js";
+export const LIVE_WINDOW_MS = 2_000;
+export const LIVE_EWMA_ALPHA = 0.35;
+export const LIVE_BYTES_PER_TOKEN = 4;
+/** Raw live throughput from one step's recent observable deltas. */
+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)
+        return undefined;
+    let bytes = 0;
+    for (const sample of samples) {
+        if (!Number.isFinite(sample.time) || !Number.isFinite(sample.bytes) || sample.bytes < 0)
+            return undefined;
+        bytes += sample.bytes;
+    }
+    if (bytes <= 0)
+        return undefined;
+    return (bytes / LIVE_BYTES_PER_TOKEN) / (duration / 1_000);
+}
+export function smoothLiveTps(previous, raw) {
+    if (previous === undefined || !Number.isFinite(previous))
+        return raw;
+    return previous * (1 - LIVE_EWMA_ALPHA) + raw * LIVE_EWMA_ALPHA;
+}
 const finite = (value) => typeof value === "number" && Number.isFinite(value);
 function historicalFirst(message) {
     const started = message.time?.created;
@@ -25,20 +52,18 @@ function historicalFirst(message) {
 }
 /** Exact completed-run TPS and the average of only measurable TTFT samples. */
 export function historicalPerformance(messages, observations = []) {
-    const observed = new Map();
-    for (const sample of observations) {
-        if (finite(sample.started) && finite(sample.first) && sample.first >= sample.started)
-            observed.set(sample.messageID, sample);
-    }
+    return performanceWithObservations(preparePerformance(messages), observations);
+}
+/** The immutable part of a snapshot is scanned once, then reused for stream updates. */
+export function preparePerformance(messages) {
     let output = 0;
     let duration = 0;
-    let ttft = 0;
-    let ttftSamples = 0;
-    const messagesSeen = new Set();
+    let ttftSum = 0;
+    let ttftCount = 0;
+    const historical = new Map();
     for (const message of messages) {
         if (message.type !== "assistant")
             continue;
-        messagesSeen.add(message.id);
         const created = message.time?.created;
         const streamed = message.time?.streamed;
         const tokens = normalize(message.tokens);
@@ -47,23 +72,35 @@ export function historicalPerformance(messages, observations = []) {
             output += generated;
             duration += streamed - created;
         }
-        const runtime = observed.get(message.id);
-        const sample = runtime ? runtime.first - runtime.started : historicalFirst(message);
+        const sample = historicalFirst(message);
         if (sample !== undefined && finite(sample) && sample >= 0) {
-            ttft += sample;
-            ttftSamples++;
+            historical.set(message.id, sample);
+            ttftSum += sample;
+            ttftCount++;
         }
     }
-    // A live first-token event can arrive before the refreshed message snapshot.
+    return { ...(duration > 0 ? { tps: output / (duration / 1_000) } : {}), ttftSum, ttftCount, historical };
+}
+function performanceWithObservations(prepared, observations) {
+    const observed = new Map();
+    for (const sample of observations) {
+        if (finite(sample.started) && finite(sample.first) && sample.first >= sample.started)
+            observed.set(sample.messageID, sample);
+    }
+    let ttft = prepared.ttftSum;
+    let ttftSamples = prepared.ttftCount;
     for (const sample of observed.values()) {
-        if (messagesSeen.has(sample.messageID))
-            continue;
+        const old = prepared.historical.get(sample.messageID);
+        if (old !== undefined) {
+            ttft -= old;
+            ttftSamples--;
+        }
         ttft += sample.first - sample.started;
         ttftSamples++;
     }
     const result = {};
-    if (duration > 0)
-        result.tps = output / (duration / 1_000);
+    if (prepared.tps !== undefined)
+        result.tps = prepared.tps;
     if (ttftSamples > 0)
         result.ttft = ttft / ttftSamples;
     return result;
@@ -117,7 +154,8 @@ export class PerformanceMonitor {
         const now = this.now();
         const changed = new Set();
         for (const [key, step] of this.active) {
-            if (step.finishedAt !== undefined && step.finishedAt + this.retention <= now) {
+            if ((step.finishedAt ?? step.reconciledAt) !== undefined
+                && (step.finishedAt ?? step.reconciledAt) + this.retention <= now) {
                 this.active.delete(key);
                 changed.add(step.sessionID);
             }
@@ -136,8 +174,9 @@ export class PerformanceMonitor {
             return;
         let next = Infinity;
         for (const step of this.active.values()) {
-            if (step.finishedAt !== undefined)
-                next = Math.min(next, step.finishedAt + this.retention);
+            const settled = step.finishedAt ?? step.reconciledAt;
+            if (settled !== undefined)
+                next = Math.min(next, settled + this.retention);
         }
         for (const sample of this.observed.values()) {
             if (sample.expiresAt !== undefined)
@@ -175,7 +214,7 @@ export class PerformanceMonitor {
             if (this.active.has(key))
                 return false;
             this.active.set(key, {
-                messageID, sessionID, started: data.started, bytes: 0, events: new Set(),
+                messageID, sessionID, started: data.started, bytes: 0, samples: [], events: new Set(),
             });
             return false;
         }
@@ -195,6 +234,8 @@ export class PerformanceMonitor {
             const sample = this.observed.get(key);
             if (sample)
                 sample.expiresAt = step.finishedAt + this.retention;
+            if (step.reconciledAt !== undefined)
+                this.active.delete(key);
             this.scheduleCleanup();
             return false;
         }
@@ -207,7 +248,20 @@ export class PerformanceMonitor {
             return false;
         if (event.id)
             step.events.add(event.id);
-        step.bytes += new TextEncoder().encode(data.delta).byteLength;
+        if (step.reconciledAt !== undefined) {
+            // A later delta means the snapshot did not represent the final stream.
+            delete step.reconciledAt;
+            const sample = this.observed.get(key);
+            if (sample)
+                delete sample.expiresAt;
+            this.scheduleCleanup();
+        }
+        const sampleBytes = new TextEncoder().encode(data.delta).byteLength;
+        step.bytes += sampleBytes;
+        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();
         step.last = Math.max(step.last ?? event.created, event.created);
         if (step.first === undefined) {
             step.first = event.created;
@@ -225,28 +279,50 @@ export class PerformanceMonitor {
                 represented.add(message.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);
+            if (sessions.has(step.sessionID) && represented.has(step.messageID)) {
+                if (step.finishedAt !== undefined)
+                    this.active.delete(key);
+                else {
+                    // A snapshot can arrive before step.ended. Retain the step to attach
+                    // the real expiry later, and set a fallback if that event is lost.
+                    step.reconciledAt ??= this.now();
+                    const sample = this.observed.get(key);
+                    if (sample)
+                        sample.expiresAt ??= step.reconciledAt + this.retention;
+                }
+            }
         }
+        this.scheduleCleanup();
     }
     summary(messages, sessionIDs) {
+        return this.summaryPrepared(preparePerformance(messages), sessionIDs);
+    }
+    summaryPrepared(prepared, 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;
+        const result = performanceWithObservations(prepared, samples);
+        // Live throughput covers only observable deltas after the first one, over a
+        // short sliding window. TTFT keeps the started -> first wait separately, and
+        // completed provider usage still replaces this estimate via reconcile().
+        let weighted = 0;
+        let durationTotal = 0;
         for (const step of this.active.values()) {
-            if (!sessions.has(step.sessionID) || step.bytes <= 0)
+            if (!sessions.has(step.sessionID) || step.reconciledAt !== undefined)
+                continue;
+            const raw = estimatedLiveTps(step.samples);
+            if (raw === undefined)
                 continue;
-            const last = step.streamed ?? step.last;
-            if (!finite(last) || last <= step.started)
+            const first = step.samples[0];
+            const last = step.samples[step.samples.length - 1];
+            const duration = last.time - first.time;
+            if (!finite(duration) || duration <= 0)
                 continue;
-            bytes += step.bytes;
-            duration += last - step.started;
+            step.liveTps = smoothLiveTps(step.liveTps, raw);
+            weighted += step.liveTps * duration;
+            durationTotal += duration;
         }
-        if (bytes > 0 && duration > 0) {
-            result.tps = (bytes / 4) / (duration / 1_000);
+        if (durationTotal > 0) {
+            result.tps = weighted / durationTotal;
             result.tpsEstimated = true;
         }
         return result;