@bacnh85/pi-sub 0.1.35 → 0.1.37

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # Changelog
 
+## 0.1.37 (2026-09-07)
+
+### Fixed
+
+- **Legible provider API errors**: structured API failures (e.g. Z.ai's
+  `500 Internal service error` returned by `api.z.ai/api/monitor/usage/quota/limit`
+  during its 2026-09-07 outage) no longer masquerade as a generic
+  "usage unavailable" — the footer shows the server's own message
+  (`Sub Z.ai (Anthropic) API error: Internal service error`), with
+  credential-shaped material (`sk-…`, `Bearer …`, JWTs) scrubbed and length
+  capped; auth-looking messages stay redacted.
+- **Crash (pi exits) on session replacement (`/new`, fork, switch, `/reload`)**:
+  a usage-refresh debounce timer armed by a late `after_provider_response` event
+  — delivered after `session_shutdown` had already cleared the previous timers —
+  captured the old extension ctx; ~2s later the timer fired, touched the now
+  stale `ctx.ui`, and the uncaught error killed pi. Deferred helpers
+  (`renderSubscriptionLine`, `refreshUsage`, `startTimer`, `scheduleRefresh`,
+  `updateActiveAdapter`) no longer take a captured ctx: they resolve `state.ctx`
+  at execution time. `state.ctx` is installed only by `session_start` (fires
+  before a session's other events, always fresh) and cleared by
+  `session_shutdown`, so mid-session handlers can never reinstall a stale ctx
+  and timers firing in the teardown window safely no-op. `session_shutdown`
+  now no-ops entirely unless it belongs to the installed session
+  (`state.ctx === ctx`), so a late old-session shutdown delivered after the
+  next `session_start` can neither touch an invalidated ctx nor stop the live
+  session's refresh timer / drop its in-flight fetch. Regression tests in
+  `extensions/test/stale-ctx-regression.test.ts`.
+
+### Changed
+
+- **Tests are now gated**: `npm test` runs both test files via
+  `node --import tsx --test` (new `tsx` devDependency), and CI runs
+  `npm ci && npm test` for pi-sub instead of only `npm pack --dry-run` — the
+  stale-ctx regression tests can no longer be bypassed by a refactor.
+
+## 0.1.36 (2026-09-07)
+
+### Fixed
+
+- **Removed the incorrect dead `tok-per-sec` module** (added in 0.1.35, never
+  wired in): its `withThinking` formula summed `reasoning` on top of `output`,
+  but Pi's `usage.output` already includes reasoning tokens (`reasoning` is a
+  subset), which would have inflated thinking-mode tok/s up to ~2×. The live
+  footer/footer tok/s math (`output / elapsed`) was and remains correct in both
+  thinking and normal mode.
+
+### Added
+
+- **`/sub` thinking/answer split** — when the model reasoned, the details line
+  now reads e.g. `Last response: 46 tok/s (36 think + 10 answer)` instead of a
+  bare total, using the correct subset math (`answer = output − reasoning`).
+  Footer keeps the single total number.
+
 ## 0.1.35 (2026-09-05)
 
 ### Added

package/extensions/index.ts

@@ -31,7 +31,7 @@ const MESSAGE_TYPE = "pi-sub-status";
 const USAGE_ENDPOINT = "https://chatgpt.com/backend-api/wham/usage";
 const REFRESH_INTERVAL_MS = 60_000;
 const REFRESH_TTL_MS = 30_000;
-const REFRESH_DEBOUNCE_MS = 2_000;
+export const REFRESH_DEBOUNCE_MS = 2_000;
 const CODEX_PROVIDER = "openai-codex";
 const OPC_PROVIDER = "opencode-go";
 const ZAI_PROVIDER = "zai";
@@ -115,10 +115,11 @@ type SubscriptionProviderAdapter = {
   fetchUsage(signal?: AbortSignal): Promise<SubscriptionUsageSnapshot>;
 };
 
