pi-open-tui 0.2.7 → 0.2.9

package/README.md

@@ -73,7 +73,7 @@ After each complete agent run, open-tui shows one transient notification. Tool-c
 
 The notification uses the footer's icon mode and semantic theme colors. Configure its master switch and individual TPS, TTFT, duration, token, stall, and cost segments from the **Telemetry** tab in `/open-tui`.
 
-TPS excludes time-to-first-token, detected stalls, and tool execution between messages. In a multi-turn agent run, it is weighted from the turns with measurable streaming spans; an unmeasurable tool turn no longer hides a measurable final response. A rate that cannot be identified reliably is shown as `TPS —`. The `stall` segment shows occurrence count followed by accumulated duration. The optional `$ / M` value uses the model's list-price `usage.cost.total`; it is not the session's cumulative cost shown in the footer.
+TPS is the complete generation throughput for the agent run: all provider-reported assistant output tokens divided by the summed generation time of every LLM turn, measured from `turn_start` through the assistant `message_end`. This includes time-to-first-token, hidden reasoning, buffering, and stalls so the token count and timing cover the same interval. Tool execution between turns is excluded. A run with no output tokens or no measurable generation time is shown as `TPS —`. The `stall` segment shows occurrence count followed by accumulated duration. The optional `$ / M` value uses the model's list-price `usage.cost.total`; it is not the session's cumulative cost shown in the footer.
 
 ## Local development
 
