@leo000001/opencode-quota-sidebar 3.0.10 → 4.0.2

package/dist/period.js

@@ -1,14 +1,192 @@
-export function periodStart(period) {
-    const now = new Date();
+const MONTH_NAMES = [
+    'Jan',
+    'Feb',
+    'Mar',
+    'Apr',
+    'May',
+    'Jun',
+    'Jul',
+    'Aug',
+    'Sep',
+    'Oct',
+    'Nov',
+    'Dec',
+];
+function pad2(value) {
+    return `${value}`.padStart(2, '0');
+}
+function startOfDay(timestamp) {
+    const date = new Date(timestamp);
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+}
+function startOfMonth(timestamp) {
+    const date = new Date(timestamp);
+    return new Date(date.getFullYear(), date.getMonth(), 1).getTime();
+}
+function startOfWeek(timestamp) {
+    const date = new Date(timestamp);
+    const day = date.getDay();
+    const shift = day === 0 ? 6 : day - 1;
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate() - shift).getTime();
+}
+function nextDayStart(timestamp) {
+    const date = new Date(timestamp);
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1).getTime();
+}
+function nextWeekStart(timestamp) {
+    const weekStart = new Date(startOfWeek(timestamp));
+    return new Date(weekStart.getFullYear(), weekStart.getMonth(), weekStart.getDate() + 7).getTime();
+}
+function nextMonthStart(timestamp) {
+    const date = new Date(timestamp);
+    return new Date(date.getFullYear(), date.getMonth() + 1, 1).getTime();
+}
+function formatLocalDate(timestamp) {
+    const date = new Date(timestamp);
+    return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+}
+function formatMonthInput(timestamp) {
+    const date = new Date(timestamp);
+    return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}`;
+}
+function formatMonthLabel(timestamp) {
+    const date = new Date(timestamp);
+    return `${MONTH_NAMES[date.getMonth()]} ${date.getFullYear()}`;
+}
+function formatMonthShortLabel(timestamp) {
+    const date = new Date(timestamp);
+    return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}`;
+}
+function formatDayShortLabel(timestamp) {
+    const date = new Date(timestamp);
+    return `${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+}
+function periodBoundaryStart(period, timestamp) {
+    if (period === 'month')
+        return startOfMonth(timestamp);
+    if (period === 'week')
+        return startOfWeek(timestamp);
+    return startOfDay(timestamp);
+}
+function nextPeriodBoundary(period, timestamp) {
+    if (period === 'month')
+        return nextMonthStart(timestamp);
+    if (period === 'week')
+        return nextWeekStart(timestamp);
+    return nextDayStart(timestamp);
+}
+function periodRangeLabels(period, startAt, endAt) {
     if (period === 'month') {
-        return new Date(now.getFullYear(), now.getMonth(), 1).getTime();
+        return {
+            label: formatMonthLabel(startAt),
+            shortLabel: formatMonthShortLabel(startAt),
+        };
+    }
+    if (period === 'week') {
+        const endLabel = formatLocalDate(Math.max(startAt, endAt - 1));
+        const startLabel = formatLocalDate(startAt);
+        return {
+            label: `${startLabel} to ${endLabel}`,
+            shortLabel: `${startLabel}..${endLabel}`,
+        };
+    }
+    return {
+        label: formatLocalDate(startAt),
+        shortLabel: formatDayShortLabel(startAt),
+    };
+}
+export function parseSince(raw, now = Date.now()) {
+    const value = raw.trim();
+    const monthMatch = /^(\d{4})-(\d{2})$/.exec(value);
+    if (monthMatch) {
+        const year = Number(monthMatch[1]);
+        const month = Number(monthMatch[2]);
+        if (year < 100 || month < 1 || month > 12) {
+            throw new Error('`since` is not a valid calendar date');
+        }
+        const startAt = new Date(year, month - 1, 1).getTime();
+        if (Number.isNaN(startAt)) {
+            throw new Error('`since` is not a valid calendar date');
+        }
+        if (startAt > now) {
+            throw new Error('`since` cannot be in the future');
+        }
+        return { raw: value, precision: 'month', startAt };
+    }
+    const dayMatch = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+    if (dayMatch) {
+        const year = Number(dayMatch[1]);
+        const month = Number(dayMatch[2]);
+        const day = Number(dayMatch[3]);
+        if (year < 100) {
+            throw new Error('`since` is not a valid calendar date');
+        }
+        const startAt = new Date(year, month - 1, day).getTime();
+        const probe = new Date(startAt);
+        if (Number.isNaN(startAt) ||
+            probe.getFullYear() !== year ||
+            probe.getMonth() !== month - 1 ||
+            probe.getDate() !== day) {
+            throw new Error('`since` is not a valid calendar date');
+        }
+        if (startAt > now) {
+            throw new Error('`since` cannot be in the future');
+        }
+        return { raw: value, precision: 'day', startAt };
+    }
+    throw new Error('`since` must be `YYYY-MM` or `YYYY-MM-DD`');
+}
+export function periodRanges(period, since, endAt = Date.now()) {
+    if (since.startAt > endAt) {
+        throw new Error('`since` cannot be in the future');
+    }
+    const ranges = [];
+    let cursor = since.startAt;
+    let index = 0;
+    while (cursor < endAt) {
+        const boundaryStart = periodBoundaryStart(period, cursor);
+        const boundaryEnd = nextPeriodBoundary(period, cursor);
+        const rangeEnd = Math.min(boundaryEnd, endAt);
+        const isCurrent = rangeEnd === endAt && endAt !== periodBoundaryStart(period, endAt);
+        const isPartial = cursor !== boundaryStart || isCurrent;
+        const { label, shortLabel } = periodRangeLabels(period, cursor, rangeEnd);
+        ranges.push({
+            period,
+            startAt: cursor,
+            endAt: rangeEnd,
+            label,
+            shortLabel,
+            isCurrent,
+            isPartial,
+            index,
+        });
+        cursor = rangeEnd;
+        index += 1;
+    }
+    if (period === 'day' && ranges.length > 90) {
+        throw new Error('day history is limited to 90 days; choose a later `since` date');
+    }
+    return ranges;
+}
+export function periodStart(period, now = Date.now()) {
+    return periodBoundaryStart(period, now);
+}
+export function sinceFromLast(period, last, now = Date.now()) {
+    if (!Number.isInteger(last) || last < 1) {
+        throw new Error('`last` must be a positive integer');
+    }
+    const currentStart = periodBoundaryStart(period, now);
+    if (period === 'day') {
+        const date = new Date(currentStart);
+        const start = new Date(date.getFullYear(), date.getMonth(), date.getDate() - (last - 1)).getTime();
+        return formatLocalDate(start);
     }
     if (period === 'week') {
-        const day = now.getDay();
-        const shift = day === 0 ? 6 : day - 1;
-        const start = new Date(now.getFullYear(), now.getMonth(), now.getDate() - shift);
-        start.setHours(0, 0, 0, 0);
-        return start.getTime();
+        const date = new Date(currentStart);
+        const start = new Date(date.getFullYear(), date.getMonth(), date.getDate() - 7 * (last - 1)).getTime();
+        return formatLocalDate(start);
     }
-    return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+    const date = new Date(currentStart);
+    const start = new Date(date.getFullYear(), date.getMonth() - (last - 1), 1).getTime();
+    return formatMonthInput(start);
 }

package/dist/provider_catalog.d.ts

@@ -0,0 +1,8 @@
+import type { HistoryUsageResult } from './usage_service.js';
+import type { UsageSummary } from './usage.js';
+export declare function listCurrentProviderIDs(input: {
+    client: unknown;
+    directory: string;
+}): Promise<Set<string>>;
+export declare function filterUsageProvidersForDisplay(usage: UsageSummary, allowedProviderIDs: ReadonlySet<string>): UsageSummary;
+export declare function filterHistoryProvidersForDisplay(result: HistoryUsageResult, allowedProviderIDs: ReadonlySet<string>): HistoryUsageResult;

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

@@ -42,19 +42,30 @@ function windowResetAt(win, fallback) {
         return undefined;
     return new Date(Date.now() + resetAfterSeconds * 1000).toISOString();
 }
-function parseOpenAIWindow(win, fallbackLabel) {
+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: windowLabel(win, fallbackLabel),
+        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 = {
@@ -195,6 +206,31 @@ async function fetchOpenAIQuota(ctx) {
         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;