@bacnh85/pi-sub 0.1.28 → 0.1.30

package/CHANGELOG.md

@@ -1,5 +1,55 @@
+## 0.1.30 (2026-08-22)
+
+- Router usage is now **provider-scoped**: the active router model's upstream
+  prefix (e.g. `command-code` from `router/command-code/deepseek/deepseek-v4-flash`)
+  is passed as `?provider=` to the OmniRoute usage API, so the footer shows that
+  upstream's quota (e.g. opencode-go session/weekly windows).
+- Aliases normalized before the API call: `cmd`→`command-code`, `oc`→`opencode-go`,
+  `ds`→`deepseek`, `glmcn`/`glm-cn`→`zai-coding-cn`; generic router aliases
+  (auto/aug/no-think/tllm/combo/openrouter/nvidia/…) are filtered out.
+- When the selected upstream has no cached quota ("No cached usage data"),
+  the adapter retries without `?provider=` so the footer still shows the best
+  snapshot instead of empty windows.
+- Switching between router models with different upstreams now refreshes
+  immediately (adapter id includes the prefix, so stale in-flight results are
+  discarded via the generation guard).
+- `/sub` breakdown shows only the Provider quota section — personal USD budget
+  lines are no longer surfaced.
+- Self-check extended (17 assertions) and now exercises the real
+  `routerUpstreamPrefix` (aliases + generic filter).
+
+## 0.1.27 (2026-08-22)
+
+- Router adapter now fetches real usage from OmniRoute instances: GET
+  `<origin>/api/usage/om-usage` (Bearer = router API key from auth.json or
+  ROUTER_API_KEY env). The plain-text report (Personal quota Daily/Weekly +
+  Provider quota Session/Weekly) is parsed into the footer R:/W: windows.
+  Non-OmniRoute routers 404 → fall back to the endpoint-only display.
+  When the per-key usage command is disabled, the footer shows a hint to
+  enable it in the OmniRoute dashboard (API Keys → the key).
+- New pure parser `parseOmniUsageText` with an env-gated self-check
+  (PI_SUB_SELF_CHECK=1) — pi-sub stays pack-only for CI.
+
+## 0.1.26 (2026-08-21)
+
+- Router adapter: reads `router.baseUrl` from `~/.pi/agent/settings.json`
+  (env `ROUTER_BASE_URL`/`NINE_ROUTER_BASE_URL`) now that pi-router moved the
+  endpoint URL out of the old `9router-config.json` (which is migrated away on
+  pi-router load). Footer shows for both new `router/` and legacy `9router/`
+  provider models.
+
 # Changelog
 
+## 0.1.29 (2026-08-15)
+
+### Features
+
+- **tok/s speed now shown for all providers.** Previously the footer was cleared
+  for providers without a subscription adapter (e.g. `ollama`); now the last
+  response speed renders as a standalone `145 tok/s` line, and `/sub` reports
+  provider/model plus last and session-average speed instead of only
+  "tracking inactive".
+
 ## 0.1.28 (2026-08-09)
 
 ### Improvements

package/README.md

@@ -51,12 +51,27 @@ The built-in `zai-coding-cn` provider targets the domestic BigModel endpoint (`o
 (Z.ai (CN) key#1a2b3c4d) R:55%/2H W:80%/3D 42 tok/s
 ```
 
-### 9router
+### Router (pi-router — formerly 9router)
 
-9router is a proxy/router with no upstream usage API, so the footer shows the configured endpoint and last response speed:
+For **OmniRoute** instances the footer shows real usage: `GET <origin>/api/usage/om-usage`
+with the router API key (auth.json `router` credential from `/login router`, or
+`ROUTER_API_KEY` env) returns the per-key report — Personal quota (daily/weekly
+USD budgets) and Provider quota (session/weekly connection windows) — rendered
+as `R:`/`W:` remaining-percent windows:
 
 ```text
-9router (172.30.55.22:20128) 145 tok/s
+Router usage R:80% W:28% 145 tok/s
+```
+
+Requirements:
+- The router instance must be OmniRoute (other routers 404 → endpoint-only fallback).
+- The API key must have the **usage command enabled** in the OmniRoute dashboard
+  (API Keys → the key → enable "usage command"); the footer shows a hint when it's off.
+
+The endpoint URL is read from `~/.pi/agent/settings.json` (`router.baseUrl`), env `ROUTER_BASE_URL` overrides:
+
+```text
+Router (172.30.55.22:20128) 145 tok/s
 ```
 
 ### Command Code
@@ -75,7 +90,17 @@ monthly allowance in USD). The `/sub` detail view also shows a
 
 `pi-sub` tracks each response's tokens-per-second (tok/s) speed by measuring the time from provider request to message completion against the response's output token count. The last response's speed is shown in the footer next to usage data. The `/sub` detail view shows both the last response speed and the session-wide average.
 
