@astrosheep/pi-quota 0.5.0 → 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
 
@@ -41,12 +41,12 @@ Use the **exact Pi provider ID**. Only selected, explicitly bound providers are
 | Adapter | Endpoint | Result |
 |---|---|---|
 | `sub2api` | `{baseUrl}/usage` | Wallet, key quota, rate windows or subscription day/week/month windows; API-key Today/Lifetime actual spend |
-| `new-api` | Account PAT `/api/user/self`, falling back to key-native billing/token endpoints | Account or key balance; **not** a renewable window |
+| `new-api` | Account PAT `/api/user/self`, falling back to key-native billing/token endpoints | Account balance + lifetime spend; finite key quota when explicitly granted; **not** a renewable window |
 | `deepseek` | Official `/user/balance` | Balance only; no invented spend |
 
 Sub2API accepts no extra settings; it preserves deployment subpaths. Rate-only keys need not expose a top-level currency (rates are USD). Unknown rate-window durations and invalid limits fail rather than inventing a 1d window. Subscription periods without a cap are omitted. Its dashboard `/api/v1/usage` is a separate, JWT-authenticated paginated request log; the adapter uses the API-key `/v1/usage` instead.
 
-For new-api, `quotaPerUnit` defaults to `500000`, `currency` to `USD`. Optionally add `dashboardAccessToken` (console system access token) and `dashboardUserId` (positive numeric ID required by some old forks) to that provider. This PAT is the **only** optional secret kept in settings. The account endpoint takes precedence; failures fall back to the key-native billing and token usage paths. Without a PAT, an API key cannot read the dashboard account quota. Values in settings and server error bodies are never logged.
+For new-api, `quotaPerUnit` defaults to `500000`, `currency` to `USD`. Optionally add `dashboardAccessToken` (console system access token) and `dashboardUserId` (positive numeric ID required by some old forks) to that provider. This PAT is the **only** optional secret kept in settings. The account endpoint takes precedence; failures fall back to the key-native billing and token usage paths. Without a PAT, an API key cannot read the dashboard account quota. A finite key reports a quota bar only when `total_granted` is present and consistent with used plus remaining; otherwise it shows a balance and lifetime spend, without inventing a limit. Values in settings and server error bodies are never logged.
 
 Authenticated quota URLs must use HTTPS, except HTTP loopback for local deployments. URL userinfo, query strings, fragments and HTTP redirects are rejected; credentials never follow redirects. Fixed official endpoints reject custom origins. No browser cookie scraping or credential discovery.
 
@@ -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.0",
-  "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/new-api.ts

@@ -2,7 +2,9 @@ import { bearer } from './http.ts';
 import { numeric, object } from './parse.ts';
 import { QuotaError } from './types.ts';
 import { safeBaseUrl } from './url.ts';
