pi-open-tui 0.2.6 → 0.2.8

package/README.md

@@ -68,12 +68,12 @@ Run `/open-tui` to open the interactive settings UI. Configuration is stored at
 After each complete agent run, open-tui shows one transient notification. Tool-call turns are aggregated into that single result:
 
 ```text
-> TPS 42.5 tok/s | ~ TTFT 1.2s | + 29.7s | ↓ in 567 | ↑ out 1.2k | ! stall 1x / 4.3s | $ $3.60/M
+> TPS 42.5 tok/s | ~ TTFT 1.2s | + 29.7s | ↑ 567 | ↓ 1.2k | ! stall 1x / 4.3s | $ $3.60/M
 ```
 
 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 actual output delivery rate: provider-reported output tokens divided by the time from the first meaningful output delta through `message_end`. It excludes time-to-first-token and tool execution between assistant messages, but includes stalls during streaming. Multi-message and multi-turn runs sum only measurable token-duration pairs before calculating the rate, so an unmeasurable short tool response does not pollute or hide a measurable final response. Messages with fewer than two meaningful deltas or less than 200 ms of observed delivery time are shown as `TPS —` unless another measurable message exists in the run. 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/icons.ts

@@ -36,8 +36,9 @@ const NERD_GLYPHS: IconGlyphs = {
 	context: "",
 	model: "",
 	thinking: "",
-	input: "",
-	output: "",
+	// client network view: input = upload to API, output = download from API
+	input: "",
+	output: "",
 	cacheHit: "",
 	cost: "",
 	speed: "󰓅",
@@ -67,8 +68,8 @@ const ASCII_GLYPHS: IconGlyphs = {
 	context: "%",
 	model: "M",
 	thinking: "~",
-	input: "↓",
-	output: "↑",
+	input: "↑",
+	output: "↓",
 	cacheHit: "c",
 	cost: "$",
 	speed: ">",

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,9 @@ 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;
+const MIN_STREAM_UPDATES = 2;
+const MIN_MEASUREMENT_MS = 200;
 
 type TelemetryEvent =
 	| AgentStartEvent
@@ -36,26 +32,25 @@ type AssistantMessage = Extract<AgentMessage, { role: "assistant" }>;
 interface MessageTiming {
 	startMs: number;
 	lastUpdateMs: number;
-	firstUpdateSeen: boolean;
+	firstOutputMs: number | null;
 	streamUpdateCount: number;
-	firstStreamUpdateMs: number | null;
-	lastStreamUpdateMs: number | null;
 	inStall: boolean;
 }
 
+interface MessageMeasurement {
+	outputTokens: number;
+	durationMs: number;
+}
+
 interface TurnTiming {
 	startMs: number;
 	firstTokenMs: number | null;
 	currentMessage: MessageTiming | null;
 	messages: AssistantMessage[];
+	measurements: MessageMeasurement[];
 	generationMs: number;
-	streamMs: number;
-	streamIntervals: number;
-	streamUpdateCount: number;
 	stallMs: number;
 	stallCount: number;
-	isToolCall: boolean;
-	modelKey: string | null;
 }
 
 export interface TurnTelemetry {
@@ -73,6 +68,11 @@ export interface TurnTelemetry {
 	measurementMs: number | null;
 }
 
+interface MeasuredTurn {
+	telemetry: TurnTelemetry;
+	measuredOutputTokens: number;
+}
+
 function isAssistantMessage(message: AgentMessage): message is AssistantMessage {
 	return message.role === "assistant";
 }
@@ -84,10 +84,9 @@ 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[] = [];
+	private agentTurns: MeasuredTurn[] = [];
 
 	constructor(now: () => number = () => performance.now()) {
 		this.now = now;
@@ -116,7 +115,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();
@@ -129,14 +127,10 @@ export class TurnTelemetryTracker {
 			firstTokenMs: null,
 			currentMessage: null,
 			messages: [],
+			measurements: [],
 			generationMs: 0,
-			streamMs: 0,
-			streamIntervals: 0,
-			streamUpdateCount: 0,
 			stallMs: 0,
 			stallCount: 0,
-			isToolCall: false,
-			modelKey: null,
 		};
 	}
 
@@ -146,13 +140,10 @@ export class TurnTelemetryTracker {
 		this.turn.currentMessage = {
 			startMs: now,
 			lastUpdateMs: now,
-			firstUpdateSeen: false,
+			firstOutputMs: null,
 			streamUpdateCount: 0,
-			firstStreamUpdateMs: null,
-			lastStreamUpdateMs: null,
 			inStall: false,
 		};
-		this.turn.modelKey ??= `${message.provider}:${message.model}`;
 	}
 
 	private updateMessage(event: MessageUpdateEvent): void {
@@ -169,16 +160,15 @@ 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.streamUpdateCount = 1;
 			current.lastUpdateMs = now;
 			return;
 		}
 
 		current.streamUpdateCount++;
-		current.firstStreamUpdateMs ??= now;
-		current.lastStreamUpdateMs = now;
 
 		const gap = now - current.lastUpdateMs;
 		if (gap >= STALL_THRESHOLD_MS) {
@@ -197,26 +187,31 @@ 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 - current.startMs;
+			if (current.firstOutputMs === null && message.usage.output > 0) {
+				turn.firstTokenMs ??= endMs;
+			}
+			const measurementMs = current.firstOutputMs === null ? 0 : endMs - current.firstOutputMs;
+			if (
+				message.usage.output > 0 &&
+				current.streamUpdateCount >= MIN_STREAM_UPDATES &&
+				measurementMs >= MIN_MEASUREMENT_MS
+			) {
+				turn.measurements.push({ outputTokens: message.usage.output, durationMs: measurementMs });
 			}
 			turn.currentMessage = null;
 		}
 		turn.messages.push(message);
-		turn.modelKey ??= `${message.provider}:${message.model}`;
 	}
 
 	private endTurnAndCollect(): TurnTelemetry | undefined {
-		const telemetry = this.endTurn();
-		if (telemetry && this.agentStartMs !== null) this.agentTurns.push(telemetry);
-		return telemetry;
+		const result = this.endTurn();
+		if (result && this.agentStartMs !== null) this.agentTurns.push(result);
+		return result?.telemetry;
 	}
 
-	private endTurn(): TurnTelemetry | undefined {
+	private endTurn(): MeasuredTurn | undefined {
 		const turn = this.turn;
 		this.turn = undefined;
 		if (!turn || turn.firstTokenMs === null || turn.messages.length === 0) return;
@@ -235,66 +230,33 @@ 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 measuredOutputTokens = turn.measurements.reduce((sum, measurement) => sum + measurement.outputTokens, 0);
+		const measuredMs = turn.measurements.reduce((sum, measurement) => sum + measurement.durationMs, 0);
+		const measurementMs = measuredMs > 0 ? measuredMs : null;
+		const tps = measurementMs === null
+			? null
+			: round(measuredOutputTokens / (measurementMs / 1000), 1);
 		const validCost = Number.isFinite(costUsd) && costUsd > 0;
 		const validTokens = Number.isFinite(totalTokens) && totalTokens > 0;
 		return {
-			tps,
-			ttftMs: turn.firstTokenMs - turn.startMs,
-			totalMs: endMs - turn.startMs,
-			inputTokens,
-			outputTokens,
-			stallMs: turn.stallMs,
-			stallCount: turn.stallCount,
-			rateUsdPerMTokens: validCost && validTokens
-				? round(costUsd / (totalTokens / 1_000_000), 2)
-				: null,
-			generationMs: turn.generationMs,
-			totalTokens,
-			costUsd: validCost ? costUsd : 0,
-			measurementMs,
+			telemetry: {
+				tps,
+				ttftMs: turn.firstTokenMs - turn.startMs,
+				totalMs: endMs - turn.startMs,
+				inputTokens,
+				outputTokens,
+				stallMs: turn.stallMs,
+				stallCount: turn.stallCount,
+				rateUsdPerMTokens: validCost && validTokens
+					? round(costUsd / (totalTokens / 1_000_000), 2)
+					: null,
+				generationMs: turn.generationMs,
+				totalTokens,
+				costUsd: validCost ? costUsd : 0,
+				measurementMs,
+			},
+			measuredOutputTokens,
 		};
 	}
 
@@ -305,33 +267,29 @@ export class TurnTelemetryTracker {
 		this.agentTurns = [];
 		if (startMs === null || turns.length === 0) return;
 
-		const outputTokens = turns.reduce((sum, turn) => sum + turn.outputTokens, 0);
-		const inputTokens = turns.reduce((sum, turn) => sum + turn.inputTokens, 0);
-		const totalTokens = turns.reduce((sum, turn) => sum + turn.totalTokens, 0);
-		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 outputTokens = turns.reduce((sum, turn) => sum + turn.telemetry.outputTokens, 0);
+		const inputTokens = turns.reduce((sum, turn) => sum + turn.telemetry.inputTokens, 0);
+		const totalTokens = turns.reduce((sum, turn) => sum + turn.telemetry.totalTokens, 0);
+		const costUsd = turns.reduce((sum, turn) => sum + turn.telemetry.costUsd, 0);
+		const stallMs = turns.reduce((sum, turn) => sum + turn.telemetry.stallMs, 0);
+		const stallCount = turns.reduce((sum, turn) => sum + turn.telemetry.stallCount, 0);
+		const measuredOutputTokens = turns.reduce((sum, turn) => sum + turn.measuredOutputTokens, 0);
+		const measuredMs = turns.reduce((sum, turn) => sum + (turn.telemetry.measurementMs ?? 0), 0);
+		const measurementMs = measuredMs > 0 ? measuredMs : null;
+		const tps = measurementMs === null
+			? null
+			: round(measuredOutputTokens / (measurementMs / 1000), 1);
 		const validRate = costUsd > 0 && totalTokens > 0;
 		return {
-			tps: boundedTps,
-			ttftMs: turns[0]!.ttftMs,
+			tps,
+			ttftMs: turns[0]!.telemetry.ttftMs,
 			totalMs: this.now() - startMs,
 			inputTokens,
 			outputTokens,
 			stallMs,
 			stallCount,
 			rateUsdPerMTokens: validRate ? round(costUsd / (totalTokens / 1_000_000), 2) : null,
-			generationMs: turns.reduce((sum, turn) => sum + turn.generationMs, 0),
+			generationMs: turns.reduce((sum, turn) => sum + turn.telemetry.generationMs, 0),
 			totalTokens,
 			costUsd,
 			measurementMs,
@@ -362,8 +320,8 @@ export function formatTurnTelemetry(
 		parts.push(theme.fg("success", `${glyphs.done} ${formatTurnDuration(telemetry.totalMs)}`));
 	}
 	if (config.tokens) {
-		parts.push(theme.fg("accent", `${glyphs.input} in ${fmtTokens(telemetry.inputTokens)}`));
-		parts.push(theme.fg("success", `${glyphs.output} out ${fmtTokens(telemetry.outputTokens)}`));
+		parts.push(theme.fg("accent", `${glyphs.input} ${fmtTokens(telemetry.inputTokens)}`));
+		parts.push(theme.fg("success", `${glyphs.output} ${fmtTokens(telemetry.outputTokens)}`));
 	}
 	if (config.stalls && telemetry.stallMs > 0) {
 		parts.push(theme.fg("warning", `${glyphs.stall} stall ${telemetry.stallCount}x / ${formatTurnDuration(telemetry.stallMs)}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-open-tui",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "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": {