-interface State {
+export interface State {
   model?: ModelLike;
   adapter?: SubscriptionProviderAdapter;
   adapterId?: string;
+  ctx?: ExtensionContext;
   snapshot?: SubscriptionUsageSnapshot;
   lastRefreshAt: number;
   refreshGeneration: number;
@@ -127,6 +128,7 @@ interface State {
   debounceTimer?: NodeJS.Timeout;
   responseStartTime?: number;
   lastTokPerSec?: number;
+  lastTokPerSecLabel?: string;
   cumulativeOutput: number;
   cumulativeDurationMs: number;
   cumulativeCost: number;
@@ -462,6 +464,9 @@ if (process.env.PI_SUB_SELF_CHECK === "1") {
   assert(p.personalWeekly?.remaining === 90, "personal weekly 90");
   assert(p.session?.remaining === 47, "session 47");
   assert(p.providerWeekly?.remaining === 28, "provider weekly 28");
+  // tok/s split label: usage.reasoning ⊂ usage.output, never summed.
+  assert(tokPerSecLabel(3200, 2500, 70_000) === "46 tok/s (36 think + 10 answer)", "tok/s split label");
+  assert(tokPerSecLabel(200, 0, 10_000) === "20 tok/s", "tok/s plain label");
   assert(p.personalDaily?.resetLabel?.includes("15h") === true, "daily reset label");
   const disabled = parseOmniUsageText("Usage command is disabled for this API key.");
   assert(Object.keys(disabled).length === 0, "disabled text parses empty");
@@ -503,7 +508,11 @@ async function fetchUsageFromPiAuth(entry: PiAuthEntry, signal?: AbortSignal): P
   return parseUsageResponse(await response.json());
 }
 
-function redactedError(error: unknown, provider = "Codex"): string {
+// ponytail: shared redaction — show provider + failure class, never leak keys.
+// Structured API errors carry the server's own message (e.g. Z.ai's
+// "Internal service error" outage); auth-looking messages were already
+// redacted above, so surface the rest verbatim for diagnosability.
+export function redactedError(error: unknown, provider = "Codex"): string {
   const message = error instanceof Error ? error.message : String(error || "Unknown error");
   if (/ENOENT|no such file/i.test(message)) return "Pi auth not found";
   if (/missing openai-codex/i.test(message)) return "openai-codex auth not found";
@@ -512,7 +521,14 @@ function redactedError(error: unknown, provider = "Codex"): string {
   if (/missing commandcode/i.test(message)) return "commandcode auth not found";
   if (/timed out|timeout|aborted/i.test(message)) return `${provider} usage refresh timed out`;
   if (/401|403|auth|token|unauthorized|forbidden/i.test(message)) return `${provider} auth unavailable`;
-  return `${provider} usage unavailable`;
+  const apiMatch = / API error: (.+)$/.exec(message);
+  if (!apiMatch) return `${provider} usage unavailable`;
+  // Trust boundary: the msg is remote-controlled — scrub credential-shaped
+  // material and cap length before it reaches the status bar.
+  const scrubbed = apiMatch[1]
+    .replace(/sk-[A-Za-z0-9_-]+|Bearer\s+\S+|eyJ[A-Za-z0-9._-]+/g, "[REDACTED]")
+    .slice(0, 120);
+  return scrubbed ? `${provider} API error: ${scrubbed}` : `${provider} usage unavailable`;
 }
 
 async function fetchCodexUsage(signal?: AbortSignal): Promise<SubscriptionUsageSnapshot> {
@@ -1081,7 +1097,11 @@ function windowSegments(account: SubscriptionAccountSnapshot | undefined): strin
   return segments;
 }
 
-function renderSubscriptionLine(ctx: ExtensionContext, state: State): void {
+export function renderSubscriptionLine(state: State): void {
+  // ponytail: resolve ctx at render time — any captured ctx goes stale on
+  // session replacement (new/fork/switch/reload) and ctx.ui then throws.
+  const ctx = state.ctx;
+  if (!ctx) return;
   const theme = ctx.ui.theme;
   if (!state.adapter) {
     // Unsupported provider (e.g. Ollama): still show the last response speed.
@@ -1120,10 +1140,10 @@ function renderSubscriptionLine(ctx: ExtensionContext, state: State): void {
   ctx.ui.setStatus(STATUS_KEY, theme.fg(color, line));
 }
 
-function startTimer(ctx: ExtensionContext, state: State): void {
+function startTimer(state: State): void {
   if (state.refreshTimer || !state.adapter) return;
   state.refreshTimer = setInterval(() => {
-    void refreshUsage(ctx, state, false);
+    void refreshUsage(state, false);
   }, REFRESH_INTERVAL_MS);
 }
 
@@ -1134,7 +1154,7 @@ function stopTimer(state: State): void {
   state.debounceTimer = undefined;
 }
 
-function updateActiveAdapter(ctx: ExtensionContext, state: State, model: ModelLike): void {
+function updateActiveAdapter(state: State, model: ModelLike): void {
   const nextAdapter = supportedAdapter(model);
   const adapterChanged = state.adapterId !== nextAdapter?.id;
 
@@ -1152,25 +1172,28 @@ function updateActiveAdapter(ctx: ExtensionContext, state: State, model: ModelLi
   if (!state.adapter) {
     stopTimer(state);
   }
-  renderSubscriptionLine(ctx, state);
-  if (state.adapter) startTimer(ctx, state);
+  renderSubscriptionLine(state);
+  if (state.adapter) startTimer(state);
 }
 
-async function refreshUsage(ctx: ExtensionContext, state: State, force: boolean): Promise<SubscriptionUsageSnapshot | undefined> {
+async function refreshUsage(state: State, force: boolean): Promise<SubscriptionUsageSnapshot | undefined> {
   const adapter = state.adapter;
-  if (!adapter) {
-    renderSubscriptionLine(ctx, state);
+  // ponytail: resolve ctx at call time, never capture it across the fetch —
+  // the session can be replaced while the promise is in flight.
+  const ctx = state.ctx;
+  if (!adapter || !ctx) {
+    renderSubscriptionLine(state);
     return undefined;
   }
   if (!force && state.snapshot && Date.now() - state.lastRefreshAt < REFRESH_TTL_MS) return state.snapshot;
   if (state.inFlight) return state.inFlight;
   const generation = state.refreshGeneration;
-  renderSubscriptionLine(ctx, state);
+  renderSubscriptionLine(state);
   state.inFlight = adapter.fetchUsage(ctx.signal).then((snapshot) => {
     if (state.refreshGeneration !== generation) return snapshot;
     state.snapshot = snapshot;
     state.lastRefreshAt = Date.now();
-    renderSubscriptionLine(ctx, state);
+    renderSubscriptionLine(state);
     return snapshot;
   }).finally(() => {
     if (state.refreshGeneration === generation) {
@@ -1180,12 +1203,12 @@ async function refreshUsage(ctx: ExtensionContext, state: State, force: boolean)
   return state.inFlight;
 }
 
-function scheduleRefresh(ctx: ExtensionContext, state: State): void {
+export function scheduleRefresh(state: State): void {
   if (!state.adapter) return;
   if (state.debounceTimer) clearTimeout(state.debounceTimer);
   state.debounceTimer = setTimeout(() => {
     state.debounceTimer = undefined;
-    void refreshUsage(ctx, state, true);
+    void refreshUsage(state, true);
   }, REFRESH_DEBOUNCE_MS);
 }
 
@@ -1193,11 +1216,21 @@ function pad(value: string, width: number): string {
   return value.length >= width ? value : value + " ".repeat(width - value.length);
 }
 
+/** "46 tok/s (36 think + 10 answer)" — split shown only when the model
+ *  reasoned. usage.reasoning is a subset of usage.output (Pi SDK contract),
+ *  so answer speed = (output − reasoning)/s, never output + reasoning. */
+function tokPerSecLabel(output: number, thinking: number, elapsedMs: number): string {
+  const total = Math.round(output / (elapsedMs / 1000));
+  if (thinking <= 0) return `${total} tok/s`;
+  const secs = elapsedMs / 1000;
+  return `${total} tok/s (${Math.round(thinking / secs)} think + ${Math.round((output - thinking) / secs)} answer)`;
+}
+
 function buildDetails(snapshot: SubscriptionUsageSnapshot | undefined, state: State): string {
   if (!state.adapter) {
     const header = `Provider: ${state.model?.provider ?? "unknown"}${state.model?.id ? ` · Model: ${state.model.id}` : ""}`;
     if (state.lastTokPerSec === undefined) return `${header}\nSubscription tracking inactive for this provider.`;
-    const tokPerSecLine = `Last response: ${state.lastTokPerSec} tok/s` +
+    const tokPerSecLine = `Last response: ${state.lastTokPerSecLabel}` +
       (state.cumulativeDurationMs > 0
         ? ` · Session avg: ${Math.round(state.cumulativeOutput / (state.cumulativeDurationMs / 1000))} tok/s`
         : "");
@@ -1240,7 +1273,7 @@ function buildDetails(snapshot: SubscriptionUsageSnapshot | undefined, state: St
 
   const costLine = state.cumulativeCost > 0 ? `\nSession cost: $${state.cumulativeCost.toFixed(2)}` : "";
   const tokPerSecLine = state.lastTokPerSec !== undefined
-    ? `\nLast response: ${state.lastTokPerSec} tok/s` +
+    ? `\nLast response: ${state.lastTokPerSecLabel}` +
       (state.cumulativeDurationMs > 0
         ? ` · Session avg: ${Math.round(state.cumulativeOutput / (state.cumulativeDurationMs / 1000))} tok/s`
         : "")
@@ -1260,44 +1293,58 @@ export default function (pi: ExtensionAPI) {
   const state: State = { lastRefreshAt: 0, refreshGeneration: 0, cumulativeOutput: 0, cumulativeDurationMs: 0, cumulativeCost: 0 };
 
   pi.on("session_start", async (_event, ctx) => {
-    updateActiveAdapter(ctx, state, ctx.model);
-    if (state.adapter) void refreshUsage(ctx, state, true);
+    // Only session_start installs state.ctx: it fires (startup/new/fork/switch/
+    // reload) before the session's other events, so mid-session handlers never
+    // need to — and a late old-session event must not reinstall a stale ctx.
+    state.ctx = ctx;
+    updateActiveAdapter(state, ctx.model);
+    if (state.adapter) void refreshUsage(state, true);
   });
 
-  pi.on("model_select", async (event, ctx) => {
-    updateActiveAdapter(ctx, state, event.model);
-    if (state.adapter) void refreshUsage(ctx, state, true);
+  pi.on("model_select", async (event, _ctx) => {
+    updateActiveAdapter(state, event.model);
+    if (state.adapter) void refreshUsage(state, true);
   });
 
   pi.on("before_provider_request", async (_event, _ctx) => {
     state.responseStartTime = Date.now();
   });
 
-  pi.on("message_end", async (event, ctx) => {
+  pi.on("message_end", async (event, _ctx) => {
     if (event.message.role === "assistant") {
       state.cumulativeCost += (event.message.usage as any)?.cost?.total ?? 0;
       if (state.responseStartTime) {
+        // usage.output already includes reasoning tokens (Pi SDK contract) —
+        // this is total tok/s in both thinking and normal mode.
         const output = (event.message.usage as any)?.output ?? 0;
+        const reasoning = (event.message.usage as any)?.reasoning ?? 0;
         const elapsed = Date.now() - state.responseStartTime;
         state.responseStartTime = undefined;
         if (elapsed > 0 && output > 0) {
           state.lastTokPerSec = Math.round(output / (elapsed / 1000));
+          state.lastTokPerSecLabel = tokPerSecLabel(output, reasoning, elapsed);
           state.cumulativeOutput += output;
           state.cumulativeDurationMs += elapsed;
         }
       }
-      renderSubscriptionLine(ctx, state);
+      renderSubscriptionLine(state);
     }
   });
 
-  pi.on("after_provider_response", async (event, ctx) => {
+  pi.on("after_provider_response", async (event, _ctx) => {
     if (event.status >= 400) {
       state.responseStartTime = undefined;
     }
-    if (state.adapter) scheduleRefresh(ctx, state);
+    if (state.adapter) scheduleRefresh(state);
   });
 
   pi.on("session_shutdown", async (_event, ctx) => {
+    // Only tear down if this shutdown belongs to the installed session: a late
+    // old-session shutdown (delivered after the next session_start) must not
+    // stop the live refresh timer, drop the live in-flight fetch, or touch a
+    // ctx that may already be invalidated. Normal flow: session_start installed
+    // this ctx, so the identity always matches for the session being torn down.
+    if (state.ctx !== ctx) return;
     stopTimer(state);
     // ponytail: session is being torn down (new/fork/switch/reload). Pi invalidates
     // this ctx next; no-op any in-flight fetch .then that captured it, and drop the
@@ -1305,6 +1352,7 @@ export default function (pi: ExtensionAPI) {
     state.inFlight = undefined;
     state.refreshGeneration++;
     ctx.ui.setStatus(STATUS_KEY, undefined);
+    state.ctx = undefined;
   });
 
   pi.registerCommand("sub", {
@@ -1316,13 +1364,19 @@ export default function (pi: ExtensionAPI) {
       return items.length > 0 ? items : null;
     },
     handler: async (args, ctx) => {
-      updateActiveAdapter(ctx, state, ctx.model);
+      updateActiveAdapter(state, ctx.model);
       const command = args.trim().toLowerCase();
       const force = command === "refresh";
-      const snapshot = state.adapter ? await refreshUsage(ctx, state, force || !state.snapshot) : undefined;
+      const snapshot = state.adapter ? await refreshUsage(state, force || !state.snapshot) : undefined;
       const details = buildDetails(snapshot ?? state.snapshot, state);
       pi.sendMessage({ customType: MESSAGE_TYPE, content: details, display: true });
-      if (force) ctx.ui.notify("Subscription usage refreshed", "info");
+      // state.ctx (not captured ctx): the session could be replaced during the
+      // await above; if it was, skip the notification instead of touching a
+      // stale ctx.
+      if (force) state.ctx?.ui.notify("Subscription usage refreshed", "info");
     },
   });
+
+  // Returned for tests only — Pi ignores the extension setup return value.
+  return state;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-sub",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "description": "Pi extension showing subscription usage for supported model providers.",
   "type": "module",
   "license": "MIT",
@@ -42,6 +42,9 @@
     "@earendil-works/pi-coding-agent": ">=0.80.8 <0.86.0"
   },
   "devDependencies": {
-    "@earendil-works/pi-server": "^0.85.1"
+    "tsx": "^4.23.13"
+  },
+  "scripts": {
+    "test": "node --import tsx --test extensions/test/*.test.ts"
   }
 }