@leo000001/opencode-quota-sidebar 3.0.9 → 4.0.0

package/dist/provider_catalog.js

@@ -0,0 +1,68 @@
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function providerListFromResponse(response) {
+    const data = isRecord(response) && Object.prototype.hasOwnProperty.call(response, 'data')
+        ? response.data
+        : undefined;
+    const record = isRecord(data) ? data : undefined;
+    return Array.isArray(record?.providers)
+        ? record.providers
+        : Array.isArray(record?.all)
+            ? record.all
+            : Array.isArray(data)
+                ? data
+                : undefined;
+}
+export async function listCurrentProviderIDs(input) {
+    const client = input.client;
+    const ids = new Set();
+    const collect = (response) => {
+        const list = providerListFromResponse(response);
+        if (!list)
+            return false;
+        for (const item of list) {
+            if (!isRecord(item))
+                continue;
+            if (typeof item.id === 'string' && item.id)
+                ids.add(item.id);
+        }
+        return ids.size > 0;
+    };
+    if (client.config?.providers) {
+        const response = await client.config.providers({
+            query: { directory: input.directory },
+            throwOnError: true,
+        });
+        if (collect(response))
+            return ids;
+    }
+    if (client.provider?.list) {
+        const response = await client.provider.list({
+            query: { directory: input.directory },
+            throwOnError: true,
+        });
+        collect(response);
+    }
+    return ids;
+}
+export function filterUsageProvidersForDisplay(usage, allowedProviderIDs) {
+    if (allowedProviderIDs.size === 0)
+        return usage;
+    return {
+        ...usage,
+        providers: Object.fromEntries(Object.entries(usage.providers).filter(([providerID]) => allowedProviderIDs.has(providerID))),
+    };
+}
+export function filterHistoryProvidersForDisplay(result, allowedProviderIDs) {
+    if (allowedProviderIDs.size === 0)
+        return result;
+    return {
+        ...result,
+        rows: result.rows.map((row) => ({
+            ...row,
+            usage: filterUsageProvidersForDisplay(row.usage, allowedProviderIDs),
+        })),
+        total: filterUsageProvidersForDisplay(result.total, allowedProviderIDs),
+    };
+}

package/dist/providers/core/anthropic.d.ts

@@ -1,2 +1,2 @@
-import type { QuotaProviderAdapter } from "../types.js";
+import type { QuotaProviderAdapter } from '../types.js';
 export declare const anthropicAdapter: QuotaProviderAdapter;

package/dist/providers/core/anthropic.js

@@ -1,13 +1,12 @@
-import { swallow } from "../../helpers.js";
-import { asRecord, configuredProviderEnabled, fetchWithTimeout, normalizePercent, toIso, } from "../common.js";
-const ANTHROPIC_OAUTH_USAGE_BETA = "oauth-2025-04-20";
+import { asRecord, configuredProviderEnabled, fetchWithTimeout, normalizePercent, toIso, } from '../common.js';
+const ANTHROPIC_OAUTH_USAGE_BETA = 'oauth-2025-04-20';
 const ANTHROPIC_WINDOW_FIELDS = [
-    ["five_hour", "5h"],
-    ["seven_day", "Weekly"],
-    ["seven_day_sonnet", "Sonnet 7d"],
-    ["seven_day_opus", "Opus 7d"],
-    ["seven_day_oauth_apps", "OAuth Apps 7d"],
-    ["seven_day_cowork", "Cowork 7d"],
+    ['five_hour', '5h'],
+    ['seven_day', 'Weekly'],
+    ['seven_day_sonnet', 'Sonnet 7d'],
+    ['seven_day_opus', 'Opus 7d'],
+    ['seven_day_oauth_apps', 'OAuth Apps 7d'],
+    ['seven_day_cowork', 'Cowork 7d'],
 ];
 function parseAnthropicWindow(value, label) {
     const win = asRecord(value);
@@ -24,96 +23,121 @@ function parseAnthropicWindow(value, label) {
     };
     return parsed;
 }