-When the current model provider is not supported, `pi-sub` clears its subscription line and does not refresh subscription data.
+The tok/s speed line is shown for **all** providers — including ones without a
+subscription adapter, such as `ollama` and other OpenAI-compatible local
+providers. For those, the footer shows only the speed:
+
+```text
+145 tok/s
+```
+
+and `/sub` reports the provider/model and speed instead of usage windows.
+`pi-sub` still does not refresh subscription data for unsupported providers
+(there is nothing to fetch).
 
 ## Commands
 

package/extensions/index.ts

@@ -16,8 +16,11 @@ const ZAI_PROVIDER = "zai";
 const ZAI_USAGE_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
 const ZAI_CODING_CN_PROVIDER = "zai-coding-cn";
 const ZAI_CODING_CN_USAGE_URL = "https://open.bigmodel.cn/api/monitor/usage/quota/limit";
-const NINE_ROUTER_PROVIDER = "9router";
-const NINE_ROUTER_CONFIG_PATH = path.join(os.homedir(), ".pi", "agent", "9router-config.json");
+const ROUTER_PROVIDER = "router";
+const LEGACY_9ROUTER_PROVIDER = "9router";
+// pi-router (formerly pi-9router): URL lives in settings.json `router.baseUrl`
+// (env override ROUTER_BASE_URL), key in auth.json `router` credential.
+const ROUTER_SETTINGS_PATH = path.join(os.homedir(), ".pi", "agent", "settings.json");
 const COMMAND_CODE_PROVIDER = "commandcode";
 const COMMAND_CODE_USAGE_URL = "https://api.commandcode.ai/alpha/billing/credits";
 
@@ -117,8 +120,8 @@ function isZaiCodingCnModel(model: ModelLike): boolean {
   return (model?.provider?.toLowerCase() ?? "") === ZAI_CODING_CN_PROVIDER;
 }
 
