@astrosheep/pi-quota 0.5.1 → 0.5.2

package/README.md

@@ -6,7 +6,7 @@ Compact quota status for Pi: Codex, Kimi and OpenCode Go work out of the box; ne
 pi install npm:@astrosheep/pi-quota
 ```
 
-Reload Pi after installing or changing settings. Use `/usage` for a persistent, context-free snapshot in the chat history. Automatic footer polling never adds chat items.
+Reload Pi after installing or changing settings. Use `/usage` for a persistent, context-free snapshot covering every configured provider with a quota adapter, including the current one. Automatic footer polling never adds chat items.
 
 ## What it shows
 
@@ -18,7 +18,7 @@ Reload Pi after installing or changing settings. Use `/usage` for a persistent,
 
 A percentage always means **remaining**, not used. Unknown is `[?] ?`; an expired reset is `↺ due` with the stale percentage hidden until the next successful query. A wallet balance never becomes a percentage. Historical spend is not a quota.
 
-The footer shows at most two windows and `+N` for additional ones. `/usage` includes all windows; it does not open a modal or send messages to the model. Snapshots remain frozen at capture time. Errors replace stale values.
+The footer shows at most two windows and `+N` for additional ones, for the current provider only. `/usage` queries all configured supported providers and includes all windows, grouped by provider; it does not open a modal or send messages to the model. Snapshots remain frozen at capture time. Errors replace stale values and are shown per provider.
 
 ## Configure providers
 
@@ -58,12 +58,12 @@ Pi model/auth → adapter → QuotaSnapshot → controller → footer / /usage /
 
 - `src/query/`: protocol-specific parsing, credential resolution, safe URLs, bounded GET client, state validation and controller. No Pi/TUI imports.
 - `src/config.ts`: strict global provider bindings.
-- `src/bar/`: pure compact rendering and persistent chat card.
+- `src/bar/`: pure compact rendering and persistent multi-provider chat card.
 - `src/extension.ts` and `src/index.ts`: Pi lifecycle and auth bridge.
 
 `QuotaSnapshot` separates `balance` (wallet), `allowance` (finite key quota), `windows` (renewable limits), and optional `spend` (Today/Lifetime actual charge). This prevents unrelated amounts from sharing an ambiguous `Used` label. Custom adapters can be passed to `createQuotaExtension({ adapters: [...] })`; see `examples/custom-provider.ts`. Provider aliases are never inferred.
 
-The extension publishes structured state on `quota-bar:state:v1`. Use `createQuotaExtension({ footer: false })` to consume it without this extension's footer. Normal queries are throttled, cancellable, timeout-bounded and backed off after errors. `/usage` forces a fresh query. Switching provider discards old values immediately.
+The extension publishes structured state on `quota-bar:state:v1`. Use `createQuotaExtension({ footer: false })` to consume it without this extension's footer. Normal queries are throttled, cancellable, timeout-bounded and backed off after errors. `/usage` forces a fresh query for every configured supported provider. Switching provider discards old footer values immediately.
 
 ## Development
 

package/package.json

@@ -1,7 +1,9 @@
 {
   "name": "@astrosheep/pi-quota",
-  "version": "0.5.1",
-  "publishConfig": { "access": "public" },
+  "version": "0.5.2",
+  "publishConfig": {
+    "access": "public"
+  },
   "type": "module",
   "description": "Composable quota bar with Codex, Kimi, OpenCode Go, new-api, DeepSeek and Sub2API adapters",
   "keywords": [

package/src/bar/card.ts

@@ -6,27 +6,39 @@ import type { QuotaState } from '../query/types.ts';
 
 export const USAGE_ENTRY = 'quota-bar:usage:v1';
 
-export interface UsageCard {
-  version: 1;
-  capturedAt: number;
-  state: Exclude<QuotaState, { kind: 'loading' }>;
-}
+export type UsageCard =
+  | { version: 1; capturedAt: number; state: Exclude<QuotaState, { kind: 'loading' }> }
+  | { version: 2; capturedAt: number; states: Exclude<QuotaState, { kind: 'loading' }>[] };
 
 export function captureUsage(state: QuotaState, now = Date.now()): UsageCard | undefined {
   if (state.kind === 'loading') return undefined;
-  // Separate the persistent entry from the live controller's state/objects.
+  // Preserve v1 rendering for cards already saved in sessions.
   return { version: 1, capturedAt: now, state: structuredClone(state) };
 }
 
+export function captureAllUsage(states: readonly QuotaState[], now = Date.now()): UsageCard {
+  return { version: 2, capturedAt: now, states: structuredClone(states.filter(
+    (state): state is Exclude<QuotaState, { kind: 'loading' }> => state.kind !== 'loading',
+  )) };
+}
+
+export function usageLines(card: UsageCard, paint?: Paint, barWidth = 20): string[] {
+  if (card.version === 1) return renderUsage(card.state, paint, card.capturedAt, barWidth);
+  if (card.states.length === 0) return ['No supported quota providers available.'];
+  return card.states.flatMap((state, index) => [
+    ...(index ? ['', ''] : []), ...renderUsage(state, paint, card.capturedAt, barWidth),
+  ]);
+}
+
 export function usageCardComponent(card: UsageCard | undefined, paint?: Paint): Component {
   return {
     render(width: number): string[] {
       if (width <= 0) return [];
-      if (!card || card.version !== 1 || !Number.isFinite(card.capturedAt)) {
+      if (!card || (card.version !== 1 && card.version !== 2) || !Number.isFinite(card.capturedAt)) {
         return new Text('Usage snapshot unavailable.', 0, 0).render(width);
       }
       // Rebuild on every render for theme/width changes, but freeze time at capture.
-      const lines = renderUsage(card.state, paint, card.capturedAt, width < 55 ? 10 : 20);
+      const lines = usageLines(card, paint, width < 55 ? 10 : 20);
       // Wrapping, not clipping: long quota names remain readable in narrow terminals.
       return new Text(lines.join('\n'), 0, 0).render(width);
     },

package/src/extension.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
-import { renderFooter, renderUsage } from './bar/quota.ts';
-import { captureUsage, USAGE_ENTRY, usageCardComponent } from './bar/card.ts';
+import { renderFooter } from './bar/quota.ts';
+import { captureAllUsage, USAGE_ENTRY, usageCardComponent, usageLines } from './bar/card.ts';
 import type { UsageCard } from './bar/card.ts';
 import { codexAdapter } from './query/codex.ts';
 import { kimiAdapter } from './query/kimi.ts';
@@ -8,7 +8,7 @@ import { openCodeGoAdapter } from './query/opencode-go.ts';
 import { QuotaController } from './query/controller.ts';
 import { createJsonClient } from './query/http.ts';
 import { AdapterRegistry } from './query/registry.ts';
-import type { ProviderAuth, QuotaAdapter } from './query/types.ts';
+import type { ProviderAuth, QuotaAdapter, QuotaState } from './query/types.ts';
 
 export const STATUS_EVENT = 'quota-bar:state:v1';
 const STATUS_KEY = 'quota-bar';
@@ -58,29 +58,64 @@ export function createQuotaExtension(options: QuotaExtensionOptions = {}) {
       }
     };
 
+    const getJson = createJsonClient();
+
     const controller = new QuotaController({
-      registry, getJson: createJsonClient(), intervalMs: options.intervalMs, timeoutMs: options.timeoutMs,
+      registry, getJson, intervalMs: options.intervalMs, timeoutMs: options.timeoutMs,
       onState(state) {
         paintFooter();
         pi.events.emit(STATUS_EVENT, state); // Structured data, no credentials or ANSI.
       },
     });
 
+    const resolveAuth = (ctx: ExtensionContext) => async (provider: string): Promise<ProviderAuth | undefined> => {
+      const resolved = await ctx.modelRegistry.getProviderAuth(provider);
+      if (!resolved) return undefined;
+      const headers: Record<string, string | undefined> = {};
+      for (const [name, value] of Object.entries(resolved.auth.headers ?? {})) {
+        if (typeof value === 'string') headers[name] = value;
+      }
+      const auth: ProviderAuth = { ...resolved.auth, headers };
+      // A model-level custom endpoint must not be mistaken for an official account.
+      if (ctx.model?.provider === provider && ctx.model.baseUrl) auth.baseUrl = ctx.model.baseUrl;
+      return auth;
+    };
+
     const refresh = (force = false): Promise<void> => {
       const ctx = current;
       if (!ctx?.hasUI) return Promise.resolve();
-      return controller.refresh(async provider => {
-        const resolved = await ctx.modelRegistry.getProviderAuth(provider);
-        if (!resolved) return undefined;
-        const headers: Record<string, string | undefined> = {};
-        for (const [name, value] of Object.entries(resolved.auth.headers ?? {})) {
-          if (typeof value === 'string') headers[name] = value;
+      return controller.refresh(resolveAuth(ctx), force);
+    };
+
+    const supportedProviders = (ctx: ExtensionContext): string[] => {
+      const providers: string[] = [];
+      const seen = new Set<string>();
+      const add = (provider: string | undefined) => {
+        if (provider && registry.get(provider) && !seen.has(provider)) {
+          seen.add(provider);
+          providers.push(provider);
         }
-        const auth: ProviderAuth = { ...resolved.auth, headers };
-        // A model-level custom endpoint must not be mistaken for an official account.
-        if (ctx.model?.provider === provider && ctx.model.baseUrl) auth.baseUrl = ctx.model.baseUrl;
-        return auth;
-      }, force);
+      };
+      add(ctx.model?.provider);
+      for (const model of ctx.modelRegistry.getAll()) add(model.provider);
+      return providers;
+    };
+
+    const queryProvider = async (provider: string, getAuth: ReturnType<typeof resolveAuth>): Promise<QuotaState> => {
+      const adapter = registry.get(provider);
+      if (!adapter) return { kind: 'error', provider, label: provider, code: 'unsupported-auth' };
+      if (provider === selectedProvider) {
+        // The footer already owns this provider's lifecycle and cache; do not fork it.
+        await controller.refresh(getAuth, true);
+        return controller.state;
+      }
+      const scratch = new QuotaController({
+        registry, getJson, intervalMs: options.intervalMs, timeoutMs: options.timeoutMs,
+        onState() {},
+      });
+      scratch.select(provider);
+      await scratch.refresh(getAuth, true);
+      return scratch.state;
     };
 
     const bind = (ctx: ExtensionContext, select = false, provider = ctx.model?.provider) => {
@@ -122,23 +157,24 @@ export function createQuotaExtension(options: QuotaExtensionOptions = {}) {
     });
 
     pi.registerCommand('usage', {
-      description: 'Query current provider quota and add a snapshot to the chat history',
+      description: 'Query quota for every configured supported provider and add snapshots to the chat history',
       handler: async (_args, ctx) => {
         if (!ctx.hasUI) return;
         bind(ctx);
         const generation = ++commandGeneration;
-        if (ctx.mode === 'tui') ctx.ui.setWidget(USAGE_WIDGET, ['Loading…']);
+        if (ctx.mode === 'tui') ctx.ui.setWidget(USAGE_WIDGET, ['Quota …']);
         try {
-          await refresh(true);
+          const getAuth = resolveAuth(ctx);
+          const providers = supportedProviders(ctx);
+          const states = await Promise.all(providers.map(provider => queryProvider(provider, getAuth)));
           // Never append via a stale Pi runtime, or label a replacement model's data
           // as the result of the original command. A newer command owns its result.
           if (!current || generation !== commandGeneration) return;
-          const card = captureUsage(controller.state);
-          if (!card) return;
+          const card = captureAllUsage(states);
           pi.appendEntry<UsageCard>(USAGE_ENTRY, card);
           // Custom entry renderers are TUI-only; RPC clients still get readable output.
           if (ctx.mode !== 'tui') {
-            ctx.ui.notify(renderUsage(card.state, undefined, card.capturedAt).join('\n'), 'info');
+            ctx.ui.notify(usageLines(card, undefined).join('\n'), 'info');
           }
         } finally {
           // An older request must not clear a newer command's loading indicator.

package/src/query/registry.ts

@@ -19,6 +19,10 @@ export class AdapterRegistry {
   get(provider: string | undefined): QuotaAdapter | undefined {
     return provider ? this.adapters.get(provider) : undefined;
   }
+
+  list(): readonly QuotaAdapter[] {
+    return [...this.adapters.values()];
+  }
 }
 
 // Validate even custom adapter output before it reaches the bar.