@@ -95,3 +95,5 @@ This project builds on the work of several Pi community packages:
 - **[pi-tps](https://github.com/monotykamary/pi-tps)** — the turn timing, stall detection, and conservative TPS measurement approach
 
 The animated logo frames are derived from `pi-claude-code-tui`, which in turn derive from Pi's official install script (`pi.dev/install.sh`). The runtime detection list and git porcelain parsing borrow structure from `pi-zentui`.
+
+Special thanks to the **[LINUX DO](https://linux.do)** community for their support.

package/extensions/open-tui/settings-command.ts

@@ -144,16 +144,22 @@ class SettingsUi implements SettingsUiHandle {
 	private selectList: SelectList;
 	private readonly selectedItemByTab: Partial<Record<Tab, string>> = {};
 	private readonly container: Box;
+	private readonly theme: Theme;
+	private readonly onChange: (config: OpenTuiConfig) => void;
+	private readonly onClose: () => void;
 	private cachedWidth: number | undefined;
 	private cachedLines: string[] | undefined;
 
 	constructor(
-		private readonly theme: Theme,
+		theme: Theme,
 		config: OpenTuiConfig,
-		private readonly onChange: (config: OpenTuiConfig) => void,
-		private readonly onClose: () => void,
+		onChange: (config: OpenTuiConfig) => void,
+		onClose: () => void,
 	) {
+		this.theme = theme;
 		this.config = config;
+		this.onChange = onChange;
+		this.onClose = onClose;
 		this.container = new Box(1, 1, (s: string) => theme.bg("customMessageBg", s));
 		this.selectList = new SelectList([], 12, {
 			selectedPrefix: (t) => theme.fg("accent", t),

package/extensions/open-tui/telemetry.ts

@@ -13,13 +13,7 @@ import type { IconMode, TelemetryConfig } from "./config.ts";
 import { resolveGlyphs } from "./icons.ts";
 import { fmtTokens, formatDuration } from "./utils.ts";
 
-const STALL_THRESHOLD_MS = 500;
-const MIN_STREAM_MS = 1;
-const MIN_STREAM_UPDATES = 5;
-const MIN_INTER_CHUNK_MS = 1;
-const MIN_GENERATION_MS = 200;
-const STALL_DOMINANCE_RATIO = 0.85;
-const MAX_PLAUSIBLE_TPS = 10_000;
+const STALL_THRESHOLD_MS = 1000;
 
 type TelemetryEvent =
 	| AgentStartEvent
@@ -34,12 +28,8 @@ type AgentMessage = MessageStartEvent["message"];
 type AssistantMessage = Extract<AgentMessage, { role: "assistant" }>;
 
 interface MessageTiming {
-	startMs: number;
 	lastUpdateMs: number;
-	firstUpdateSeen: boolean;
-	streamUpdateCount: number;
-	firstStreamUpdateMs: number | null;
-	lastStreamUpdateMs: number | null;
+	firstOutputMs: number | null;
 	inStall: boolean;
 }
 
@@ -49,13 +39,8 @@ interface TurnTiming {
 	currentMessage: MessageTiming | null;
 	messages: AssistantMessage[];
 	generationMs: number;
-	streamMs: number;
-	streamIntervals: number;
-	streamUpdateCount: number;
 	stallMs: number;
 	stallCount: number;
-	isToolCall: boolean;
-	modelKey: string | null;
 }
 
 export interface TurnTelemetry {
@@ -84,7 +69,6 @@ function round(value: number, decimals: number): number {
 
 export class TurnTelemetryTracker {
 	private readonly now: () => number;
-	private readonly tpsCaps = new Map<string, number>();
 	private turn: TurnTiming | undefined;
 	private agentStartMs: number | null = null;
 	private agentTurns: TurnTelemetry[] = [];
@@ -116,7 +100,6 @@ export class TurnTelemetryTracker {
 				this.endMessage(event.message);
 				return;
 			case "tool_execution_start":
-				if (this.turn) this.turn.isToolCall = true;
 				return;
 			case "turn_end":
 				return this.endTurnAndCollect();
@@ -130,13 +113,8 @@ export class TurnTelemetryTracker {
 			currentMessage: null,
 			messages: [],
 			generationMs: 0,
-			streamMs: 0,
-			streamIntervals: 0,
-			streamUpdateCount: 0,
 			stallMs: 0,
 			stallCount: 0,
-			isToolCall: false,
-			modelKey: null,
 		};
 	}
 
@@ -144,15 +122,10 @@ export class TurnTelemetryTracker {
 		if (!this.turn || !isAssistantMessage(message)) return;
 		const now = this.now();
 		this.turn.currentMessage = {
-			startMs: now,
 			lastUpdateMs: now,
-			firstUpdateSeen: false,
-			streamUpdateCount: 0,
-			firstStreamUpdateMs: null,
-			lastStreamUpdateMs: null,
+			firstOutputMs: null,
 			inStall: false,
 		};
-		this.turn.modelKey ??= `${message.provider}:${message.model}`;
 	}
 
 	private updateMessage(event: MessageUpdateEvent): void {
@@ -169,17 +142,13 @@ export class TurnTelemetryTracker {
 		if (!turn || !current || !isAssistantMessage(message)) return;
 
 		const now = this.now();
-		if (!current.firstUpdateSeen) {
-			current.firstUpdateSeen = true;
+		if (current.firstOutputMs === null) {
+			current.firstOutputMs = now;
 			turn.firstTokenMs ??= now;
 			current.lastUpdateMs = now;
 			return;
 		}
 
-		current.streamUpdateCount++;
-		current.firstStreamUpdateMs ??= now;
-		current.lastStreamUpdateMs = now;
-
 		const gap = now - current.lastUpdateMs;
 		if (gap >= STALL_THRESHOLD_MS) {
 			if (!current.inStall) turn.stallCount++;
@@ -197,17 +166,14 @@ export class TurnTelemetryTracker {
 
 		const current = turn.currentMessage;
 		if (current) {
-			turn.generationMs += this.now() - current.startMs;
-			turn.streamUpdateCount += current.streamUpdateCount;
-			turn.streamIntervals += Math.max(0, current.streamUpdateCount - 1);
-			// Sum per-message spans so tool execution between messages never enters TPS.
-			if (current.firstStreamUpdateMs !== null && current.lastStreamUpdateMs !== null) {
-				turn.streamMs += current.lastStreamUpdateMs - current.firstStreamUpdateMs;
+			const endMs = this.now();
+			turn.generationMs = endMs - turn.startMs;
+			if (current.firstOutputMs === null && message.usage.output > 0) {
+				turn.firstTokenMs ??= endMs;
 			}
 			turn.currentMessage = null;
 		}
 		turn.messages.push(message);
-		turn.modelKey ??= `${message.provider}:${message.model}`;
 	}
 
 	private endTurnAndCollect(): TurnTelemetry | undefined {
@@ -235,49 +201,11 @@ export class TurnTelemetryTracker {
 		if (![inputTokens, outputTokens, totalTokens, costUsd].every(Number.isFinite)) {
 			throw new Error("Invalid assistant usage in turn telemetry");
 		}
-		if (outputTokens <= 0 || !turn.modelKey) return;
-
-		const streamMs = turn.streamUpdateCount > 0 ? turn.streamMs : null;
-		const averageGapMs = turn.streamIntervals > 0 ? turn.streamMs / turn.streamIntervals : 0;
-		let tps: number | null = null;
-		let measurementMs: number | null = null;
-		let primary = false;
-		if (
-			streamMs !== null &&
-			streamMs >= MIN_STREAM_MS &&
-			turn.streamUpdateCount >= MIN_STREAM_UPDATES &&
-			averageGapMs >= MIN_INTER_CHUNK_MS &&
-			turn.stallMs < streamMs &&
-			streamMs - turn.stallMs >= MIN_GENERATION_MS &&
-			turn.stallMs < streamMs - turn.stallMs
-		) {
-			measurementMs = streamMs - turn.stallMs;
-			tps = round(outputTokens / (measurementMs / 1000), 1);
-			primary = true;
-		} else if (turn.streamUpdateCount >= 2 && turn.generationMs >= MIN_GENERATION_MS) {
-			let activeMs = turn.generationMs - turn.stallMs;
-			if (activeMs < MIN_GENERATION_MS || turn.stallMs > turn.generationMs * STALL_DOMINANCE_RATIO) {
-				activeMs = turn.generationMs - turn.stallMs / 2;
-			}
-			measurementMs = Math.max(activeMs, MIN_GENERATION_MS);
-			tps = round(outputTokens / (measurementMs / 1000), 1);
-		}
-
-		if (tps !== null && tps > MAX_PLAUSIBLE_TPS) {
-			tps = null;
-			measurementMs = null;
-			primary = false;
-		}
-		if (primary && tps !== null) {
-			this.tpsCaps.set(turn.modelKey, Math.max(tps, this.tpsCaps.get(turn.modelKey) ?? 0));
-		}
-		if (turn.isToolCall && tps !== null) {
-			tps = this.tpsCaps.has(turn.modelKey)
-				? Math.min(tps, this.tpsCaps.get(turn.modelKey)!)
-				: null;
-			if (tps === null) measurementMs = null;
-		}
 
+		const measurementMs = outputTokens > 0 && turn.generationMs > 0 ? turn.generationMs : null;
+		const tps = measurementMs === null
+			? null
+			: round(outputTokens / (measurementMs / 1000), 1);
 		const validCost = Number.isFinite(costUsd) && costUsd > 0;
 		const validTokens = Number.isFinite(totalTokens) && totalTokens > 0;
 		return {
@@ -311,19 +239,14 @@ export class TurnTelemetryTracker {
 		const costUsd = turns.reduce((sum, turn) => sum + turn.costUsd, 0);
 		const stallMs = turns.reduce((sum, turn) => sum + turn.stallMs, 0);
 		const stallCount = turns.reduce((sum, turn) => sum + turn.stallCount, 0);
-		const measuredTurns = turns.filter((turn) => turn.measurementMs !== null);
-		const measuredOutputTokens = measuredTurns.reduce((sum, turn) => sum + turn.outputTokens, 0);
-		const measurementMs = measuredTurns.length > 0
-			? measuredTurns.reduce((sum, turn) => sum + turn.measurementMs!, 0)
-			: null;
-		const tps =
-			measurementMs !== null && measurementMs >= MIN_GENERATION_MS
-				? round(measuredOutputTokens / (measurementMs / 1000), 1)
-				: null;
-		const boundedTps = tps !== null && tps <= MAX_PLAUSIBLE_TPS ? tps : null;
+		const generationMs = turns.reduce((sum, turn) => sum + turn.generationMs, 0);
+		const measurementMs = outputTokens > 0 && generationMs > 0 ? generationMs : null;
+		const tps = measurementMs === null
+			? null
+			: round(outputTokens / (measurementMs / 1000), 1);
 		const validRate = costUsd > 0 && totalTokens > 0;
 		return {
-			tps: boundedTps,
+			tps,
 			ttftMs: turns[0]!.ttftMs,
 			totalMs: this.now() - startMs,
 			inputTokens,
@@ -331,7 +254,7 @@ export class TurnTelemetryTracker {
 			stallMs,
 			stallCount,
 			rateUsdPerMTokens: validRate ? round(costUsd / (totalTokens / 1_000_000), 2) : null,
-			generationMs: turns.reduce((sum, turn) => sum + turn.generationMs, 0),
+			generationMs,
 			totalTokens,
 			costUsd,
 			measurementMs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-open-tui",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "A polished TUI for Pi coding agent: animated logo header, Starship-style footer, rounded editor with model metadata, and prompt-box user messages. Combines the best of pi-haiku, pi-claude-code-tui, and pi-zentui.",
   "type": "module",
   "repository": {
@@ -24,7 +24,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node --test --experimental-transform-types tests/settings-command.test.ts tests/footer.test.ts tests/editor.test.ts tests/telemetry.test.ts",
+    "test": "node --test tests/settings-command.test.ts tests/footer.test.ts tests/editor.test.ts tests/telemetry.test.ts",
     "typecheck": "tsc --noEmit"
   },
   "pi": {