@d3ara1n/pi-editor-shell 0.9.0 → 0.9.1

package/README.md

@@ -7,7 +7,7 @@ Replaces pi's default editor and status bar with a unified rounded-corner shell
 ## What shows up where
 
 - **Top border** — `  model ·  thinking-level ` (left) + pinned extension statuses (right, via `pinnedStatus` config)
-- **Bottom border** — `  ctx NN%/NNk|N.NM · ⚡ cacheRead (total)  hitRate% · NN.N t/s · $N.NNN ` (left) + `  ~/Projects (main +2 ~1 *4) ` (right, shows git branch plus staged, unstaged, and untracked file counts when in a repo). TPS is measured for the latest completed response from its first streamed content delta, excluding time-to-first-token. Session cost includes assistant, tool, compaction, and branch-summary usage; the dollar segment is hidden when the provider reports no priced usage. Session hit rate via `/editor-shell:status`.
+- **Bottom border** — `  ctx NN%/NNk|N.NM · ⚡ cacheRead (total)  hitRate% · NN.N t/s · $N.NNN ` (left) + `  ~/Projects (main +2 ~1 *4) ` (right, shows git branch plus staged, unstaged, and untracked file counts when in a repo). TPS is client-observed visible-text throughput for the latest reliable completed response: `(visible output tokens - 1) / (last text delta - first text delta)`, excluding time-to-first-token and provider-reported reasoning tokens. Responses containing tool calls, failed/aborted responses, samples below 10 visible tokens, and samples shorter than 250 ms do not replace the last valid TPS. Providers without a reasoning-token breakdown may still include hidden reasoning in the count. Session cost includes assistant, tool, compaction, and branch-summary usage; the dollar segment is hidden when the provider reports no priced usage. Session hit rate via `/editor-shell:status`.
 - **Below shell** — Auto-wrapping extension status line (all `setStatus` entries not pinned to the top)
 - **Border color** follows pi's thinking-level / bash-mode indicator automatically.
 
@@ -54,8 +54,8 @@ How the model is labeled in the top-left border (`"name"` by default):
 
 | Value | Example |
 |-------|---------|
-| `"name"` (default) | `Claude Opus 4.8 (Yanproxy)` |
-| `"provider-id"` | `yanproxy/anthropic/claude-opus-4-8` |
+| `"name"` (default) | `Claude Opus 4.8` |
+| `"provider-id"` | `anthropic/claude-opus-4-8` |
 
 `"name"` uses `model.name`; a model with no name falls back to its id, so the slot never goes blank.
 
@@ -63,7 +63,7 @@ How the model is labeled in the top-left border (`"name"` by default):
 
 | Command | Description |
 |---------|-------------|
