dsh-plugin-subscription-oauth 0.6.1 → 0.8.0

package/lib/auth/allowance-scheduler.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Cross-request memory of when each provider account's allowance resets.
+ *
+ * This is what lets one model id draw on the whole account pool without a wasted
+ * request: when the default account's allowance runs out, the moment it will refill is
+ * remembered, and until then the scheduler sends work straight to another account
+ * instead of trying the spent one, failing, and only then moving on. When the reset
+ * time passes the spent account is first choice again.
+ *
+ * The holder is shared by the route's reader (which learns reset times from usage
+ * reads) and its streamer (which consults them when picking an account), so the
+ * scheduler's view is exactly the last read's.
+ *
+ * @module dsh-plugin-subscription-oauth/auth/allowance-scheduler
+ */
+/** One account's remembered allowance state. */
+export interface AllowanceState {
+    /** Epoch milliseconds at which the account's allowance resets, when known. */
+    resetsAt?: number;
+    /** Epoch milliseconds at which this state was last learned. */
+    learnedAt: number;
+}
+/** In-memory, per-provider memory of account reset times. */
+export declare class AllowanceScheduler {
+    private readonly byProvider;
+    /** One provider's account states, creating the map on first use. */
+    private provider;
+    /**
+     * Record that one account's allowance resets at a given moment.
+     *
+     * @param provider - the provider route id.
+     * @param account - the account key.
+     * @param resetsAt - epoch milliseconds of the allowance reset, when known.
+     */
+    noteReset(provider: string, account: string, resetsAt?: number): void;
+    /**
+     * Whether one account's allowance is known to be spent now.
+     *
+     * True when the account was recorded with a reset time that is still in the future:
+     * its allowance is spent and will not refill until then, so a request should go to a
+     * different account rather than fail against this one.
+     *
+     * @param provider - the provider route id.
+     * @param account - the account key.
+     * @returns whether the account's allowance is spent until its remembered reset.
+     */
+    isSpentUntilReset(provider: string, account: string): boolean;
+    /**
+     * The moment one account's allowance is known to reset, when it was recorded.
+     *
+     * @param provider - the provider route id.
+     * @param account - the account key.
+     * @returns the reset instant, or undefined when unknown or already passed.
+     */
+    resetAt(provider: string, account: string): number | undefined;
+}
+/** The one shared scheduler every route reads and writes. */
+export declare const allowanceScheduler: AllowanceScheduler;

package/lib/auth/allowance-scheduler.js

@@ -0,0 +1,72 @@
+/**
+ * Cross-request memory of when each provider account's allowance resets.
+ *
+ * This is what lets one model id draw on the whole account pool without a wasted
+ * request: when the default account's allowance runs out, the moment it will refill is
+ * remembered, and until then the scheduler sends work straight to another account
+ * instead of trying the spent one, failing, and only then moving on. When the reset
+ * time passes the spent account is first choice again.
+ *
+ * The holder is shared by the route's reader (which learns reset times from usage
+ * reads) and its streamer (which consults them when picking an account), so the
+ * scheduler's view is exactly the last read's.
+ *
+ * @module dsh-plugin-subscription-oauth/auth/allowance-scheduler
+ */
+/** In-memory, per-provider memory of account reset times. */
+export class AllowanceScheduler {
+    byProvider = new Map();
+    /** One provider's account states, creating the map on first use. */
+    provider(provider) {
+        let map = this.byProvider.get(provider);
+        if (map === undefined) {
+            map = new Map();
+            this.byProvider.set(provider, map);
+        }
+        return map;
+    }
+    /**
+     * Record that one account's allowance resets at a given moment.
+     *
+     * @param provider - the provider route id.
+     * @param account - the account key.
+     * @param resetsAt - epoch milliseconds of the allowance reset, when known.
+     */
+    noteReset(provider, account, resetsAt) {
+        this.provider(provider).set(account, { ...resetsAt === undefined ? {} : { resetsAt }, learnedAt: Date.now() });
+    }
+    /**
+     * Whether one account's allowance is known to be spent now.
+     *
+     * True when the account was recorded with a reset time that is still in the future:
+     * its allowance is spent and will not refill until then, so a request should go to a
+     * different account rather than fail against this one.
+     *
+     * @param provider - the provider route id.
+     * @param account - the account key.
+     * @returns whether the account's allowance is spent until its remembered reset.
+     */
+    isSpentUntilReset(provider, account) {
+        const state = this.byProvider.get(provider)?.get(account);
+        if (state === undefined)
+            return false;
+        if (state.resetsAt === undefined)
+            return false;
+        return Date.now() < state.resetsAt;
+    }
+    /**
+     * The moment one account's allowance is known to reset, when it was recorded.
+     *
+     * @param provider - the provider route id.
+     * @param account - the account key.
+     * @returns the reset instant, or undefined when unknown or already passed.
+     */
+    resetAt(provider, account) {
+        const state = this.byProvider.get(provider)?.get(account);
+        if (state === undefined || state.resetsAt === undefined)
+            return undefined;
+        return Date.now() < state.resetsAt ? state.resetsAt : undefined;
+    }
+}
+/** The one shared scheduler every route reads and writes. */
+export const allowanceScheduler = new AllowanceScheduler();