-function isNineRouterModel(model: ModelLike): boolean {
-  return (model?.provider?.toLowerCase() ?? "") === NINE_ROUTER_PROVIDER;
+function isRouterModel(model: ModelLike, provider: string = ROUTER_PROVIDER): boolean {
+  return (model?.provider?.toLowerCase() ?? "") === provider;
 }
 
 function isCommandCodeModel(model: ModelLike): boolean {
@@ -309,21 +312,113 @@ async function readZaiAuth(providerId: string, label: string): Promise<{ key: st
   return { key: entry.key, account: authAccountSnapshot(label, entry) };
 }
 
-// ponytail: duplicated from pi-9router — no shared config lib, 8 lines, acceptable
-function readNineRouterConfig(): { baseUrl: string; apiKey?: string } | null {
+// ponytail: duplicated from pi-router — no shared config lib, ~12 lines, acceptable
+function readRouterConfig(): { baseUrl: string } | null {
   try {
-    const exists = (p: string) => { try { return fs.statSync(p).isFile(); } catch { return false; } };
-    if (!exists(NINE_ROUTER_CONFIG_PATH)) return null;
-    const data = JSON.parse(fs.readFileSync(NINE_ROUTER_CONFIG_PATH, "utf8")) as Record<string, unknown>;
-    const baseUrl = process.env.NINE_ROUTER_BASE_URL || (typeof data.baseUrl === "string" ? data.baseUrl : undefined);
-    const apiKey = process.env.NINE_ROUTER_API_KEY || (typeof data.apiKey === "string" ? data.apiKey : undefined);
-    if (!baseUrl || typeof baseUrl !== "string") return null;
-    return { baseUrl, apiKey };
+    let baseUrl = process.env.ROUTER_BASE_URL || process.env.NINE_ROUTER_BASE_URL;
+    if (!baseUrl && fs.statSync(ROUTER_SETTINGS_PATH).isFile()) {
+      const settings = JSON.parse(fs.readFileSync(ROUTER_SETTINGS_PATH, "utf8")) as Record<string, unknown>;
+      const router = settings.router as { baseUrl?: unknown } | undefined;
+      if (typeof router?.baseUrl === "string" && router.baseUrl) baseUrl = router.baseUrl;
+    }
+    return baseUrl ? { baseUrl } : null;
   } catch {
     return null;
   }
 }
 
+/** Router API key: auth.json `router` credential (via /login), then env. */
+function readRouterApiKey(): string | undefined {
+  const stored = readStoredCredential(ROUTER_PROVIDER, piAuthPath()) as PiAuthEntry | undefined;
+  if (stored?.key) return stored.key;
+  return process.env.ROUTER_API_KEY || process.env.NINE_ROUTER_API_KEY || undefined;
+}
+
+/** Strip a `/v1` suffix so management routes (under the origin) can be
+ *  derived from the OpenAI-compatible baseUrl. */
+function routerOrigin(baseUrl: string): string {
+  return baseUrl.replace(/\/v1\/?$/, "");
+}
+
+/** Parse OmniRoute's `/api/usage/om-usage` plain-text report into windows.
+ *  Sections: "Personal quota" (per-key USD budgets: Daily/Weekly) and
+ *  "Provider quota" (connection session/weekly). Lines: `<Label>`,
+ *  `NN% left`, `⏱ reset in <countdown>`. Robust to missing/unknown blocks. */
+export function parseOmniUsageText(text: string): {
+  personalDaily?: UsageWindow;
+  personalWeekly?: UsageWindow;
+  session?: UsageWindow;
+  providerWeekly?: UsageWindow;
+} {
+  const out: {
+    personalDaily?: UsageWindow;
+    personalWeekly?: UsageWindow;
+    session?: UsageWindow;
+    providerWeekly?: UsageWindow;
+  } = {};
+  const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  let inPersonal = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.toLowerCase() === "personal quota") { inPersonal = true; continue; }
+    if (line.toLowerCase() === "provider quota") { inPersonal = false; continue; }
+    const usedMatch = line.match(/^(\d+)%\s*left$/);
+    if (!usedMatch) continue;
+    const label = (lines[i - 1] ?? "").toLowerCase();
+    const resetMatch = lines[i + 1]?.match(/reset in (.+)$/);
+    const remaining = Number(usedMatch[1]);
+    if (remaining < 0 || remaining > 100) continue;
+    const window: UsageWindow = { remaining };
+    if (resetMatch) window.resetLabel = `⏱ ${resetMatch[1].trim()}`;
+    if (inPersonal) {
+      if (label.includes("daily")) out.personalDaily = window;
+      else if (label.includes("weekly")) out.personalWeekly = window;
+    } else {
+      if (label.includes("session")) out.session = window;
+      else if (label.includes("weekly")) out.providerWeekly = window;
+    }
+  }
+  return out;
+}
+
+// ponytail: runnable self-check (pi-sub has no test runner — pack gate only)
+if (process.env.PI_SUB_SELF_CHECK === "1") {
+  const sample = [
+    "Personal quota", "Daily", "80% left", "⏱ reset in 15h 0m", "",
+    "Weekly", "90% left", "⏱ reset in 7d 0h 0m", "",
+    "Provider quota", "Session", "47% left", "⏱ reset in 9m", "",
+    "Weekly", "28% left", "⏱ reset in 1d 0h 0m",
+  ].join("\n");
+  const p = parseOmniUsageText(sample);
+  const assert = (cond: boolean, msg: string) => { if (!cond) throw new Error("pi-sub self-check: " + msg); };
+  assert(p.personalDaily?.remaining === 80, "personal daily 80");
+  // routerUpstreamPrefix: provider first segment, aliases + generic filtered
+  const rp = (id: string) => routerUpstreamPrefix({ id });
+  assert(rp("command-code/deepseek/deepseek-v4-flash") === "command-code", "prefix command-code");
+  assert(rp("cmd/deepseek/deepseek-v4-flash") === "command-code", "alias cmd → command-code");
+  assert(rp("oc/gpt-5") === "opencode-go", "alias oc → opencode-go");
+  assert(rp("zai-coding/glm-5.2") === "zai-coding", "prefix zai-coding");
+  assert(rp("auto/best") === undefined, "generic auto filtered");
+  assert(rp("openrouter/gpt-5") === undefined, "generic openrouter filtered");
+  assert(rp("nvidia/gpt-5") === undefined, "generic nvidia filtered");
+  assert(p.personalWeekly?.remaining === 90, "personal weekly 90");
+  assert(p.session?.remaining === 47, "session 47");
+  assert(p.providerWeekly?.remaining === 28, "provider weekly 28");
+  assert(p.personalDaily?.resetLabel?.includes("15h"), "daily reset label");
+  const disabled = parseOmniUsageText("Usage command is disabled for this API key.");
+  assert(Object.keys(disabled).length === 0, "disabled text parses empty");
+  // Live-verified: provider without cached data → no windows (endpoint fallback).
+  const noCache = parseOmniUsageText("Provider quota\nNo cached usage data available.");
+  assert(Object.keys(noCache).length === 0, "no-cached-data parses empty");
+  // Live-verified: opencode-go quota via ?provider=opencode-go.
+  const live = parseOmniUsageText(
+    "Provider quota\nSession\n90% left\n⏱ reset in 1h 59m\n\nWeekly\n0% left\n⏱ reset in 1d 20h 26m"
+  );
+  assert(live.session?.remaining === 90, "session 90");
+  assert(live.providerWeekly?.remaining === 0, "weekly 0");
+  assert(live.session?.resetLabel?.includes("1h 59m"), "session reset");
+}
+
 async function fetchUsageFromPiAuth(entry: PiAuthEntry, signal?: AbortSignal): Promise<UsageApiSnapshot | undefined> {
   const accountId = getCodexAccountId(entry) ?? entry.accountId;
   if (!accountId) throw new Error("Missing openai-codex OAuth entry in Pi auth");
@@ -395,27 +490,100 @@ async function fetchOpenCodeGoUsage(_signal?: AbortSignal): Promise<Subscription
   }
 }
 