-| `/editor-shell:status` | Show debug info: pinned config, all extension statuses with their keys, cache totals, latest response TPS, and session cost |
+| `/editor-shell:status` | Show debug info: pinned config, all extension statuses with their keys, cache totals, latest reliable visible-text TPS, and session cost |
 
 ## How it works
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-editor-shell",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "type": "module",
   "description": "Replaces pi's default editor and status bar with a unified rounded-corner shell embedding status info in the border",
   "keywords": [

package/src/index.ts

@@ -5,6 +5,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { CardEditor, type FrameProvider, type SpinnerPhase } from "./card-editor.ts";
 import { DEFAULT_CONFIG, loadEditorShellConfig, type EditorShellConfig, type EditorShellIcons } from "./config.ts";
+import { calculateVisibleTextTps } from "./tps.ts";
 
 /**
  * pi-editor-shell — Replaces pi's default editor and status bar with a
@@ -75,6 +76,7 @@ const DEFAULT_ICONS: EditorShellIcons = {
 interface UsageSnap {
   input?: number;
   output?: number;
+  reasoning?: number;
   cacheRead?: number;
   cacheWrite?: number;
   cost?: {
@@ -83,7 +85,9 @@ interface UsageSnap {
 }
 interface MsgSnap {
   role: string;
+  content?: Array<{ type: string }>;
   usage?: UsageSnap;
+  stopReason?: string;
 }
 interface EntrySnap {
   type: string;
@@ -284,11 +288,11 @@ export default function (pi: ExtensionAPI) {
   // entries every frame.
   let _cacheTotal = 0;
   let _latestUsage: UsageSnap | undefined;
-  // Latest completed response throughput. Timing begins with the first streamed
-  // content delta, excluding time-to-first-token; it is intentionally not
-  // reconstructed for resumed sessions because persisted messages have no end time.
-  let _streamStartedAt: number | undefined;
-  let _pendingResponseElapsedMs: number | undefined;
+  // Latest reliable client-observed text throughput. TTFT is excluded; tool-call,
+  // failed, and statistically tiny responses do not replace the last valid sample.
+  // Persisted messages have no delta timestamps, so resumed sessions start empty.
+  let _firstTextDeltaAt: number | undefined;
+  let _lastTextDeltaAt: number | undefined;
   let _latestTps: number | undefined;
   // Full-session billable cost, including tool/summarization usage. Zero means the
   // provider supplied no priced usage, so the border omits the dollar segment.
@@ -299,17 +303,16 @@ export default function (pi: ExtensionAPI) {
   // a same-phase no-op, so rapid event streams never reset the animation.
   pi.on("message_start", (event) => {
     if (event.message.role !== "assistant") return;
-    _streamStartedAt = undefined;
-    _pendingResponseElapsedMs = undefined;
+    _firstTextDeltaAt = undefined;
+    _lastTextDeltaAt = undefined;
   });
   pi.on("turn_start", () => editor?.setSpinner("thinking"));
   pi.on("message_update", (event) => {
     const t = event.assistantMessageEvent.type;
-    if (
-      _streamStartedAt == null &&
-      (t === "thinking_delta" || t === "text_delta" || t === "toolcall_delta")
-    ) {
-      _streamStartedAt = Date.now();
+    if (t === "text_delta") {
+      const now = performance.now();
+      _firstTextDeltaAt ??= now;
+      _lastTextDeltaAt = now;
     }
     let next: SpinnerPhase;
     if (t.startsWith("thinking_")) next = "thinking";
@@ -318,12 +321,6 @@ export default function (pi: ExtensionAPI) {
     else return;
     editor?.setSpinner(next);
   });
-  pi.on("message_end", (event) => {
-    if (event.message.role !== "assistant") return;
-    const elapsedMs = _streamStartedAt == null ? 0 : Date.now() - _streamStartedAt;
-    _pendingResponseElapsedMs = elapsedMs > 0 ? elapsedMs : undefined;
-    _streamStartedAt = undefined;
-  });
   pi.on("tool_execution_start", () => editor?.setSpinner("exec"));
   pi.on("agent_end", (_event, ctx) => {
     // cacheRead totals + latest usage are stable once a turn finishes —
@@ -334,8 +331,8 @@ export default function (pi: ExtensionAPI) {
     editor?.setSpinner(null);
   });
   pi.on("session_shutdown", () => {
-    _streamStartedAt = undefined;
-    _pendingResponseElapsedMs = undefined;
+    _firstTextDeltaAt = undefined;
+    _lastTextDeltaAt = undefined;
     _latestTps = undefined;
     _sessionCost = 0;
     editor?.setSpinner(null);
@@ -354,10 +351,18 @@ export default function (pi: ExtensionAPI) {
   // Async — never blocks the event loop; re-renders once settled.
   pi.on("turn_end", (event) => {
     if (event.message.role === "assistant") {
-      const output = (event.message as MsgSnap).usage?.output ?? 0;
-      const elapsedMs = _pendingResponseElapsedMs ?? 0;
-      _latestTps = elapsedMs > 0 && output > 0 ? output / (elapsedMs / 1000) : undefined;
-      _pendingResponseElapsedMs = undefined;
+      const message = event.message as MsgSnap;
+      const sample = calculateVisibleTextTps({
+        outputTokens: message.usage?.output,
+        reasoningTokens: message.usage?.reasoning,
+        firstTextDeltaAt: _firstTextDeltaAt,
+        lastTextDeltaAt: _lastTextDeltaAt,
+        hasToolCall: message.content?.some((part) => part.type === "toolCall") ?? false,
+        stopReason: message.stopReason,
+      });
+      if (sample != null) _latestTps = sample;
+      _firstTextDeltaAt = undefined;
+      _lastTextDeltaAt = undefined;
       editor?.requestRender();
     }
     if (_cwd) refreshGitDirty(_cwd, () => editor?.requestRender());
@@ -371,8 +376,8 @@ export default function (pi: ExtensionAPI) {
     icons = { ...DEFAULT_ICONS, ...config.icons };
     _cacheTotal = sumCacheRead(ctx);
     _latestUsage = latestAssistantUsage(ctx);
-    _streamStartedAt = undefined;
-    _pendingResponseElapsedMs = undefined;
+    _firstTextDeltaAt = undefined;
+    _lastTextDeltaAt = undefined;
     _latestTps = undefined;
     _sessionCost = sumSessionCost(ctx);
     refreshGitDirty(ctx.cwd, () => editor?.requestRender());
@@ -424,7 +429,7 @@ export default function (pi: ExtensionAPI) {
           : "";
       const tpsPart =
         _latestTps != null
-          ? `${theme.fg("dim", " · ")}${theme.fg("success", `${_latestTps.toFixed(1)} t/s`)}`
+          ? `${theme.fg("dim", " · ")}${theme.fg("warning", `${_latestTps.toFixed(1)} t/s`)}`
           : "";
       const costPart =
         _sessionCost > 0
@@ -544,7 +549,7 @@ export default function (pi: ExtensionAPI) {
       const sessionCost = sumSessionCost(ctx);
       _sessionCost = sessionCost;
       lines.push(`  session cost: ${sessionCost > 0 ? `$${sessionCost.toFixed(3)}` : "n/a"}`);
-      lines.push(`  latest response TPS: ${_latestTps != null ? `${_latestTps.toFixed(1)} t/s` : "n/a"}`);
+      lines.push(`  latest reliable text TPS: ${_latestTps != null ? `${_latestTps.toFixed(1)} t/s` : "n/a"}`);
       const latest = latestAssistantUsage(ctx);
       const now = latest?.cacheRead ?? 0;
       lines.push(`  this turn cacheRead: ${formatTokens(now)}`);

package/src/tps.test.ts

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { calculateVisibleTextTps, type VisibleTextTpsSample } from "./tps.ts";
+
+function sample(overrides: Partial<VisibleTextTpsSample> = {}): VisibleTextTpsSample {
+  return {
+    outputTokens: 51,
+    reasoningTokens: 10,
+    firstTextDeltaAt: 1_000,
+    lastTextDeltaAt: 5_000,
+    hasToolCall: false,
+    stopReason: "stop",
+    ...overrides,
+  };
+}
+
+test("calculates visible text TPS over inter-token intervals", () => {
+  assert.equal(calculateVisibleTextTps(sample()), 10);
+});
+
+test("uses all output tokens when the provider has no reasoning breakdown", () => {
+  assert.equal(calculateVisibleTextTps(sample({ reasoningTokens: undefined })), 12.5);
+});
+
+test("accepts the minimum reliable sample", () => {
+  assert.equal(
+    calculateVisibleTextTps(sample({
+      outputTokens: 10,
+      reasoningTokens: 0,
+      firstTextDeltaAt: 1_000,
+      lastTextDeltaAt: 1_250,
+    })),
+    36,
+  );
+});
+
+test("rejects responses containing tool calls", () => {
+  assert.equal(calculateVisibleTextTps(sample({ hasToolCall: true })), undefined);
+});
+
+test("rejects failed and aborted responses", () => {
+  assert.equal(calculateVisibleTextTps(sample({ stopReason: "error" })), undefined);
+  assert.equal(calculateVisibleTextTps(sample({ stopReason: "aborted" })), undefined);
+});
+
+test("rejects samples with too few visible tokens", () => {
+  assert.equal(
+    calculateVisibleTextTps(sample({ outputTokens: 18, reasoningTokens: 9 })),
+    undefined,
+  );
+});
+
+test("rejects samples shorter than 250 ms", () => {
+  assert.equal(
+    calculateVisibleTextTps(sample({ firstTextDeltaAt: 1_000, lastTextDeltaAt: 1_249 })),
+    undefined,
+  );
+});
+
+test("rejects missing or invalid usage and timing data", () => {
+  assert.equal(calculateVisibleTextTps(sample({ outputTokens: undefined })), undefined);
+  assert.equal(calculateVisibleTextTps(sample({ firstTextDeltaAt: undefined })), undefined);
+  assert.equal(calculateVisibleTextTps(sample({ lastTextDeltaAt: undefined })), undefined);
+  assert.equal(calculateVisibleTextTps(sample({ reasoningTokens: -1 })), undefined);
+  assert.equal(calculateVisibleTextTps(sample({ lastTextDeltaAt: Number.NaN })), undefined);
+});

package/src/tps.ts

@@ -0,0 +1,53 @@
+const MIN_VISIBLE_TOKENS = 10;
+const MIN_SAMPLE_DURATION_MS = 250;
+
+/** @internal — exported for focused throughput tests. */
+export interface VisibleTextTpsSample {
+  outputTokens?: number;
+  reasoningTokens?: number;
+  firstTextDeltaAt?: number;
+  lastTextDeltaAt?: number;
+  hasToolCall: boolean;
+  stopReason?: string;
+}
+
+/**
+ * Calculate client-observed visible-text throughput for one completed response.
+ *
+ * The provider's reasoning count is removed when available because its tokens may
+ * be generated before the first visible delta. Tool-call responses are excluded:
+ * providers do not expose a portable split between text and serialized tool tokens.
+ *
+ * @internal — exported for focused throughput tests.
+ */
+export function calculateVisibleTextTps(sample: VisibleTextTpsSample): number | undefined {
+  if (sample.hasToolCall || sample.stopReason === "error" || sample.stopReason === "aborted") {
+    return undefined;
+  }
+
+  const output = sample.outputTokens;
+  const reasoning = sample.reasoningTokens ?? 0;
+  const first = sample.firstTextDeltaAt;
+  const last = sample.lastTextDeltaAt;
+  if (
+    output == null ||
+    !Number.isFinite(output) ||
+    !Number.isFinite(reasoning) ||
+    reasoning < 0 ||
+    first == null ||
+    last == null ||
+    !Number.isFinite(first) ||
+    !Number.isFinite(last)
+  ) {
+    return undefined;
+  }
+
+  const visibleTokens = output - reasoning;
+  const elapsedMs = last - first;
+  if (visibleTokens < MIN_VISIBLE_TOKENS || elapsedMs < MIN_SAMPLE_DURATION_MS) {
+    return undefined;
+  }
+
+  // N received tokens span N - 1 inter-token intervals once TTFT is excluded.
+  return (visibleTokens - 1) / (elapsedMs / 1000);
+}