package/lib/auth/ccswitch.d.ts

@@ -24,13 +24,38 @@ export interface CcSwitchBalance {
     /** Whether the account reports itself as usable. */
     available: boolean;
 }
+/**
+ * Query the balance endpoint some OpenAI-compatible providers expose at `{base}/v1/usage`.
+ *
+ * huanling is one: it answers `GET {base}/v1/usage` with `{ remaining, unit, … }`, which is
+ * the figure cc-switch shows for it. This is the provider's own shape, not cc-switch's
+ * `balance_infos`, so it is read separately. The base has any trailing `/v1` stripped before
+ * the path is added, so both `https://api.huanling.icu` and `https://api.huanling.icu/v1`
+ * resolve to the same `{base}/v1/usage`.
+ *
+ * @param input - the provider's API key and base URL.
+ * @returns the balance, or undefined when the provider did not answer with one.
+ */
+export declare function queryUsageBalance(input: {
+    apiKey: string;
+    baseUrl: string;
+    fetchFn?: FetchFn;
+}): Promise<CcSwitchBalance | undefined>;
 /**
  * Query one provider's balance the way cc-switch does.
  *
- * @param input - the provider's API key, and optionally a fetch to substitute in tests.
+ * cc-switch reads a DeepSeek-compatible provider's balance with `GET <base>/user/balance`
+ * and a bearer API key. For the official DeepSeek that base is `api.deepseek.com`, so the
+ * path is effectively hardcoded there; for a provider the user added through a custom
+ * endpoint (like huanling), the same path is read against that provider's own base URL,
+ * which is the only place its balance can live.
+ *
+ * @param input - the provider's API key and base URL.
  * @returns the balance, or undefined when the provider did not answer with one.
  */
 export declare function queryCcSwitchBalance(input: {
     apiKey: string;
+    /** The provider's own base URL; `https://api.deepseek.com` for the official one. */
+    baseUrl: string;
     fetchFn?: FetchFn;
 }): Promise<CcSwitchBalance | undefined>;

package/lib/auth/ccswitch.js

@@ -23,18 +23,75 @@ function num(value) {
         return value.trim();
     return undefined;
 }