-async function fetchNineRouterUsage(_signal?: AbortSignal): Promise<SubscriptionUsageSnapshot> {
-  const cfg = readNineRouterConfig();
+async function fetchRouterUsage(signal?: AbortSignal, provider?: string): Promise<SubscriptionUsageSnapshot> {
+  const cfg = readRouterConfig();
   const now = Date.now();
   if (!cfg) {
     return {
-      providerDisplayName: "9router",
+      providerDisplayName: "Router",
       accounts: [],
       fetchedAt: now,
-      error: "9router not configured — run /login-9router",
+      error: "router not configured — set router.baseUrl in ~/.pi/agent/settings.json",
     };
   }
-  const account: SubscriptionAccountSnapshot = {
+  const apiKey = readRouterApiKey();
+  const baseAccount: SubscriptionAccountSnapshot = {
     id: cfg.baseUrl,
     isActive: true,
     accountLabel: cfg.baseUrl.replace(/^https?:\/\//, ""),
     lastActivity: "Now",
   };
+
+  // OmniRoute exposes per-key usage at GET <origin>/api/usage/om-usage
+  // (Bearer = the router API key). `?provider=` selects that upstream's quota
+  // (e.g. command-code/deepseek/deepseek-v4-flash → provider=command-code);
+  // without it the report shows the best/all snapshot. Plain text: Personal
+  // quota (Daily/Weekly USD budgets) + Provider quota (Session/Weekly).
+  // Non-OmniRoute routers 404 here — fall back to endpoint-only display.
+  if (apiKey) {
+    try {
+      const timeoutSignal = AbortSignal.timeout(7_000);
+      const combined = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+      const url = `${routerOrigin(cfg.baseUrl)}/api/usage/om-usage` +
+        (provider ? `?provider=${encodeURIComponent(provider)}` : "");
+      const response = await fetch(url, {
+        headers: { Accept: "text/plain", Authorization: `Bearer ${apiKey}` },
+        signal: combined,
+      });
+      if (response.ok) {
+        let text = await response.text();
+        if (text && !text.includes("disabled")) {
+          let w = parseOmniUsageText(text);
+          // Provider-scoped call but no cached quota for that upstream — retry
+          // without ?provider= so the report shows the best/all snapshot.
+          if (provider && !w.session && !w.providerWeekly) {
+            const plain = await fetch(url.replace(/\?provider=.*$/, ""), {
+              headers: { Accept: "text/plain", Authorization: `Bearer ${apiKey}` },
+              signal: combined,
+            });
+            if (plain.ok) {
+              const plainText = await plain.text();
+              if (plainText && !plainText.includes("disabled")) {
+                w = parseOmniUsageText(plainText);
+                text = plainText;
+              }
+            }
+          }
+          // personalDaily = per-key budget (nearest reset → R slot),
+          // provider weekly/session = upstream quota (W slot). Fall back sensibly.
+          const account: SubscriptionAccountSnapshot = {
+            ...baseAccount,
+            plan: provider ? `Router · ${provider}` : "Router usage",
+            fiveHour: w.personalDaily ?? w.session,
+            weekly: w.providerWeekly ?? w.personalWeekly,
+            // breakdown keeps only the provider-quota section — the raw text can
+            // include personal USD budget lines (privacy) and is noisy.
+            usageBreakdown: providerQuotaSection(text),
+          };
+          return {
+            providerDisplayName: "Router",
+            accounts: [account],
+            activeAccount: account,
+            fetchedAt: Date.now(),
+          };
+        }
+        // Usage command exists but is disabled for this key — keep the footer
+        // clean (endpoint display) and surface the hint in /sub detail only.
+        const keyFp = apiKey ? `${apiKey.slice(0, 4)}…${apiKey.slice(-4)}` : "?";
+        const hintAccount: SubscriptionAccountSnapshot = {
+          ...baseAccount,
+          usageBreakdown: `OmniRoute usage command is disabled for the router key ${keyFp} — ` +
+            `enable it in the dashboard (API Keys → the key ending ${apiKey?.slice(-4)} → usage command).`,
+        };
+        return {
+          providerDisplayName: "Router",
+          accounts: [hintAccount],
+          activeAccount: hintAccount,
+          fetchedAt: Date.now(),
+        };
+      }
+    } catch { /* non-OmniRoute or transient — fall through to endpoint display */ }
+  }
+
   return {
-    providerDisplayName: "9router",
-    accounts: [account],
-    activeAccount: account,
+    providerDisplayName: "Router",
+    accounts: [baseAccount],
+    activeAccount: baseAccount,
     fetchedAt: now,
   };
 }
@@ -704,11 +872,54 @@ function supportedAdapter(model: ModelLike): SubscriptionProviderAdapter | undef
   if (isOpenCodeGoModel(model)) return { id: OPC_PROVIDER, displayName: "OpenCode Go", fetchUsage: fetchOpenCodeGoUsage };
   if (isZaiModel(model)) return { id: ZAI_PROVIDER, displayName: "Z.ai", ...zaiUsageAdapter(ZAI_PROVIDER, ZAI_USAGE_URL, "Z.ai") };
   if (isZaiCodingCnModel(model)) return { id: ZAI_CODING_CN_PROVIDER, displayName: "Z.ai (CN)", ...zaiUsageAdapter(ZAI_CODING_CN_PROVIDER, ZAI_CODING_CN_USAGE_URL, "Z.ai (CN)") };
-  if (isNineRouterModel(model)) return { id: NINE_ROUTER_PROVIDER, displayName: "9router", fetchUsage: fetchNineRouterUsage };
+  if (isRouterModel(model)) {
+    const prefix = routerUpstreamPrefix(model);
+    return {
+      // Prefix in the id makes adapterChanged fire when switching upstreams
+      // (e.g. opencode-go → command-code), so the in-flight fetch from the
+      // previous model is discarded via the refreshGeneration guard.
+      id: prefix ? `${ROUTER_PROVIDER}:${prefix}` : ROUTER_PROVIDER,
+      displayName: "Router",
+      // ponytail: capture the upstream provider prefix so fetchRouterUsage can
+      // request that provider's quota from the OmniRoute usage API.
+      fetchUsage: (signal) => fetchRouterUsage(signal, prefix),
+    };
+  }
+  if (isRouterModel(model, LEGACY_9ROUTER_PROVIDER)) return { id: LEGACY_9ROUTER_PROVIDER, displayName: "9router (legacy)", fetchUsage: fetchRouterUsage };
   if (isCommandCodeModel(model)) return { id: COMMAND_CODE_PROVIDER, displayName: "Command Code", fetchUsage: fetchCommandCodeUsage };
   return undefined;
 }
 
+/** Strip everything up to and including the "Provider quota" section header
+ *  so /sub breakdown never shows personal USD budget lines. */
+function providerQuotaSection(text: string): string | undefined {
+  const idx = text.indexOf("Provider quota");
+  if (idx < 0) return undefined;
+  const section = text.slice(idx);
+  return section.trim().length > 0 ? section : undefined;
+}
+
+/** First path segment of a router model id = the upstream provider OmniRoute
+ *  routes to (e.g. `command-code/deepseek/deepseek-v4-flash` → `command-code`).
+ *  `router/provider/model` in pi flattens to id `provider/model`, so the prefix
+ *  is the first segment. Aliases normalize to the canonical provider id
+ *  (`cmd` → `command-code`); generic router aliases carry no provider info —
+ *  return undefined so the usage API picks the best snapshot. */
+function routerUpstreamPrefix(model: ModelLike): string | undefined {
+  const id = model?.id ?? "";
+  const first = id.split("/")[0]?.toLowerCase();
+  if (!first) return undefined;
+  // Alias normalization: OmniRoute exposes the same upstream under several ids.
+  if (first === "cmd") return "command-code";
+  if (first === "oc") return "opencode-go";
+  if (first === "ds") return "deepseek";
+  if (first === "glmcn" || first === "glm-cn") return "zai-coding-cn";
+  // Generic router aliases / upstreams without cached quota data — no provider
+  // selection; the usage API returns the best snapshot instead.
+  const generic = new Set(["auto", "aug", "no-think", "tllm", "combo", "openrouter", "nvidia", "felo", "pepper", "mcode", "ddgw", "veoaifree-web", "veo-free"]);
+  return generic.has(first) ? undefined : first;
+}
+
 function formatRemaining(window: UsageWindow | undefined): string {
   if (!window) return "?";
   if (window.remainingLabel) return `${window.remaining}%/${window.remainingLabel}`;
@@ -733,11 +944,12 @@ function windowSegments(account: SubscriptionAccountSnapshot | undefined): strin
 }
 
 function renderSubscriptionLine(ctx: ExtensionContext, state: State): void {
+  const theme = ctx.ui.theme;
   if (!state.adapter) {
-    ctx.ui.setStatus(STATUS_KEY, undefined);
+    // Unsupported provider (e.g. Ollama): still show the last response speed.
+    ctx.ui.setStatus(STATUS_KEY, state.lastTokPerSec !== undefined ? theme.fg("dim", `${state.lastTokPerSec} tok/s`) : undefined);
     return;
   }
-  const theme = ctx.ui.theme;
   const snapshot = state.snapshot;
   let line: string;
   let color: "dim" | "warning" | "error" = "dim";
@@ -844,7 +1056,15 @@ function pad(value: string, width: number): string {
 }
 
 function buildDetails(snapshot: SubscriptionUsageSnapshot | undefined, state: State): string {
-  if (!state.adapter) return `Subscription tracking inactive for current model provider (${state.model?.provider ?? "unknown"}).`;
+  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` +
+      (state.cumulativeDurationMs > 0
+        ? ` · Session avg: ${Math.round(state.cumulativeOutput / (state.cumulativeDurationMs / 1000))} tok/s`
+        : "");
+    return `${header}\n${tokPerSecLine}`;
+  }
   if (!snapshot) return "Subscription usage has not been loaded yet.";
   if (snapshot.error) return `${snapshot.providerDisplayName}: ${snapshot.error}`;
   if (snapshot.accounts.length === 0) {
@@ -928,7 +1148,7 @@ export default function (pi: ExtensionAPI) {
           state.cumulativeDurationMs += elapsed;
         }
       }
-      if (state.adapter) renderSubscriptionLine(ctx, state);
+      renderSubscriptionLine(ctx, state);
     }
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-sub",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "description": "Pi extension showing subscription usage for supported model providers.",
   "type": "module",
   "license": "MIT",