-import type { AccountBalance, QuotaAdapter } from './types.ts';
+import type { QuotaAdapter, QuotaSnapshot } from './types.ts';
+
+type Amounts = Pick<QuotaSnapshot, 'balance' | 'allowance' | 'spend'>;
 
 export interface NewApiOptions {
   quotaPerUnit?: number;
@@ -33,29 +35,40 @@ export function newApiRootUrl(baseUrl: string | undefined): string {
 // GET /api/usage/token (new-api >= v0.9.0-alpha.8, PR QuantumNous/new-api#1161):
 // accepts the sk- model key itself (TokenAuth), returns per-token quota in
 // the same unit as /api/user/self quota. Response shell: {code:true,data:{...}}.
-export function parseNewApiTokenUsage(payload: unknown, options: NewApiOptions = {}): AccountBalance | null {
+export function parseNewApiTokenUsage(payload: unknown, options: NewApiOptions = {}): Amounts | null {
   const { quotaPerUnit, currency } = validateNewApiOptions(options);
   const response = object(payload);
   if (response.code !== true) return null;
   const data = object(response.data);
   if (data.object !== 'token_usage') return null;
   const used = numeric(data.total_used);
-  // Missing fields must not become a made-up zero balance.
   if (used === null || !Number.isSafeInteger(used) || used < 0) throw new QuotaError('schema');
   if (data.unlimited_quota === true) {
-    return { currency, remaining: 0, unlimited: true };
+    return { balance: { currency, remaining: 0, unlimited: true },
+      spend: { currency, lifetime: used / quotaPerUnit } };
   }
   const remaining = numeric(data.total_available);
   if (remaining === null || !Number.isSafeInteger(remaining)) throw new QuotaError('schema');
-  const balance = { currency, remaining: remaining / quotaPerUnit };
-  if (!Number.isFinite(balance.remaining)) throw new QuotaError('schema');
-  return balance;
+  const moneyLeft = remaining / quotaPerUnit;
+  if (!Number.isFinite(moneyLeft)) throw new QuotaError('schema');
+
+  // New-api reports granted = key used + key remaining. Only draw a finite
+  // allocation bar when the server actually supplies that total.
+  if (data.total_granted !== undefined) {
+    const granted = numeric(data.total_granted);
+    if (granted === null || !Number.isSafeInteger(granted) || granted < 0
+      || !Number.isSafeInteger(used + remaining) || granted !== used + remaining) throw new QuotaError('schema');
+    if (granted > 0) return { allowance: { currency, limit: granted / quotaPerUnit,
+      used: used / quotaPerUnit, remaining: moneyLeft } };
+  }
+  return { balance: { currency, remaining: moneyLeft },
+    spend: { currency, lifetime: used / quotaPerUnit } };
 }
 
 // GET /api/user/self (UserAuth): the console's own account quota, readable with
 // a dashboard access token (PAT), which sk- keys are not. Old forks also demand
 // a matching New-Api-User header. Response shell: {success:true,data:{...}}.
-export function parseNewApiUserSelf(payload: unknown, options: NewApiOptions = {}): AccountBalance {
+export function parseNewApiUserSelf(payload: unknown, options: NewApiOptions = {}): Amounts {
   const { quotaPerUnit, currency } = validateNewApiOptions(options);
   const response = object(payload);
   if (response.success !== true) throw new QuotaError('schema');
@@ -65,13 +78,14 @@ export function parseNewApiUserSelf(payload: unknown, options: NewApiOptions = {
   if (quota === null || usedQuota === null
     || !Number.isSafeInteger(quota) || !Number.isSafeInteger(usedQuota)
     || quota < 0 || usedQuota < 0) throw new QuotaError('schema');
-  return { currency, remaining: quota / quotaPerUnit };
+  return { balance: { currency, remaining: quota / quotaPerUnit },
+    spend: { currency, lifetime: usedQuota / quotaPerUnit } };
 }
 
 // Legacy one-api billing pair, still the only option on older deployments.
 // total_usage is in cents (divide by 100, per one-api issue #1785); most
 // deployments report a fake 1e8 hard limit for unlimited quotas.
-export function parseNewApiBilling(subscription: unknown, usage: unknown, options: NewApiOptions = {}): AccountBalance {
+export function parseNewApiBilling(subscription: unknown, usage: unknown, options: NewApiOptions = {}): Amounts {
   const { currency } = validateNewApiOptions(options);
   const sub = object(subscription);
   const limit = numeric(sub.hard_limit_usd);
@@ -80,8 +94,12 @@ export function parseNewApiBilling(subscription: unknown, usage: unknown, option
   if (limit === null || !Number.isFinite(limit) || limit < 0
     || totalUsage === null || !Number.isFinite(totalUsage) || totalUsage < 0) throw new QuotaError('schema');
   const used = totalUsage / 100;
-  if (limit >= 1e7) return { currency, remaining: 0, unlimited: true };
-  return { currency, remaining: limit - used };
+  // This endpoint reports account remaining + lifetime usage as its hard limit.
+  // Top-ups change that total, so it is a wallet balance, not a fixed allowance.
+  if (limit >= 1e7) return { balance: { currency, remaining: 0, unlimited: true },
+    spend: { currency, lifetime: used } };
+  return { balance: { currency, remaining: limit - used },
+    spend: { currency, lifetime: used } };
 }
 
 export function createNewApiAdapter(provider: string, options: NewApiOptions = {}): QuotaAdapter {
@@ -111,7 +129,7 @@ export function createNewApiAdapter(provider: string, options: NewApiOptions = {
         if (dashboardUserId !== undefined) headers['New-Api-User'] = String(dashboardUserId);
         try {
           const payload = await context.getJson(`${root}/api/user/self`, headers, context.signal);
-          return { windows: [], balance: parseNewApiUserSelf(payload, settings), fetchedAt: context.now() };
+          return { windows: [], ...parseNewApiUserSelf(payload, settings), fetchedAt: context.now() };
         } catch (error) {
           if (!(error instanceof QuotaError)) throw error;
         }
@@ -120,14 +138,14 @@ export function createNewApiAdapter(provider: string, options: NewApiOptions = {
       // 1. Account billing (one-api legacy): a finite hard limit is the real
       // account balance. 1e8 means unlimited — then the key quota may still
       // be finite and more precise.
-      let billingBalance: AccountBalance | null = null;
+      let billingBalance: Amounts | null = null;
       try {
         const pair = await Promise.all([
           context.getJson(`${root}/v1/dashboard/billing/subscription`, headers, context.signal),
           context.getJson(`${root}/v1/dashboard/billing/usage?start_date=2020-01-01&end_date=2100-01-01`, headers, context.signal),
         ]);
         const billing = parseNewApiBilling(pair[0], pair[1], settings);
-        if (billing.unlimited !== true) return { windows: [], balance: billing, fetchedAt: context.now() };
+        if (billing.balance?.unlimited !== true) return { windows: [], ...billing, fetchedAt: context.now() };
         billingBalance = billing;
       } catch (error) {
         // 404: deployment has no billing pair. 401: try the key-native endpoint
@@ -139,15 +157,15 @@ export function createNewApiAdapter(provider: string, options: NewApiOptions = {
       try {
         const payload = await context.getJson(`${root}/api/usage/token/`, headers, context.signal);
         const parsed = parseNewApiTokenUsage(payload, settings);
-        if (parsed) return { windows: [], balance: parsed, fetchedAt: context.now() };
+        if (parsed) return { windows: [], ...parsed, fetchedAt: context.now() };
       } catch (error) {
         if (billingBalance && error instanceof QuotaError && error.code === 'http') {
-          return { windows: [], balance: billingBalance, fetchedAt: context.now() };
+          return { windows: [], ...billingBalance, fetchedAt: context.now() };
         }
         if (error instanceof QuotaError && error.code === 'auth') throw new QuotaError('account-access');
         throw error;
       }
-      if (billingBalance) return { windows: [], balance: billingBalance, fetchedAt: context.now() };
+      if (billingBalance) return { windows: [], ...billingBalance, fetchedAt: context.now() };
       throw new QuotaError('schema');
     },
   };

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.