@pi-unipi/footer 2.12.0 → 2.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/footer",
-  "version": "2.12.0",
+  "version": "2.12.1",
   "description": "Persistent status bar for Unipi — subscribes to UNIPI_EVENTS and renders key stats from all unipi packages",
   "type": "module",
   "main": "index.ts",

package/src/index.ts

@@ -235,12 +235,6 @@ function setupFooterUI(pi: ExtensionAPI, ctx: ExtensionContext, state: FooterSta
             // Branch-derived tool time: pending callId → assistant msg ts.
             const pendingToolCalls = new Map<string, number>();
             let branchToolMs = 0;
-            // Per-assistant-message duration (this assistant ts → next entry
-            // ts): the honest generation+tool window, replaces first-scan
-            // reconstruction for restart tok/s.
-            const recordDurations = new Map<number, number>();
-            let prevEntryTs = 0;
-            let prevAssistantIdx = -1;
             for (const e of events) {
               if (!e || typeof e !== "object") continue;
               if (e.type !== "message") continue;
@@ -249,12 +243,6 @@ function setupFooterUI(pi: ExtensionAPI, ctx: ExtensionContext, state: FooterSta
               // Branch-derived turn/wall accounting: user messages delimit
               // turns; assistant timestamps bound the session wall time.
               const ts = Date.parse((e as any).timestamp ?? "") || 0;
-              // Close the previous assistant's window with this entry's ts.
-              if (prevAssistantIdx >= 0 && ts > 0 && prevEntryTs > 0) {
-                recordDurations.set(prevAssistantIdx, Math.min(ts - prevEntryTs, 600_000));
-                prevAssistantIdx = -1;
-              }
-              if (ts > 0) prevEntryTs = ts;
               if (m.role === "user") {
                 userCount++;
                 continue;
@@ -274,7 +262,6 @@ function setupFooterUI(pi: ExtensionAPI, ctx: ExtensionContext, state: FooterSta
               if (ts > 0) {
                 if (firstAssistantTs === 0 || ts < firstAssistantTs) firstAssistantTs = ts;
                 if (ts > lastAssistantTs) lastAssistantTs = ts;
-                prevAssistantIdx = msgIndex; // close on next entry
               }
               const hasStop = !!m.stopReason;
               // Pass the whole message: completed messages get anchored to
@@ -301,7 +288,11 @@ function setupFooterUI(pi: ExtensionAPI, ctx: ExtensionContext, state: FooterSta
               msgIndex++;
             }
             tpsTracker.syncBranchStats(userCount, msgIndex);
-            if (recordDurations.size > 0) tpsTracker.syncRecordDurations(recordDurations);
+            // NOTE: no per-record duration seeding here on purpose. Timestamps
+            // alone cannot mark stream END — a 'next-entry' delta would include
+            // tool runs + user think-time inside the rate window (the bug that
+            // made 100-tok/s models read ~7 tok/s). AVG now uses only
+            // hook-measured decode windows; see getSessionAvgTps().
             if (lastAssistantTs > firstAssistantTs) {
               tpsTracker.syncWallMs(lastAssistantTs - firstAssistantTs);
             }

package/src/tps-tracker.ts

@@ -56,8 +56,16 @@ interface MessageTpsRecord {
 	requestAt: number;
 	/** When OUTPUT GENERATION started (ms). First non-empty delta. */
 	startedAt: number;
+	/** True once a live streaming delta was observed (window is hook-measured). */
+	sawFirstDelta: boolean;
 	/** When generation completed (ms), 0 if still generating. */
 	completedAt: number;
+	/**
+	 * MEASURED output-only decode window (first delta → stream end, ms).
+	 * 0 when never measured — such records are excluded from the session
+	 * average (deepseek-harness rule: unmeasurable steps drop out).
+	 */
+	decodeMs: number;
 	/** Final TPS for this message (once completed). */
 	tps: number;
 }
@@ -141,7 +149,10 @@ function estimateOutputTokens(message: unknown): number {
 			}
 		}
 	}
-	return estimateTokens(String(chars)); // ceil(chars/4) via single call
+	// FIXED: was estimateTokens(String(chars)) — that divided the DIGIT COUNT
+	// of the number (String(8000).length === 4) by 4, collapsing an 8000-char
+	// response into 1 "token". Divide the actual char count instead.
+	return Math.ceil(chars / CHARS_PER_TOKEN);
 }
 
 /**
@@ -202,7 +213,9 @@ export class TpsTracker {
 				anchored: false,
 				requestAt: this.lastTurnStart,
 				startedAt: 0,
+				sawFirstDelta: false,
 				completedAt: 0,
+			decodeMs: 0,
 				tps: 0,
 			});
 		}
@@ -215,7 +228,9 @@ export class TpsTracker {
 			// record inherits the current open-turn start as its TTFT bound.
 			requestAt: this.lastTurnStart,
 			startedAt: 0,
+			sawFirstDelta: false,
 			completedAt: 0,
+			decodeMs: 0,
 			tps: 0,
 		});
 	}
@@ -252,6 +267,7 @@ export class TpsTracker {
 				this.ttftHookSamples += 1;
 			}
 		}
+		record.sawFirstDelta = true; // window becomes hook-measured
 		record.estimatedTokens += deltaContribution(deltaText);
 		record.tokens = record.estimatedTokens;
 	}
@@ -279,10 +295,19 @@ export class TpsTracker {
 			// provider message timestamp so the window is still output-ish.
 			record.startedAt =
 				messageTimestamp(finalMessage) || record.completedAt - 500;
-		}		const durationSec = Math.max(
+		}
+		const durationSec = Math.max(
 			(record.completedAt - record.startedAt) / 1000,
 			0.05,
 		);
+		// decodeMs is the measured output-only window ONLY when live hooks saw
+		// both bounds; scan-reconstructed windows stay 0 → excluded from AVG.
+		if (record.sawFirstDelta && record.startedAt > 0) {
+			const ms = Math.max(1, record.completedAt - record.startedAt);
+			// Guard: a hook-measured window should never be absurdly long —
+			// keep an over-flow safety cap far above any real generation.
+			record.decodeMs = Math.min(ms, 3600_000);
+		}
 		record.tps = record.tokens > 0 ? record.tokens / durationSec : 0;
 		this.totalOutput += record.tokens;
 		this.pendingChars.delete(messageIndex);
@@ -392,7 +417,9 @@ export class TpsTracker {
 					anchored: false,
 					requestAt: this.lastTurnStart,
 					startedAt: 0,
+					sawFirstDelta: false,
 					completedAt: 0,
+			decodeMs: 0,
 					tps: 0,
 				});
 			}
@@ -436,49 +463,33 @@ export class TpsTracker {
 		return 0;
 	}
 
-	/** Session average TPS across completed + current generation windows. */
-	/**
-	 * Honest per-record duration override from branch order: a persisted
-	 * assistant message ended by the time the NEXT entry arrived. Feeding
-	 * these durations replaces first-scan-sighting reconstruction (which made
-	 * every historical message look 10 min long → tok/s ≈ 0).
-	 */
-	syncRecordDurations(durations: Map<number, number>): void {
-		for (const [idx, durMs] of durations) {
-			const r = this.records[idx];
-			if (!r || r.completedAt === 0 || !r.startedAt) continue;
-			const sec = Math.max(0.05, Math.min(durMs / 1000, TpsTracker.MAX_RECORD_DURATION_SEC));
-			// Recompute this record's tps contribution lazily via tokens/duration
-			r.tps = sec > 0 ? r.tokens / sec : r.tps;
-			(r as unknown as { forcedDurationSec?: number }).forcedDurationSec = sec;
-		}
-	}
-
 	/** Session average TPS across completed + current generation windows.
 	 *
-	 * Scan-reconciled OLD messages (after restart/reload) can yield absurd
-	 * durations: startedAt comes from the provider timestamp, completedAt
-	 * from 'first time our scanner saw it' = now — i.e. minutes/hours for a
-	 * message that generated in seconds. Each record's duration is therefore
-	 * clamped to MAX_RECORD_DURATION_SEC before averaging; syncRecordDurations
-	 * supersedes the clamp with real next-entry deltas when available.
+	 * Deepseek-harness contract (projection.ts): throughput =
+	 * Σ decodeTokens ÷ Σ decodeMs, sampled ONLY over steps whose decode
+	 * window was actually measured (first delta → stream end by live hooks).
+	 * Steps without a measured window drop out of the average entirely.
+	 *
+	 * Scan-reconciled OLD messages (after restart/reload) previously entered
+	 * this average with fabricated durations: startedAt from the provider
+	 * timestamp, completedAt from 'when our scanner first saw it' (minutes
+	 * late), or worse a 'next-entry-ts' window that silently includes tool
+	 * runs and user think-time. That made a 100 tok/s model read ~7 tok/s.
+	 * We now honor the same rule as the harness: unmeasurable steps are
+	 * EXCLUDED, never averaged in with invented durations.
 	 */
-	private static readonly MAX_RECORD_DURATION_SEC = 600;
-
 	getSessionAvgTps(): number {
-		const cap = TpsTracker.MAX_RECORD_DURATION_SEC;
 		let totalTokens = 0;
 		let totalDurationSec = 0;
 		for (const r of this.records) {
-			if (r.completedAt > 0 && r.startedAt > 0) {
+			if (r.completedAt > 0 && r.startedAt > 0 && r.decodeMs > 0) {
+				// Measured output-only window (live streaming hooks).
 				totalTokens += r.tokens;
-				// Branch-derived duration wins; fallback reconstructs from
-				// startedAt→completedAt clamped at the cap.
-				const forced = (r as unknown as { forcedDurationSec?: number }).forcedDurationSec;
-				totalDurationSec += forced ?? Math.min((r.completedAt - r.startedAt) / 1000, cap);
+				totalDurationSec += r.decodeMs / 1000;
 			} else if (r.completedAt === 0 && r.startedAt > 0) {
+				// Open generation window: contribute what's elapsed so far.
 				totalTokens += r.tokens;
-				totalDurationSec += Math.min((Date.now() - r.startedAt) / 1000, cap);
+				totalDurationSec += Math.max(0.05, (Date.now() - r.startedAt) / 1000);
 			}
 		}
 		if (totalDurationSec <= 0) return 0;