+/**
+ * Query the balance endpoint some OpenAI-compatible providers expose at `{base}/v1/usage`.
+ *
+ * huanling is one: it answers `GET {base}/v1/usage` with `{ remaining, unit, … }`, which is
+ * the figure cc-switch shows for it. This is the provider's own shape, not cc-switch's
+ * `balance_infos`, so it is read separately. The base has any trailing `/v1` stripped before
+ * the path is added, so both `https://api.huanling.icu` and `https://api.huanling.icu/v1`
+ * resolve to the same `{base}/v1/usage`.
+ *
+ * @param input - the provider's API key and base URL.
+ * @returns the balance, or undefined when the provider did not answer with one.
+ */
+export async function queryUsageBalance(input) {
+    const fetchFn = input.fetchFn ?? proxiedFetch;
+    const base = input.baseUrl.replace(/\/+$/, '').replace(/\/v1$/i, '');
+    const url = `${base}/v1/usage`;
+    let response;
+    try {
+        response = await fetchFn(url, {
+            headers: { authorization: `Bearer ${input.apiKey}`, accept: 'application/json' },
+            signal: AbortSignal.timeout(15_000),
+        });
+    }
+    catch {
+        return undefined;
+    }
+    if (!response.ok)
+        return undefined;
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof payload !== 'object' || payload === null)
+        return undefined;
+    const record = payload;
+    const total = num(record.remaining);
+    if (total === undefined)
+        return undefined;
+    const currency = typeof record.unit === 'string' && record.unit.trim() !== '' ? record.unit.trim() : 'USD';
+    return {
+        currency,
+        total,
+        available: record.isValid !== false && record.is_active !== false,
+    };
+}
 /**
  * Query one provider's balance the way cc-switch does.
  *
- * @param input - the provider's API key, and optionally a fetch to substitute in tests.
+ * cc-switch reads a DeepSeek-compatible provider's balance with `GET <base>/user/balance`
+ * and a bearer API key. For the official DeepSeek that base is `api.deepseek.com`, so the
+ * path is effectively hardcoded there; for a provider the user added through a custom
+ * endpoint (like huanling), the same path is read against that provider's own base URL,
+ * which is the only place its balance can live.
+ *
+ * @param input - the provider's API key and base URL.
  * @returns the balance, or undefined when the provider did not answer with one.
  */
 export async function queryCcSwitchBalance(input) {
     const fetchFn = input.fetchFn ?? proxiedFetch;
+    // Resolve `<base>/user/balance` without doubling or dropping the path: a base that
+    // already ends in `/v1` keeps it, since that is the path the OpenAI-compatible wire
+    // uses and the balance endpoint lives beside it.
+    const url = `${input.baseUrl.replace(/\/+$/, '')}/user/balance`;
     let response;
     try {
-        // cc-switch's exact request shape: hardcoded URL, bearer auth, 15 s timeout.
-        response = await fetchFn('https://api.deepseek.com/user/balance', {
+        response = await fetchFn(url, {
             headers: { authorization: `Bearer ${input.apiKey}`, accept: 'application/json' },
             signal: AbortSignal.timeout(15_000),
         });

package/lib/auth/rpc.d.ts

@@ -16,6 +16,8 @@ export type CredentialResolver = (ref: string) => Promise<string | undefined>;
 export interface BalanceContext {
     /** The credential reference each provider id's balance query uses. */
     readonly credentialRefs: Readonly<Record<string, string>>;
+    /** The base URL each provider id's balance query reads, when it is not DeepSeek's own. */
+    readonly baseUrls: Readonly<Record<string, string>>;
     /** Resolve one credential reference to its key. */
     readonly resolveCredential?: CredentialResolver;
     /**

package/lib/auth/rpc.js

@@ -1,5 +1,5 @@
 import { BAD_REQUEST, ProviderError } from '../errors.js';
-import { queryCcSwitchBalance } from './ccswitch.js';
+import { queryCcSwitchBalance, queryUsageBalance } from './ccswitch.js';
 import { readDeepSeekBalance } from './deepseek-balance.js';
 import { RPC_ENDPOINTS, RPC_PREFIX } from '../protocol.js';
 /** Wrap a value as a successful envelope result. */
@@ -165,11 +165,12 @@ async function runEndpoint(registry, endpoint, payload, balance) {
             return await readDeepSeekBalance(balance?.resolveDeepSeekAccount?.(), client);
         }
         case 'ccswitch-balance': {
-            // A non-subscription provider's balance, by cc-switch's query. The caller names
-            // the provider; the configured map turns that into the credential reference the
-            // provider's profile uses, and the host's credential service resolves it. No
-            // entry, no key, or a key the provider does not answer for means no balance —
-            // never a fabricated zero.
+            // A non-subscription provider's balance, by cc-switch's query against the provider's
+            // own base URL. The caller names the provider; the configured map turns that into
+            // the credential reference the provider's profile uses and the base URL that profile
+            // connects to, and the host's credential service resolves the reference. No entry,
+            // no key, or a key the provider does not answer for means no balance — never a
+            // fabricated zero.
             const provider = requiredProvider(payload, endpoint);
             const credentialRef = balance?.credentialRefs[provider];
             if (credentialRef === undefined || balance?.resolveCredential === undefined)
@@ -177,7 +178,12 @@ async function runEndpoint(registry, endpoint, payload, balance) {
             const apiKey = await balance.resolveCredential(credentialRef);
             if (apiKey === undefined)
                 return undefined;
-            return await queryCcSwitchBalance({ apiKey });
+            const baseUrl = balance?.baseUrls[provider] ?? 'https://api.deepseek.com';
+            // A provider that answers the OpenAI-compatible `/v1/usage` (the shape cc-switch's
+            // custom template reads, `{ remaining, unit }`) is asked that first; one that
+            // answers the DeepSeek `balance_infos` shape is asked that as a fallback.
+            return await queryUsageBalance({ apiKey, baseUrl })
+                ?? await queryCcSwitchBalance({ apiKey, baseUrl });
         }
         case 'reload':
             return registry.reload();

package/lib/client/UsageChip.d.ts

@@ -117,10 +117,12 @@ export declare function balanceOf(value: {
  * Format one wallet for the chip's compact line.
  *
  * A balance is money, not a percentage, so it renders as `¥6.89` rather than a meter;
- * the currency prefix keeps two currencies from being mistaken for one sum.
+ * the currency prefix keeps two currencies from being mistaken for one sum. The amount
+ * is rounded to two decimal places (a balance reads to the cent, and a figure like
+ * `1.1` for `1.10` would mislead) and always carries both places.
  *
  * @param wallet - the wallet to show.
- * @returns the short form, e.g. `¥6.89` or `+¥2` for a bonus wallet.
+ * @returns the short form, e.g. `¥6.89` or `+$2.00` for a bonus wallet.
  */
 export declare function formatBalance(wallet: ChipBalance): string;
 /**
@@ -157,6 +159,60 @@ export declare function pickWindow(windows: readonly UsageWindow[]): UsageWindow
  * @param usage - the accounts the route answered for.
  * @returns the reading, or undefined when the route stated no figure.
  */
+/** What one account's allowance reduces to for the chip. */
+export interface AccountReading {
+    /** Which account these figures belong to. */
+    account: string;
+    /** Plan name, when the provider stated one. */
+    plan?: string;
+    /** Every metered window, in the order the route stated them. */
+    windows: readonly UsageWindow[];
+}
+/**
+ * Reduce a route's per-account usage to one reading per account.
+ *
+ * A provider can hold several accounts (two Antigravity sign-ins, say), and the chip
+ * shows each one's allowance on its own line, the way the settings cards do — a merged
+ * figure would hide that one account is exhausted while the other is free.
+ *
+ * @param usage - every account the route answered for.
+ * @returns one reading per account that states a figure, in the route's order.
+ */
+/**
+ * Reduce a route's per-account usage to one reading per account.
+ *
+ * A provider can hold several accounts (two Antigravity sign-ins, say). Every account's
+ * windows are kept as the route stated them — a percentage-metered quota and a credit
+ * balance (`credits`) alike — so the per-account panel shows the real figures, and the
+ * compact line's merge decides which to integrate.
+ *
+ * @param usage - every account the route answered for.
+ * @returns one reading per account that states any window, in the route's order.
+ */
+export declare function accountReadingsOf(usage: readonly ProviderUsage[]): readonly AccountReading[];
+/**
+ * Merge every account's percentage-metered windows into one figure per label.
+ *
+ * The chip's compact line integrates the whole pool: two accounts at 50 percent read as
+ * one window at 50 percent (the same allowance spent twice as wide), not two lines. A
+ * credit balance (`credits`) is money, not a share of a shared allowance, so it is not
+ * merged — it stays on the per-account panel, where it reads correctly. Only windows
+ * that state a `usedPercent` (a share of an allowance) merge.
+ *
+ * @param readings - one per account, from {@link accountReadingsOf}.
+ * @returns one merged window per percentage-metered label, most-spent first.
+ */
+export declare function mergeAccountWindows(readings: readonly AccountReading[]): readonly UsageWindow[];
+/**
+ * Reduce one route's usage to the single line the compact chip renders.
+ *
+ * Kept for the balance-free providers that still show one merged line.
+ *
+ * @param provider - the route id.
+ * @param label - the route's display name.
+ * @param usage - the accounts the route answered for.
+ * @returns the first account's reading, or undefined when none states a figure.
+ */
 export declare function readingOf(provider: string, label: string, usage: readonly ProviderUsage[]): ChipReading | undefined;
 /**
  * Format a window's reset the way the settings cards do.

package/lib/client/UsageChip.js

@@ -82,14 +82,16 @@ export function balanceOf(value) {
  * Format one wallet for the chip's compact line.
  *
  * A balance is money, not a percentage, so it renders as `¥6.89` rather than a meter;
- * the currency prefix keeps two currencies from being mistaken for one sum.
+ * the currency prefix keeps two currencies from being mistaken for one sum. The amount
+ * is rounded to two decimal places (a balance reads to the cent, and a figure like
+ * `1.1` for `1.10` would mislead) and always carries both places.
  *
  * @param wallet - the wallet to show.
- * @returns the short form, e.g. `¥6.89` or `+¥2` for a bonus wallet.
+ * @returns the short form, e.g. `¥6.89` or `+$2.00` for a bonus wallet.
  */
 export function formatBalance(wallet) {
     const amount = Number.parseFloat(wallet.balance);
-    const trimmed = Number.isFinite(amount) ? String(Math.round(amount * 100) / 100) : wallet.balance;
+    const trimmed = Number.isFinite(amount) ? amount.toFixed(2) : wallet.balance;
     const symbol = wallet.currency === 'CNY' ? '¥' : wallet.currency === 'USD' ? '$' : `${wallet.currency} `;
     return `${wallet.bonus ? '+' : ''}${symbol}${trimmed}`;
 }
@@ -142,12 +144,90 @@ export function pickWindow(windows) {
     return best;
 }
 /**
- * Reduce one route's usage to what the chip renders.
+ * Reduce a route's per-account usage to one reading per account.
  *
- * @param provider - the route the figures came from.
+ * A provider can hold several accounts (two Antigravity sign-ins, say), and the chip
+ * shows each one's allowance on its own line, the way the settings cards do — a merged
+ * figure would hide that one account is exhausted while the other is free.
+ *
+ * @param usage - every account the route answered for.
+ * @returns one reading per account that states a figure, in the route's order.
+ */
+/**
+ * Reduce a route's per-account usage to one reading per account.
+ *
+ * A provider can hold several accounts (two Antigravity sign-ins, say). Every account's
+ * windows are kept as the route stated them — a percentage-metered quota and a credit
+ * balance (`credits`) alike — so the per-account panel shows the real figures, and the
+ * compact line's merge decides which to integrate.
+ *
+ * @param usage - every account the route answered for.
+ * @returns one reading per account that states any window, in the route's order.
+ */
+export function accountReadingsOf(usage) {
+    const out = [];
+    for (const entry of usage) {
+        if (entry.windows.length === 0)
+            continue;
+        out.push({ account: entry.account, windows: entry.windows, ...entry.plan === undefined ? {} : { plan: entry.plan } });
+    }
+    return out;
+}
+/**
+ * Merge every account's percentage-metered windows into one figure per label.
+ *
+ * The chip's compact line integrates the whole pool: two accounts at 50 percent read as
+ * one window at 50 percent (the same allowance spent twice as wide), not two lines. A
+ * credit balance (`credits`) is money, not a share of a shared allowance, so it is not
+ * merged — it stays on the per-account panel, where it reads correctly. Only windows
+ * that state a `usedPercent` (a share of an allowance) merge.
+ *
+ * @param readings - one per account, from {@link accountReadingsOf}.
+ * @returns one merged window per percentage-metered label, most-spent first.
+ */
+export function mergeAccountWindows(readings) {
+    const byLabel = new Map();
+    for (const reading of readings) {
+        for (const window of reading.windows) {
+            // Only a percentage-metered window merges. A credit balance (a bare used/limit
+            // pair) is money, not a share of a shared allowance, and averaging it across
+            // accounts would misread money as a quota.
+            if (window.usedPercent === undefined)
+                continue;
+            const list = byLabel.get(window.label) ?? [];
+            list.push(window);
+            byLabel.set(window.label, list);
+        }
+    }
+    const merged = [];
+    for (const [label, list] of byLabel) {
+        // Percentages average across accounts: the pool's spent share is the mean of each
+        // account's spent share (accounts share an allowance, they do not add to it).
+        const withPercent = list.filter((window) => window.usedPercent !== undefined);
+        if (withPercent.length === 0)
+            continue;
+        const usedPercent = withPercent.reduce((sum, window) => sum + (window.usedPercent ?? 0), 0) / withPercent.length;
+        // The pool's reset is the soonest account reset: the window refills when the first
+        // account's does.
+        const resets = list.map((window) => window.resetsAt).filter((at) => typeof at === 'number');
+        merged.push({
+            label,
+            usedPercent: Math.max(0, Math.min(100, usedPercent)),
+            ...resets.length === 0 ? {} : { resetsAt: Math.min(...resets) },
+        });
+    }
+    // Most-spent first, so the line leads with the window that will stop work soonest.
+    return merged.sort((left, right) => (right.usedPercent ?? 0) - (left.usedPercent ?? 0));
+}
+/**
+ * Reduce one route's usage to the single line the compact chip renders.
+ *
+ * Kept for the balance-free providers that still show one merged line.
+ *
+ * @param provider - the route id.
  * @param label - the route's display name.
  * @param usage - the accounts the route answered for.
- * @returns the reading, or undefined when the route stated no figure.
+ * @returns the first account's reading, or undefined when none states a figure.
  */
 export function readingOf(provider, label, usage) {
     for (const entry of usage) {
@@ -197,6 +277,7 @@ export function formatReset(at, now) {
  */
 export function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, useProjection }) {
     const [reading, setReading] = useState(undefined);
+    const [accountReadings, setAccountReadings] = useState(undefined);
     const [balance, setBalance] = useState(undefined);
     const [ccBalance, setCcBalance] = useState(undefined);
     const [now, setNow] = useState(() => Date.now());
@@ -239,8 +320,7 @@ export function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBala
     const load = useCallback(async (target) => {
         try {
             const result = await call('usage', { provider: target });
-            const label = result.status.providers.find((entry) => entry.provider === target)?.displayName ?? target;
-            return readingOf(target, label, result.usage);
+            return accountReadingsOf(result.usage);
         }
         catch {
             // A failed read is not worth a chip of its own: the settings page is where a user
@@ -276,7 +356,7 @@ export function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBala
             // Not one of ours (or none selected): keep showing the last own reading.
             : lastOwn.current;
         if (target === undefined) {
-            setReading(undefined);
+            setAccountReadings(undefined);
             return;
         }
         let live = true;
@@ -286,7 +366,7 @@ export function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBala
                 if (!live || next === undefined)
                     return;
                 lastOwn.current = target;
-                setReading(next);
+                setAccountReadings(next);
             });
         };
         refresh();
@@ -327,20 +407,22 @@ export function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBala
                         setOpen((was) => !was);
                     }, children: [_jsx("span", { className: "dsh-subscription-usage-chip-label", children: short }), balance.map((wallet) => (_jsx("span", { className: "dsh-subscription-usage-chip-cell", children: _jsx("span", { className: "dsh-subscription-usage-chip-value", children: formatBalance(wallet) }) }, `${wallet.currency}${wallet.bonus ? ':bonus' : ''}`)))] }), open && (_jsxs("span", { className: "dsh-subscription-usage-chip-panel", role: "status", children: [_jsx("span", { className: "dsh-subscription-usage-chip-full", children: t('usageChipFull', { provider: 'DeepSeek Account' }) }), balance.map((wallet) => (_jsx("span", { className: "dsh-subscription-usage-chip-meter", children: _jsxs("span", { className: "dsh-subscription-usage-chip-meterHead", children: [_jsx("span", { children: `${wallet.bonus ? 'Bonus · ' : ''}${wallet.currency}` }), _jsx("span", { className: "dsh-subscription-usage-chip-detail", children: formatBalance(wallet) })] }) }, `${wallet.currency}${wallet.bonus ? ':bonus' : ''}`)))] }))] }));
     }
-    if (reading === undefined)
-        return null;
-    const percent = reading.window.usedPercent;
-    if (percent === undefined)
+    if (accountReadings === undefined || accountReadings.length === 0)
         return null;
-    const reset = formatReset(reading.window.resetsAt, now);
-    const clamped = Math.max(0, Math.min(100, percent));
-    const short = shortLabel(reading.provider, reading.label);
-    return (_jsxs("span", { className: "dsh-subscription-usage-chip", children: [_jsx("style", { children: usageChipCss }), _jsxs("button", { type: "button", className: "dsh-subscription-usage-chip-trigger", "aria-expanded": open, title: t('usageChipTitle', { provider: reading.label }), onClick: (event) => {
+    const short = shortLabel(selected ?? '', selected ?? '');
+    // The compact line integrates the whole pool; the panel shows each account's own
+    // figures, so a merged glance hides nothing a per-account look cannot recover.
+    const merged = mergeAccountWindows(accountReadings);
+    return (_jsxs("span", { className: "dsh-subscription-usage-chip", children: [_jsx("style", { children: usageChipCss }), _jsxs("button", { type: "button", className: "dsh-subscription-usage-chip-trigger", "aria-expanded": open, title: t('usageChipTitle', { provider: selected ?? '' }), onClick: (event) => {
                     // The document listener would otherwise close what this click just opened.
                     event.stopPropagation();
                     setOpen((was) => !was);
-                }, children: [_jsx("span", { className: "dsh-subscription-usage-chip-label", children: short }), reading.windows.map((window) => (_jsxs("span", { className: "dsh-subscription-usage-chip-cell", children: [_jsx("span", { className: "dsh-subscription-usage-chip-window", children: shortWindow(window.label) }), _jsx("span", { className: "dsh-subscription-usage-chip-value", children: `${String(Math.round(window.usedPercent ?? 0))}%` })] }, window.label)))] }), open && (_jsxs("span", { className: "dsh-subscription-usage-chip-panel", role: "status", children: [_jsx("span", { className: "dsh-subscription-usage-chip-full", children: t('usageChipFull', { provider: reading.label }) }), reading.windows.map((window) => {
-                        const windowReset = formatReset(window.resetsAt, now);
-                        return (_jsxs("span", { className: "dsh-subscription-usage-chip-meter", children: [_jsxs("span", { className: "dsh-subscription-usage-chip-meterHead", children: [_jsx("span", { children: window.label }), _jsx("span", { className: "dsh-subscription-usage-chip-detail", children: `${String(Math.round(window.usedPercent ?? 0))}%${windowReset === undefined ? '' : ` · ${windowReset}`}` })] }), _jsx("span", { className: "dsh-subscription-usage-chip-track", "aria-hidden": "true", children: _jsx("span", { className: "dsh-subscription-usage-chip-fill", style: { width: `${String(Math.max(0, Math.min(100, window.usedPercent ?? 0)))}%` } }) })] }, window.label));
-                    }), reading.plan === undefined ? null : (_jsx("span", { className: "dsh-subscription-usage-chip-detail", children: reading.plan }))] }))] }));
+                }, children: [_jsx("span", { className: "dsh-subscription-usage-chip-label", children: short }), merged.map((window) => (_jsxs("span", { className: "dsh-subscription-usage-chip-cell", children: [_jsx("span", { className: "dsh-subscription-usage-chip-window", children: shortWindow(window.label) }), _jsx("span", { className: "dsh-subscription-usage-chip-value", children: `${String(Math.round(window.usedPercent ?? 0))}%` })] }, window.label)))] }), open && (_jsxs("span", { className: "dsh-subscription-usage-chip-panel", role: "status", children: [_jsx("span", { className: "dsh-subscription-usage-chip-full", children: t('usageChipFull', { provider: selected ?? '' }) }), accountReadings.map((account) => (_jsxs("span", { className: "dsh-subscription-usage-chip-account", children: [_jsx("span", { className: "dsh-subscription-usage-chip-meterHead", children: _jsx("span", { children: account.plan ?? account.account }) }), account.windows.map((window) => {
+                                const windowReset = formatReset(window.resetsAt, now);
+                                // A credit balance reads as money (`used`/`limit`), a quota as a percent.
+                                const amount = window.usedPercent === undefined && window.used !== undefined && window.limit !== undefined
+                                    ? `${String(window.used)}/${String(window.limit)}`
+                                    : `${String(Math.round(window.usedPercent ?? 0))}%`;
+                                return (_jsxs("span", { className: "dsh-subscription-usage-chip-meter", children: [_jsxs("span", { className: "dsh-subscription-usage-chip-meterHead", children: [_jsx("span", { children: window.label }), _jsx("span", { className: "dsh-subscription-usage-chip-detail", children: `${amount}${windowReset === undefined ? '' : ` · ${windowReset}`}` })] }), window.usedPercent !== undefined && (_jsx("span", { className: "dsh-subscription-usage-chip-track", "aria-hidden": "true", children: _jsx("span", { className: "dsh-subscription-usage-chip-fill", style: { width: `${String(Math.max(0, Math.min(100, window.usedPercent ?? 0)))}%` } }) }))] }, window.label));
+                            })] }, account.account)))] }))] }));
 }