+function anthropicFetchErrorNote(error) {
+    if (error instanceof Error && error.name === 'AbortError') {
+        return 'timeout';
+    }
+    return 'network request failed';
+}
+function isRetryableAnthropicStatus(status) {
+    return status === 408 || status === 429 || status >= 500;
+}
+async function fetchAnthropicUsage(accessToken, timeoutMs) {
+    let lastErrorNote;
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            const response = await fetchWithTimeout('https://api.anthropic.com/api/oauth/usage', {
+                method: 'GET',
+                headers: {
+                    Accept: 'application/json',
+                    Authorization: `Bearer ${accessToken}`,
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'opencode-quota-sidebar',
+                    'anthropic-beta': ANTHROPIC_OAUTH_USAGE_BETA,
+                },
+            }, timeoutMs);
+            if (response.ok ||
+                !isRetryableAnthropicStatus(response.status) ||
+                attempt > 0) {
+                return { response };
+            }
+            lastErrorNote = `http ${response.status}`;
+        }
+        catch (error) {
+            lastErrorNote = anthropicFetchErrorNote(error);
+        }
+    }
+    return { errorNote: lastErrorNote || 'network request failed' };
+}
 async function fetchAnthropicQuota({ providerID, auth, config, }) {
     const checkedAt = Date.now();
     const base = {
         providerID,
-        adapterID: "anthropic",
-        label: "Anthropic",
-        shortLabel: "Anthropic",
+        adapterID: 'anthropic',
+        label: 'Anthropic',
+        shortLabel: 'Anthropic',
         sortOrder: 30,
     };
     if (!auth) {
         return {
             ...base,
-            status: "unavailable",
+            status: 'unavailable',
             checkedAt,
-            note: "auth not found",
+            note: 'auth not found',
         };
     }
-    if (auth.type !== "oauth") {
+    if (auth.type !== 'oauth') {
         return {
             ...base,
-            status: "unsupported",
+            status: 'unsupported',
             checkedAt,
-            note: "api key auth has no quota endpoint",
+            note: 'api key auth has no quota endpoint',
         };
     }
-    if (typeof auth.access !== "string" || !auth.access) {
+    if (typeof auth.access !== 'string' || !auth.access) {
         return {
             ...base,
-            status: "unavailable",
+            status: 'unavailable',
             checkedAt,
-            note: "missing oauth access token",
+            note: 'missing oauth access token',
         };
     }
-    const response = await fetchWithTimeout("https://api.anthropic.com/api/oauth/usage", {
-        method: "GET",
-        headers: {
-            Accept: "application/json",
-            Authorization: `Bearer ${auth.access}`,
-            "Content-Type": "application/json",
-            "User-Agent": "opencode-quota-sidebar",
-            "anthropic-beta": ANTHROPIC_OAUTH_USAGE_BETA,
-        },
-    }, config.quota.requestTimeoutMs).catch(swallow("fetchAnthropicQuota:usage"));
+    const { response, errorNote } = await fetchAnthropicUsage(auth.access, config.quota.requestTimeoutMs);
     if (!response) {
         return {
             ...base,
-            status: "error",
+            status: 'error',
             checkedAt,
-            note: "network request failed",
+            note: errorNote || 'network request failed',
         };
     }
     if (!response.ok) {
         return {
             ...base,
-            status: "error",
+            status: 'error',
             checkedAt,
             note: `http ${response.status}`,
         };
     }
-    const payload = await response
-        .json()
-        .catch(swallow("fetchAnthropicQuota:json"));
+    const payload = await response.json().catch(() => undefined);
     const usage = asRecord(payload);
     if (!usage) {
         return {
             ...base,
-            status: "error",
+            status: 'error',
             checkedAt,
-            note: "invalid response",
+            note: 'invalid response',
         };
     }
     const windows = ANTHROPIC_WINDOW_FIELDS.map(([field, label]) => parseAnthropicWindow(usage[field], label)).filter((window) => Boolean(window));
     const primary = windows[0];
     return {
         ...base,
-        status: primary ? "ok" : "error",
+        status: primary ? 'ok' : 'error',
         checkedAt,
         usedPercent: primary?.usedPercent,
         remainingPercent: primary?.remainingPercent,
         resetAt: primary?.resetAt,
-        note: primary ? undefined : "missing quota fields",
+        note: primary ? undefined : 'missing quota fields',
         windows: windows.length > 0 ? windows : undefined,
     };
 }
 export const anthropicAdapter = {
-    id: "anthropic",
-    label: "Anthropic",
-    shortLabel: "Anthropic",
+    id: 'anthropic',
+    label: 'Anthropic',
+    shortLabel: 'Anthropic',
     sortOrder: 30,
-    matchScore: ({ providerID }) => (providerID === "anthropic" ? 80 : 0),
-    isEnabled: (config) => configuredProviderEnabled(config.quota, "anthropic", config.quota.includeAnthropic),
+    matchScore: ({ providerID }) => (providerID === 'anthropic' ? 80 : 0),
+    isEnabled: (config) => configuredProviderEnabled(config.quota, 'anthropic', config.quota.includeAnthropic),
     fetch: fetchAnthropicQuota,
 };

package/dist/providers/core/openai.js

@@ -1,5 +1,71 @@
 import { debug, debugError, isRecord, swallow } from '../../helpers.js';
-import { OPENAI_OAUTH_CLIENT_ID, configuredProviderEnabled, fetchWithTimeout, normalizePercent, parseRateLimitWindow, toIso, } from '../common.js';
+import { OPENAI_OAUTH_CLIENT_ID, asNumber, configuredProviderEnabled, fetchWithTimeout, toIso, windowLabel, } from '../common.js';
+function decodeJwtPayload(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            return undefined;
+        const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf8'));
+        return isRecord(payload) ? payload : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractAccountIdFromJwt(token) {
+    const payload = decodeJwtPayload(token);
+    if (!payload)
+        return undefined;
+    const authClaim = payload['https://api.openai.com/auth'];
+    if (!isRecord(authClaim))
+        return undefined;
+    const accountID = authClaim.chatgpt_account_id;
+    return typeof accountID === 'string' && accountID ? accountID : undefined;
+}
+function normalizeOpenAIQuotaPercent(value) {
+    const numeric = asNumber(value);
+    if (numeric === undefined || Number.isNaN(numeric))
+        return undefined;
+    const expanded = numeric > 0 && numeric < 1 ? numeric * 100 : numeric;
+    if (expanded < 0)
+        return 0;
+    if (expanded > 100)
+        return 100;
+    return expanded;
+}
+function windowResetAt(win, fallback) {
+    const absolute = toIso(win.reset_at ?? fallback?.reset_at);
+    if (absolute)
+        return absolute;
+    const resetAfterSeconds = asNumber(win.reset_after_seconds) ?? asNumber(fallback?.reset_after_seconds);
+    if (resetAfterSeconds === undefined || resetAfterSeconds < 0)
+        return undefined;
+    return new Date(Date.now() + resetAfterSeconds * 1000).toISOString();
+}
+function parseOpenAIWindow(win, fallbackLabel, labelPrefix = '') {
+    const usedPercent = normalizeOpenAIQuotaPercent(win.used_percent);
+    const remainingPercent = normalizeOpenAIQuotaPercent(win.remaining_percent) ??
+        (usedPercent === undefined ? undefined : 100 - usedPercent);
+    if (remainingPercent === undefined)
+        return undefined;
+    return {
+        label: `${labelPrefix}${windowLabel(win, fallbackLabel)}`.trim(),
+        remainingPercent,
+        usedPercent,
+        resetAt: windowResetAt(win),
+    };
+}
+function additionalRateLimitPrefix(limitName, meteredFeature) {
+    if (meteredFeature === 'codex_bengalfox')
+        return 'Spark ';
+    if (typeof meteredFeature === 'string' && meteredFeature)
+        return undefined;
+    if (typeof limitName !== 'string' || !limitName)
+        return undefined;
+    if (/codex-spark/i.test(limitName))
+        return 'Spark ';
+    return undefined;
+}
 async function fetchOpenAIQuota(ctx) {
     const checkedAt = Date.now();
     const base = {
@@ -85,13 +151,15 @@ async function fetchOpenAIQuota(ctx) {
             }
         }
     }
+    const accountId = (typeof ctx.auth.accountId === 'string' && ctx.auth.accountId) ||
+        extractAccountIdFromJwt(access);
     const headers = new Headers({
         Authorization: `Bearer ${access}`,
         Accept: 'application/json',
         'User-Agent': 'opencode-quota-sidebar',
     });
-    if (typeof ctx.auth.accountId === 'string' && ctx.auth.accountId) {
-        headers.set('ChatGPT-Account-Id', ctx.auth.accountId);
+    if (accountId) {
+        headers.set('ChatGPT-Account-Id', accountId);
     }
     const response = await fetchWithTimeout('https://chatgpt.com/backend-api/wham/usage', { headers }, ctx.config.quota.requestTimeoutMs).catch(swallow('fetchOpenAIQuota:usage'));
     if (!response) {
@@ -123,21 +191,46 @@ async function fetchOpenAIQuota(ctx) {
     const primary = isRecord(rateLimit.primary_window)
         ? rateLimit.primary_window
         : {};
-    const usedPercent = normalizePercent(primary.used_percent);
-    const remainingPercent = normalizePercent(primary.remaining_percent) ??
+    const usedPercent = normalizeOpenAIQuotaPercent(primary.used_percent);
+    const remainingPercent = normalizeOpenAIQuotaPercent(primary.remaining_percent) ??
         (usedPercent === undefined ? undefined : 100 - usedPercent);
-    const resetAt = toIso(primary.reset_at ?? rateLimit.reset_at);
+    const resetAt = windowResetAt(primary, rateLimit);
     const windows = [];
     if (remainingPercent !== undefined) {
-        const primaryWin = parseRateLimitWindow(primary, '');
+        const primaryWin = parseOpenAIWindow(primary, '');
         if (primaryWin)
             windows.push(primaryWin);
     }
     if (isRecord(rateLimit.secondary_window)) {
-        const secondaryWin = parseRateLimitWindow(rateLimit.secondary_window, 'Weekly');
+        const secondaryWin = parseOpenAIWindow(rateLimit.secondary_window, 'Weekly');
         if (secondaryWin)
             windows.push(secondaryWin);
     }
+    const additionalRateLimits = Array.isArray(payload.additional_rate_limits)
+        ? payload.additional_rate_limits
+        : [];
+    for (const item of additionalRateLimits) {
+        if (!isRecord(item))
+            continue;
+        const prefix = additionalRateLimitPrefix(item.limit_name, item.metered_feature);
+        if (!prefix)
+            continue;
+        const itemRateLimit = isRecord(item.rate_limit)
+            ? item.rate_limit
+            : undefined;
+        if (!itemRateLimit)
+            continue;
+        if (isRecord(itemRateLimit.primary_window)) {
+            const primaryWin = parseOpenAIWindow(itemRateLimit.primary_window, '', prefix);
+            if (primaryWin)
+                windows.push(primaryWin);
+        }
+        if (isRecord(itemRateLimit.secondary_window)) {
+            const secondaryWin = parseOpenAIWindow(itemRateLimit.secondary_window, 'Weekly', prefix);
+            if (secondaryWin)
+                windows.push(secondaryWin);
+        }
+    }
     return {
         ...base,
         status: remainingPercent === undefined ? 'error' : 'ok',

package/dist/providers/index.d.ts

@@ -6,7 +6,6 @@ import { openaiAdapter } from './core/openai.js';
 import { zhipuCodingPlanAdapter } from './core/zhipu_coding_plan.js';
 import { QuotaProviderRegistry } from './registry.js';
 import { rightCodeAdapter } from './third_party/rightcode.js';
-import { xyaiAdapter } from './third_party/xyai.js';
 export declare function createDefaultProviderRegistry(): QuotaProviderRegistry;
-export { anthropicAdapter, copilotAdapter, kimiForCodingAdapter, minimaxCnCodingPlanAdapter, openaiAdapter, rightCodeAdapter, xyaiAdapter, zhipuCodingPlanAdapter, QuotaProviderRegistry, };
+export { anthropicAdapter, copilotAdapter, kimiForCodingAdapter, minimaxCnCodingPlanAdapter, openaiAdapter, rightCodeAdapter, zhipuCodingPlanAdapter, QuotaProviderRegistry, };
 export type { AuthUpdate, AuthValue, ProviderResolveContext, QuotaFetchContext, QuotaProviderAdapter, RefreshedOAuthAuth, } from './types.js';

package/dist/providers/index.js

@@ -6,11 +6,9 @@ import { openaiAdapter } from './core/openai.js';
 import { zhipuCodingPlanAdapter } from './core/zhipu_coding_plan.js';
 import { QuotaProviderRegistry } from './registry.js';
 import { rightCodeAdapter } from './third_party/rightcode.js';
-import { xyaiAdapter } from './third_party/xyai.js';
 export function createDefaultProviderRegistry() {
     const registry = new QuotaProviderRegistry();
     registry.register(rightCodeAdapter);
-    registry.register(xyaiAdapter);
     registry.register(kimiForCodingAdapter);
     registry.register(zhipuCodingPlanAdapter);
     registry.register(minimaxCnCodingPlanAdapter);
@@ -19,4 +17,4 @@ export function createDefaultProviderRegistry() {
     registry.register(anthropicAdapter);
     return registry;
 }
-export { anthropicAdapter, copilotAdapter, kimiForCodingAdapter, minimaxCnCodingPlanAdapter, openaiAdapter, rightCodeAdapter, xyaiAdapter, zhipuCodingPlanAdapter, QuotaProviderRegistry, };
+export { anthropicAdapter, copilotAdapter, kimiForCodingAdapter, minimaxCnCodingPlanAdapter, openaiAdapter, rightCodeAdapter, zhipuCodingPlanAdapter, QuotaProviderRegistry, };

package/dist/quota.d.ts

@@ -1,5 +1,5 @@
-import type { AuthUpdate, AuthValue } from "./providers/types.js";
-import type { QuotaSidebarConfig, QuotaSnapshot } from "./types.js";
+import type { AuthUpdate, AuthValue } from './providers/types.js';
+import type { QuotaSidebarConfig, QuotaSnapshot } from './types.js';
 export declare function quotaSort(left: QuotaSnapshot, right: QuotaSnapshot): number;
 export declare function listDefaultQuotaProviderIDs(): string[];
 export declare function createQuotaRuntime(): {
@@ -24,6 +24,7 @@ export declare function createQuotaRuntime(): {
         };
         note?: string;
         windows?: import("./types.js").QuotaWindow[];
+        stale?: import("./types.js").QuotaStaleMeta;
     } | undefined>;
 };
 export declare function normalizeProviderID(providerID: string): string;
@@ -48,4 +49,5 @@ export declare function fetchQuotaSnapshot(providerID: string, authMap: Record<s
     };
     note?: string;
     windows?: import("./types.js").QuotaWindow[];
+    stale?: import("./types.js").QuotaStaleMeta;
 } | undefined>;

package/dist/quota.js

@@ -1,14 +1,14 @@
-import fs from "node:fs/promises";
-import { isRecord, swallow } from "./helpers.js";
-import { createDefaultProviderRegistry } from "./providers/index.js";
-import { sanitizeBaseURL } from "./providers/common.js";
+import fs from 'node:fs/promises';
+import { isRecord, swallow } from './helpers.js';
+import { createDefaultProviderRegistry } from './providers/index.js';
+import { sanitizeBaseURL } from './providers/common.js';
 function resolveContext(providerID, providerOptions) {
     return { providerID, providerOptions };
 }
 function authCandidates(providerID, normalizedProviderID, adapterID) {
     const candidates = new Set([providerID]);
-    if (adapterID === "github-copilot") {
-        candidates.add("github-copilot-enterprise");
+    if (adapterID === 'github-copilot') {
+        candidates.add('github-copilot-enterprise');
     }
     candidates.add(normalizedProviderID);
     candidates.add(adapterID);
@@ -34,12 +34,12 @@ export function quotaSort(left, right) {
 export function listDefaultQuotaProviderIDs() {
     // Keep default report behavior stable for built-in subscription providers.
     return [
-        "openai",
-        "kimi-for-coding",
-        "zhipuai-coding-plan",
-        "minimax-cn-coding-plan",
-        "github-copilot",
-        "anthropic",
+        'openai',
+        'kimi-for-coding',
+        'zhipuai-coding-plan',
+        'minimax-cn-coding-plan',
+        'github-copilot',
+        'anthropic',
     ];
 }
 export function createQuotaRuntime() {
@@ -60,14 +60,11 @@ export function createQuotaRuntime() {
             keyBase = `${adapter.id}:${providerID}`;
         }
         // Some third-party adapters intentionally preserve provider-specific labels
-        // (for example RC-openai or an XYAI alias) even when they share one adapter.
+        // (for example RC-openai) even when they share one adapter.
         // Keep the original provider identity in cache keys so same-host aliases with
         // different auth/config entries do not overwrite each other.
-        if ((adapter?.id === "rightcode" &&
-            normalizedProviderID.startsWith("rightcode-")) ||
-            (adapter?.id === "xyai" &&
-                providerID !== "xyai" &&
-                providerID !== "xyai-vibe")) {
+        if (adapter?.id === 'rightcode' &&
+            normalizedProviderID.startsWith('rightcode-')) {
             keyBase = normalizedProviderID;
         }
         return baseURL ? `${keyBase}@${baseURL}` : keyBase;
@@ -116,16 +113,16 @@ export function quotaCacheKey(providerID, providerOptions) {
 }
 export async function loadAuthMap(authPath) {
     const parsed = await fs
-        .readFile(authPath, "utf8")
+        .readFile(authPath, 'utf8')
         .then((value) => JSON.parse(value))
-        .catch(swallow("loadAuthMap"));
+        .catch(swallow('loadAuthMap'));
     if (!isRecord(parsed))
         return {};
     return Object.entries(parsed).reduce((acc, [key, value]) => {
         if (!isRecord(value))
             return acc;
         const type = value.type;
-        if (type !== "oauth" && type !== "api" && type !== "wellknown")
+        if (type !== 'oauth' && type !== 'api' && type !== 'wellknown')
             return acc;
         acc[key] = value;
         return acc;

package/dist/quota_render.d.ts

@@ -1,4 +1,4 @@
-import type { QuotaSnapshot } from "./types.js";
+import type { QuotaSnapshot } from './types.js';
 export declare function canonicalProviderID(providerID: string): string;
 export declare function displayShortLabel(providerID: string): string;
 export declare function quotaDisplayLabel(quota: QuotaSnapshot): string;

package/dist/quota_render.js

@@ -1,22 +1,20 @@
+import { isSupportedQuotaSnapshot } from './supported_quota.js';
 const PROVIDER_SHORT_LABELS = {
-    openai: "OpenAI",
-    "kimi-for-coding": "Kimi",
-    "zhipuai-coding-plan": "Zhipu",
-    "minimax-cn-coding-plan": "MiniMax",
-    "github-copilot": "Copilot",
-    anthropic: "Anthropic",
-    rightcode: "RC",
-    xyai: "XYAI",
+    openai: 'OpenAI',
+    'kimi-for-coding': 'Kimi',
+    'zhipuai-coding-plan': 'Zhipu',
+    'minimax-cn-coding-plan': 'MiniMax',
+    'github-copilot': 'Copilot',
+    anthropic: 'Anthropic',
+    rightcode: 'RC',
 };
 export function canonicalProviderID(providerID) {
-    if (providerID.startsWith("github-copilot"))
-        return "github-copilot";
-    if (providerID === "zhipuai-coding-plan")
-        return "zhipuai-coding-plan";
-    if (providerID === "minimax-cn-coding-plan")
-        return "minimax-cn-coding-plan";
-    if (providerID === "xyai-vibe")
-        return "xyai";
+    if (providerID.startsWith('github-copilot'))
+        return 'github-copilot';
+    if (providerID === 'zhipuai-coding-plan')
+        return 'zhipuai-coding-plan';
+    if (providerID === 'minimax-cn-coding-plan')
+        return 'minimax-cn-coding-plan';
     return providerID;
 }
 export function displayShortLabel(providerID) {
@@ -24,8 +22,8 @@ export function displayShortLabel(providerID) {
     const direct = PROVIDER_SHORT_LABELS[canonical];
     if (direct)
         return direct;
-    if (canonical.startsWith("rightcode-")) {
-        return `RC-${canonical.slice("rightcode-".length)}`;
+    if (canonical.startsWith('rightcode-')) {
+        return `RC-${canonical.slice('rightcode-'.length)}`;
     }
     return providerID;
 }
@@ -40,13 +38,13 @@ export function quotaDisplayLabel(quota) {
     return displayShortLabel(quota.providerID);
 }
 function quotaKey(quota) {
-    if (quota.adapterID === "rightcode")
+    if (quota.adapterID === 'rightcode')
         return `rightcode:${quota.providerID}`;
     return `${quota.adapterID || quota.providerID}:${quota.providerID}`;
 }
 function quotaScore(quota) {
     let score = 0;
-    if (quota.status === "ok")
+    if (quota.status === 'ok')
         score += 10;
     if (quota.windows && quota.windows.length > 0) {
         score += 5 + quota.windows.length;
@@ -58,14 +56,15 @@ function quotaScore(quota) {
     return score;
 }
 export function collapseQuotaSnapshots(quotas) {
+    const supportedQuotas = quotas.filter((quota) => isSupportedQuotaSnapshot(quota));
     const grouped = new Map();
-    const hasRightCodeBase = quotas.some((quota) => quota.adapterID === "rightcode" && quotaDisplayLabel(quota) === "RC");
-    for (const quota of quotas) {
+    const hasRightCodeBase = supportedQuotas.some((quota) => quota.adapterID === 'rightcode' && quotaDisplayLabel(quota) === 'RC');
+    for (const quota of supportedQuotas) {
         // If both RC (balance) and RC-variant (subscription) exist,
         // treat balance as owned by RC.
         const normalizedQuota = hasRightCodeBase &&
-            quota.adapterID === "rightcode" &&
-            quotaDisplayLabel(quota).startsWith("RC-")
+            quota.adapterID === 'rightcode' &&
+            quotaDisplayLabel(quota).startsWith('RC-')
             ? { ...quota, balance: undefined }
             : quota;
         const key = quotaKey(normalizedQuota);

package/dist/quota_service.d.ts

@@ -20,4 +20,5 @@ export declare function createQuotaService(deps: {
     getQuotaSnapshots: (providerIDs: string[], options?: {
         allowDefault?: boolean;
     }) => Promise<QuotaSnapshot[]>;
+    invalidateForProvider: (providerID: string) => void;
 };