+ {recoveryRows.flatMap(({ label, window }) => (
+ window.nextRecoveryAt !== undefined && window.nextRecoveryPercent !== undefined
+ ? [
+ {t("pws.capacity.nextRecovery")} · {label} · {formatRecoveryAt(window.nextRecoveryAt)}
+ {t("pws.capacity.recoveryShare", { percent: formatPercent(window.nextRecoveryPercent) })}
+
]
+ : []
+ ))}
+ {aggregation.currentAccount?.quota && (
+
+
+ {t("pws.capacity.currentAccount")}
+ {aggregation.currentAccount.plan ? ` · ${aggregation.currentAccount.plan}` : ""}
+
+
+
+ )}
+ {aggregation.incomplete && (
+
+ {t("pws.capacity.incomplete", {
+ excluded: aggregation.excludedAccounts,
+ unknown: aggregation.unknownPlanAccounts,
+ })}
+
+ )}
+
diff --git a/gui/src/i18n/de.ts b/gui/src/i18n/de.ts
index 2811acd6fd..c882769f28 100644
--- a/gui/src/i18n/de.ts
+++ b/gui/src/i18n/de.ts
@@ -1380,6 +1380,11 @@ export const de: Record
= {
"pws.dashboard.title": "Anbieterübersicht",
"pws.dashboard.subtitle": "Verwalten Sie alle Ihre Modellanbieter an einem Ort.",
"pws.dashboard.rateLimits": "RATE LIMITS",
+ "pws.capacity.estimate": "Konfiguriert gewichtete Pool-Schätzung",
+ "pws.capacity.currentAccount": "Aktuelles effektives Konto",
+ "pws.capacity.nextRecovery": "Nächste Kapazitätswiederherstellung",
+ "pws.capacity.recoveryShare": "+{percent} % Pool-Kapazität",
+ "pws.capacity.incomplete": "Unvollständige Abdeckung: {excluded} Konten ausgeschlossen, davon {unknown} mit unbekanntem Tarif",
"pws.dashboard.recentlyUsed": "KÜRZLICH VERWENDET",
"pws.dashboard.requests": "{count} Anfragen",
"pws.dashboard.checkedAgo": "Geprüft {time}",
diff --git a/gui/src/i18n/en.ts b/gui/src/i18n/en.ts
index 877214622a..eda18bc277 100644
--- a/gui/src/i18n/en.ts
+++ b/gui/src/i18n/en.ts
@@ -1046,6 +1046,11 @@ export const en = {
"pws.dashboard.title": "Providers overview",
"pws.dashboard.subtitle": "Manage all your model providers in one place.",
"pws.dashboard.rateLimits": "RATE LIMITS",
+ "pws.capacity.estimate": "Configured-weight pool estimate",
+ "pws.capacity.currentAccount": "Current effective account",
+ "pws.capacity.nextRecovery": "Next capacity recovery",
+ "pws.capacity.recoveryShare": "+{percent}% pool capacity",
+ "pws.capacity.incomplete": "Incomplete coverage: {excluded} account(s) excluded, including {unknown} unknown plan(s)",
"pws.dashboard.recentlyUsed": "RECENTLY USED",
"pws.dashboard.requests": "{count} requests",
"pws.dashboard.checkedAgo": "Checked {time}",
diff --git a/gui/src/i18n/ja.ts b/gui/src/i18n/ja.ts
index 97d5e3ee48..4e88dec9f8 100644
--- a/gui/src/i18n/ja.ts
+++ b/gui/src/i18n/ja.ts
@@ -996,6 +996,11 @@ export const ja: Record = {
"pws.dashboard.title": "プロバイダー概要",
"pws.dashboard.subtitle": "すべてのモデルプロバイダーを一か所で管理します。",
"pws.dashboard.rateLimits": "レート制限",
+ "pws.capacity.estimate": "設定済み重みによるプール推定",
+ "pws.capacity.currentAccount": "現在の有効アカウント",
+ "pws.capacity.nextRecovery": "次の容量回復",
+ "pws.capacity.recoveryShare": "+{percent}% のプール容量",
+ "pws.capacity.incomplete": "対象範囲が不完全です: {excluded} 件を除外（不明なプラン {unknown} 件）",
"pws.dashboard.recentlyUsed": "最近の使用",
"pws.dashboard.requests": "{count} リクエスト",
"pws.dashboard.checkedAgo": "{time} に確認",
diff --git a/gui/src/i18n/ko.ts b/gui/src/i18n/ko.ts
index 474d007c0c..42098d5e12 100644
--- a/gui/src/i18n/ko.ts
+++ b/gui/src/i18n/ko.ts
@@ -1407,6 +1407,11 @@ export const ko: Record = {
"pws.dashboard.title": "프로바이더 개요",
"pws.dashboard.subtitle": "모든 모델 프로바이더를 한곳에서 관리합니다.",
"pws.dashboard.rateLimits": "사용량 제한",
+ "pws.capacity.estimate": "설정 가중치 기반 풀 추정치",
+ "pws.capacity.currentAccount": "현재 유효 계정",
+ "pws.capacity.nextRecovery": "다음 용량 회복",
+ "pws.capacity.recoveryShare": "+{percent}% 풀 용량",
+ "pws.capacity.incomplete": "불완전한 범위: {excluded}개 계정 제외, 알 수 없는 요금제 {unknown}개 포함",
"pws.dashboard.recentlyUsed": "최근 사용",
"pws.dashboard.requests": "{count}건 요청",
"pws.dashboard.checkedAgo": "{time} 전 확인",
diff --git a/gui/src/i18n/ru.ts b/gui/src/i18n/ru.ts
index 80c4d8d395..c03eef27c7 100644
--- a/gui/src/i18n/ru.ts
+++ b/gui/src/i18n/ru.ts
@@ -1038,6 +1038,11 @@ export const ru: Record = {
"pws.dashboard.title": "Обзор провайдеров",
"pws.dashboard.subtitle": "Управляйте всеми провайдерами моделей в одном месте.",
"pws.dashboard.rateLimits": "Лимиты запросов",
+ "pws.capacity.estimate": "Оценка пула по настроенным весам",
+ "pws.capacity.currentAccount": "Текущая активная учётная запись",
+ "pws.capacity.nextRecovery": "Следующее восстановление ёмкости",
+ "pws.capacity.recoveryShare": "+{percent}% ёмкости пула",
+ "pws.capacity.incomplete": "Неполное покрытие: исключено аккаунтов: {excluded}, неизвестных планов: {unknown}",
"pws.dashboard.recentlyUsed": "Недавно использованные",
"pws.dashboard.requests": "{count} запросов",
"pws.dashboard.checkedAgo": "Проверено {time}",
diff --git a/gui/src/i18n/zh.ts b/gui/src/i18n/zh.ts
index 7f24d45d32..6e63f86f5e 100644
--- a/gui/src/i18n/zh.ts
+++ b/gui/src/i18n/zh.ts
@@ -1400,6 +1400,11 @@ export const zh: Record = {
"pws.dashboard.title": "提供商概览",
"pws.dashboard.subtitle": "在一个地方管理所有模型提供商。",
"pws.dashboard.rateLimits": "速率限制",
+ "pws.capacity.estimate": "按配置权重估算的账户池",
+ "pws.capacity.currentAccount": "当前有效账户",
+ "pws.capacity.nextRecovery": "下一次容量恢复",
+ "pws.capacity.recoveryShare": "+{percent}% 账户池容量",
+ "pws.capacity.incomplete": "覆盖不完整：已排除 {excluded} 个账户，其中 {unknown} 个套餐未知",
"pws.dashboard.recentlyUsed": "最近使用",
"pws.dashboard.requests": "{count} 个请求",
"pws.dashboard.checkedAgo": "{time} 前检查",
diff --git a/gui/src/provider-workspace/report.ts b/gui/src/provider-workspace/report.ts
index c38e982ad9..b53b9d3bcc 100644
--- a/gui/src/provider-workspace/report.ts
+++ b/gui/src/provider-workspace/report.ts
@@ -11,41 +11,115 @@ export interface ProviderQuotaReportView {
source?: string;
updatedAt?: number;
quota?: unknown;
+ aggregation?: unknown;
}
-/** Narrow an unknown quota payload into the AccountQuota display shape (null when unusable). */
-export function accountQuotaFromReport(report?: ProviderQuotaReportView): AccountQuota | null {
- const quota = report?.quota;
+export interface CapacityWindowView {
+ usedPercent: number;
+ nextRecoveryAt?: number;
+ nextRecoveryPercent?: number;
+}
+
+export interface ProviderCapacityAggregationView {
+ incomplete: boolean;
+ excludedAccounts: number;
+ unknownPlanAccounts: number;
+ fiveHour?: CapacityWindowView;
+ weekly?: CapacityWindowView;
+ monthly?: CapacityWindowView;
+ customWindows?: Array;
+ currentAccount?: { plan?: string | null; quota: AccountQuota | null };
+}
+
+const finite = (value: unknown): number | undefined => (
+ typeof value === "number" && Number.isFinite(value) ? value : undefined
+);
+
+function quotaFromUnknown(quota: unknown, fallbackUpdatedAt?: number): AccountQuota | null {
if (!quota || typeof quota !== "object" || Array.isArray(quota)) return null;
const q = quota as Record;
- const num = (v: unknown): number | undefined => (typeof v === "number" && Number.isFinite(v) ? v : undefined);
const windows = Array.isArray(q.customWindows)
? (q.customWindows as unknown[]).flatMap(w => {
if (!w || typeof w !== "object") return [];
const row = w as Record;
- if (typeof row.label !== "string" || num(row.percent) === undefined) return [];
+ if (typeof row.label !== "string" || finite(row.percent) === undefined) return [];
return [{
label: row.label,
percent: row.percent as number,
- ...(num(row.resetAt) !== undefined ? { resetAt: row.resetAt as number } : {}),
+ ...(finite(row.resetAt) !== undefined ? { resetAt: row.resetAt as number } : {}),
}];
})
: [];
const out: AccountQuota = {
- ...(num(q.fiveHourPercent) !== undefined ? { fiveHourPercent: q.fiveHourPercent as number } : {}),
- ...(num(q.fiveHourResetAt) !== undefined ? { fiveHourResetAt: q.fiveHourResetAt as number } : {}),
- ...(num(q.weeklyPercent) !== undefined ? { weeklyPercent: q.weeklyPercent as number } : {}),
- ...(num(q.weeklyResetAt) !== undefined ? { weeklyResetAt: q.weeklyResetAt as number } : {}),
- ...(num(q.monthlyPercent) !== undefined ? { monthlyPercent: q.monthlyPercent as number } : {}),
- ...(num(q.monthlyResetAt) !== undefined ? { monthlyResetAt: q.monthlyResetAt as number } : {}),
+ ...(finite(q.fiveHourPercent) !== undefined ? { fiveHourPercent: q.fiveHourPercent as number } : {}),
+ ...(finite(q.fiveHourResetAt) !== undefined ? { fiveHourResetAt: q.fiveHourResetAt as number } : {}),
+ ...(finite(q.weeklyPercent) !== undefined ? { weeklyPercent: q.weeklyPercent as number } : {}),
+ ...(finite(q.weeklyResetAt) !== undefined ? { weeklyResetAt: q.weeklyResetAt as number } : {}),
+ ...(finite(q.monthlyPercent) !== undefined ? { monthlyPercent: q.monthlyPercent as number } : {}),
+ ...(finite(q.monthlyResetAt) !== undefined ? { monthlyResetAt: q.monthlyResetAt as number } : {}),
...(windows.length > 0 ? { customWindows: windows } : {}),
- updatedAt: num(q.updatedAt) ?? report?.updatedAt ?? Date.now(),
+ updatedAt: finite(q.updatedAt) ?? fallbackUpdatedAt ?? Date.now(),
};
- const hasSignal = out.fiveHourPercent !== undefined
+ return out.fiveHourPercent !== undefined
|| out.weeklyPercent !== undefined
|| out.monthlyPercent !== undefined
- || (out.customWindows?.length ?? 0) > 0;
- return hasSignal ? out : null;
+ || (out.customWindows?.length ?? 0) > 0
+ ? out
+ : null;
+}
+
+/** Narrow an unknown quota payload into the AccountQuota display shape (null when unusable). */
+export function accountQuotaFromReport(report?: ProviderQuotaReportView): AccountQuota | null {
+ return quotaFromUnknown(report?.quota, report?.updatedAt);
+}
+
+function capacityWindow(value: unknown): CapacityWindowView | undefined {
+ if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+ const row = value as Record;
+ const usedPercent = finite(row.usedPercent);
+ if (usedPercent === undefined) return undefined;
+ return {
+ usedPercent,
+ ...(finite(row.nextRecoveryAt) !== undefined ? { nextRecoveryAt: row.nextRecoveryAt as number } : {}),
+ ...(finite(row.nextRecoveryPercent) !== undefined ? { nextRecoveryPercent: row.nextRecoveryPercent as number } : {}),
+ };
+}
+
+/** Strictly narrows optional weighted-pool metadata; legacy reports return null. */
+export function capacityAggregationFromReport(report?: ProviderQuotaReportView): ProviderCapacityAggregationView | null {
+ const value = report?.aggregation;
+ if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+ const row = value as Record;
+ if (row.kind !== "capacity-weighted-v1" || row.scope !== "routable-known") return null;
+ const excludedAccounts = finite(row.excludedAccounts);
+ const unknownPlanAccounts = finite(row.unknownPlanAccounts);
+ if (excludedAccounts === undefined || unknownPlanAccounts === undefined || typeof row.incomplete !== "boolean") return null;
+ const currentRaw = row.currentAccount && typeof row.currentAccount === "object" && !Array.isArray(row.currentAccount)
+ ? row.currentAccount as Record
+ : null;
+ const customWindows = Array.isArray(row.customWindows)
+ ? row.customWindows.flatMap(value => {
+ if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+ const custom = value as Record;
+ const window = capacityWindow(custom);
+ return typeof custom.label === "string" && window ? [{ label: custom.label, ...window }] : [];
+ })
+ : [];
+ return {
+ incomplete: row.incomplete,
+ excludedAccounts,
+ unknownPlanAccounts,
+ ...(capacityWindow(row.fiveHour) ? { fiveHour: capacityWindow(row.fiveHour) } : {}),
+ ...(capacityWindow(row.weekly) ? { weekly: capacityWindow(row.weekly) } : {}),
+ ...(capacityWindow(row.monthly) ? { monthly: capacityWindow(row.monthly) } : {}),
+ ...(customWindows.length > 0 ? { customWindows } : {}),
+ ...(currentRaw ? {
+ currentAccount: {
+ ...(typeof currentRaw.plan === "string" || currentRaw.plan === null ? { plan: currentRaw.plan } : {}),
+ quota: quotaFromUnknown(currentRaw.quota),
+ },
+ } : {}),
+ };
}
/** Human label for a quota report source id (e.g. "cursor:period-usage"). */
diff --git a/gui/src/styles/provider-overview-dashboard.css b/gui/src/styles/provider-overview-dashboard.css
index ba11de9d06..d09b8058fc 100644
--- a/gui/src/styles/provider-overview-dashboard.css
+++ b/gui/src/styles/provider-overview-dashboard.css
@@ -190,6 +190,45 @@
min-height: 64px;
}
+.pws-capacity-label,
+.pws-capacity-recovery,
+.pws-capacity-incomplete {
+ font-size: 0.7rem;
+}
+
+.pws-capacity-label {
+ color: var(--fg-muted, #888);
+ margin-bottom: 3px;
+}
+
+.pws-capacity-details {
+ display: grid;
+ gap: 7px;
+ margin-top: 8px;
+ padding-top: 7px;
+ border-top: 1px solid var(--border-soft);
+}
+
+.pws-capacity-recovery {
+ display: flex;
+ justify-content: space-between;
+ gap: 12px;
+ color: var(--fg-muted, #888);
+}
+
+.pws-capacity-recovery strong {
+ color: var(--text);
+ white-space: nowrap;
+}
+
+.pws-capacity-current {
+ padding-top: 2px;
+}
+
+.pws-capacity-incomplete {
+ color: var(--warning, #b7791f);
+}
+
.pws-dashboard-section--rate-limits,
.pws-dashboard-section--recent {
min-height: 180px;
diff --git a/gui/tests/provider-capacity.test.ts b/gui/tests/provider-capacity.test.ts
new file mode 100644
index 0000000000..863bb5c2ad
--- /dev/null
+++ b/gui/tests/provider-capacity.test.ts
@@ -0,0 +1,41 @@
+import { expect, test } from "bun:test";
+import { capacityAggregationFromReport } from "../src/provider-workspace/report";
+
+test("legacy provider quota reports remain valid without aggregation metadata", () => {
+ expect(capacityAggregationFromReport({ quota: { weeklyPercent: 42 } })).toBeNull();
+});
+
+test("capacity metadata preserves estimate, raw current quota, recovery percent, and incomplete coverage", () => {
+ const aggregation = capacityAggregationFromReport({
+ quota: { weeklyPercent: 30.769230769, updatedAt: 123 },
+ aggregation: {
+ kind: "capacity-weighted-v1",
+ scope: "routable-known",
+ incomplete: true,
+ excludedAccounts: 2,
+ unknownPlanAccounts: 1,
+ weekly: {
+ usedPercent: 30.769230769,
+ nextRecoveryAt: 1_800_000_010_000,
+ nextRecoveryPercent: 19.23076923,
+ },
+ currentAccount: {
+ plan: "pro",
+ quota: { weeklyPercent: 10, weeklyResetAt: 1_800_000_030, updatedAt: 123 },
+ },
+ },
+ });
+ expect(aggregation).toMatchObject({
+ incomplete: true,
+ excludedAccounts: 2,
+ unknownPlanAccounts: 1,
+ weekly: { usedPercent: 30.769230769, nextRecoveryPercent: 19.23076923 },
+ currentAccount: { plan: "pro", quota: { weeklyPercent: 10 } },
+ });
+ expect(aggregation?.weekly).not.toHaveProperty("projectedUsedPercentAfterReset");
+});
+
+test("malformed or future aggregation contracts fail closed", () => {
+ expect(capacityAggregationFromReport({ aggregation: { kind: "capacity-weighted-v2" } })).toBeNull();
+ expect(capacityAggregationFromReport({ aggregation: { kind: "capacity-weighted-v1", scope: "routable-known" } })).toBeNull();
+});
diff --git a/src/codex/auth-api.ts b/src/codex/auth-api.ts
index fa0472267a..f4345d0fec 100644
--- a/src/codex/auth-api.ts
+++ b/src/codex/auth-api.ts
@@ -750,6 +750,10 @@ export function clearCodexQuotaPrimeState(): void {
primeInFlight = null;
}
+export function effectiveCodexAuthAccountId(config: OcxConfig): string {
+ return getEffectiveActiveCodexAccountId(config) ?? MAIN_CODEX_ACCOUNT_ID;
+}
+
export async function listCodexAuthAccounts(config: OcxConfig, forceRefresh = false): Promise {
const runtimeConfig = getRuntimeConfig(config);
const poolAccounts = (runtimeConfig.codexAccounts ?? []).filter(isSelectableCodexPoolAccount);
diff --git a/src/providers/codex-capacity.ts b/src/providers/codex-capacity.ts
new file mode 100644
index 0000000000..c24c4b741a
--- /dev/null
+++ b/src/providers/codex-capacity.ts
@@ -0,0 +1,219 @@
+export const CODEX_CONFIGURED_CAPACITY_WEIGHTS = {
+ plus: 1,
+ business: 1,
+ prolite: 5,
+ pro: 20,
+} as const;
+
+export type CodexCapacityQuota = {
+ fiveHourPercent?: number;
+ fiveHourResetAt?: number;
+ weeklyPercent?: number;
+ weeklyResetAt?: number;
+ monthlyPercent?: number;
+ monthlyResetAt?: number;
+ customWindows?: Array<{ label: string; percent: number; resetAt?: number }>;
+ updatedAt: number;
+};
+
+export interface CodexCapacityAccount {
+ isMain: boolean;
+ active?: boolean;
+ plan?: string | null;
+ paused: boolean;
+ needsReauth?: boolean;
+ quota: CodexCapacityQuota | null;
+}
+
+export interface CodexCapacityWindowAggregation {
+ usedPercent: number;
+ includedAccounts: number;
+ totalWeight: number;
+ consumedWeight: number;
+ remainingWeight: number;
+ nextRecoveryAt?: number;
+ nextRecoveryPercent?: number;
+}
+
+export interface CodexCapacityAggregation {
+ kind: "capacity-weighted-v1";
+ scope: "routable-known";
+ includedAccounts: number;
+ excludedAccounts: number;
+ unknownPlanAccounts: number;
+ missingQuotaAccounts: number;
+ pausedAccounts: number;
+ reauthAccounts: number;
+ incomplete: boolean;
+ fiveHour?: CodexCapacityWindowAggregation;
+ weekly?: CodexCapacityWindowAggregation;
+ monthly?: CodexCapacityWindowAggregation;
+ customWindows?: Array;
+ currentAccount?: {
+ isMain: boolean;
+ plan?: string | null;
+ quota: CodexCapacityQuota | null;
+ };
+}
+
+export interface CodexCapacityResult {
+ quota: CodexCapacityQuota | null;
+ aggregation: CodexCapacityAggregation | null;
+ currentAccount?: CodexCapacityAggregation["currentAccount"];
+}
+
+type MutableWindow = {
+ totalWeight: number;
+ consumedWeight: number;
+ includedAccounts: number;
+ recoveries: Map;
+};
+
+function configuredWeight(plan: string | null | undefined): number | undefined {
+ const normalized = plan?.trim().toLowerCase();
+ return normalized && normalized in CODEX_CONFIGURED_CAPACITY_WEIGHTS
+ ? CODEX_CONFIGURED_CAPACITY_WEIGHTS[normalized as keyof typeof CODEX_CONFIGURED_CAPACITY_WEIGHTS]
+ : undefined;
+}
+
+function normalizedPercent(value: unknown): number | undefined {
+ return typeof value === "number" && Number.isFinite(value)
+ ? Math.max(0, Math.min(100, value))
+ : undefined;
+}
+
+function futureResetMs(value: unknown, now: number): number | undefined {
+ if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
+ const milliseconds = value > 10_000_000_000 ? value : value * 1000;
+ return milliseconds > now ? milliseconds : undefined;
+}
+
+function addWindow(
+ windows: Map,
+ key: string,
+ weight: number,
+ percent: number,
+ resetAt: number | undefined,
+): void {
+ const window = windows.get(key) ?? {
+ totalWeight: 0,
+ consumedWeight: 0,
+ includedAccounts: 0,
+ recoveries: new Map(),
+ };
+ const consumed = weight * percent / 100;
+ window.totalWeight += weight;
+ window.consumedWeight += consumed;
+ window.includedAccounts += 1;
+ if (resetAt !== undefined) {
+ window.recoveries.set(resetAt, (window.recoveries.get(resetAt) ?? 0) + consumed);
+ }
+ windows.set(key, window);
+}
+
+function finalizeWindow(window: MutableWindow): CodexCapacityWindowAggregation {
+ const nextRecoveryAt = [...window.recoveries.keys()].sort((a, b) => a - b)[0];
+ const recovered = nextRecoveryAt === undefined ? undefined : window.recoveries.get(nextRecoveryAt);
+ return {
+ usedPercent: window.consumedWeight / window.totalWeight * 100,
+ includedAccounts: window.includedAccounts,
+ totalWeight: window.totalWeight,
+ consumedWeight: window.consumedWeight,
+ remainingWeight: window.totalWeight - window.consumedWeight,
+ ...(nextRecoveryAt !== undefined ? { nextRecoveryAt } : {}),
+ ...(recovered !== undefined ? { nextRecoveryPercent: recovered / window.totalWeight * 100 } : {}),
+ };
+}
+
+/** Display-only configured-weight estimate. It never participates in account selection or routing. */
+export function aggregateCodexPoolCapacity(
+ accounts: readonly CodexCapacityAccount[],
+ now = Date.now(),
+): CodexCapacityResult {
+ const current = accounts.find(account => account.active)
+ ?? accounts.find(account => account.isMain)
+ ?? accounts[0];
+ const currentAccount = current ? {
+ isMain: current.isMain,
+ ...(current.plan !== undefined ? { plan: current.plan } : {}),
+ quota: current.quota,
+ } : undefined;
+ const windows = new Map();
+ const included = new Set();
+ let unknownPlanAccounts = 0;
+ let missingQuotaAccounts = 0;
+ let pausedAccounts = 0;
+ let reauthAccounts = 0;
+ let updatedAt = 0;
+
+ for (const account of accounts) {
+ const weight = configuredWeight(account.plan);
+ if (weight === undefined) unknownPlanAccounts += 1;
+ if (account.paused) pausedAccounts += 1;
+ if (account.needsReauth) reauthAccounts += 1;
+ const quota = account.quota;
+ const standard = quota ? [
+ ["fiveHour", quota.fiveHourPercent, quota.fiveHourResetAt],
+ ["weekly", quota.weeklyPercent, quota.weeklyResetAt],
+ ["monthly", quota.monthlyPercent, quota.monthlyResetAt],
+ ] as const : [];
+ const custom = quota?.customWindows ?? [];
+ const hasQuota = standard.some(([, percent]) => normalizedPercent(percent) !== undefined)
+ || custom.some(window => normalizedPercent(window.percent) !== undefined);
+ if (!hasQuota) missingQuotaAccounts += 1;
+ if (account.paused || account.needsReauth || weight === undefined || !quota || !hasQuota) continue;
+
+ let contributed = false;
+ for (const [key, rawPercent, rawReset] of standard) {
+ const percent = normalizedPercent(rawPercent);
+ if (percent === undefined) continue;
+ addWindow(windows, key, weight, percent, futureResetMs(rawReset, now));
+ contributed = true;
+ }
+ for (const customWindow of custom) {
+ const percent = normalizedPercent(customWindow.percent);
+ if (percent === undefined) continue;
+ addWindow(windows, `custom:${customWindow.label}`, weight, percent, futureResetMs(customWindow.resetAt, now));
+ contributed = true;
+ }
+ if (contributed) {
+ included.add(account);
+ updatedAt = Math.max(updatedAt, quota.updatedAt);
+ }
+ }
+
+ if (windows.size === 0) return { quota: null, aggregation: null, ...(currentAccount ? { currentAccount } : {}) };
+ const fiveHour = windows.get("fiveHour") ? finalizeWindow(windows.get("fiveHour")!) : undefined;
+ const weekly = windows.get("weekly") ? finalizeWindow(windows.get("weekly")!) : undefined;
+ const monthly = windows.get("monthly") ? finalizeWindow(windows.get("monthly")!) : undefined;
+ const customWindows = [...windows.entries()].flatMap(([key, window]) => key.startsWith("custom:")
+ ? [{ label: key.slice("custom:".length), ...finalizeWindow(window) }]
+ : []);
+ const quota: CodexCapacityQuota = {
+ ...(fiveHour ? { fiveHourPercent: fiveHour.usedPercent } : {}),
+ ...(weekly ? { weeklyPercent: weekly.usedPercent } : {}),
+ ...(monthly ? { monthlyPercent: monthly.usedPercent } : {}),
+ ...(customWindows.length > 0 ? {
+ customWindows: customWindows.map(window => ({ label: window.label, percent: window.usedPercent })),
+ } : {}),
+ updatedAt: updatedAt || now,
+ };
+ const excludedAccounts = accounts.length - included.size;
+ const aggregation: CodexCapacityAggregation = {
+ kind: "capacity-weighted-v1",
+ scope: "routable-known",
+ includedAccounts: included.size,
+ excludedAccounts,
+ unknownPlanAccounts,
+ missingQuotaAccounts,
+ pausedAccounts,
+ reauthAccounts,
+ incomplete: excludedAccounts > 0,
+ ...(fiveHour ? { fiveHour } : {}),
+ ...(weekly ? { weekly } : {}),
+ ...(monthly ? { monthly } : {}),
+ ...(customWindows.length > 0 ? { customWindows } : {}),
+ ...(currentAccount ? { currentAccount } : {}),
+ };
+ return { quota, aggregation, ...(currentAccount ? { currentAccount } : {}) };
+}
diff --git a/src/providers/quota.ts b/src/providers/quota.ts
index 131bc1358e..b637993361 100644
--- a/src/providers/quota.ts
+++ b/src/providers/quota.ts
@@ -1,4 +1,4 @@
-import { fetchMainAccountInfo, listCodexAuthAccounts } from "../codex/auth-api";
+import { effectiveCodexAuthAccountId, fetchMainAccountInfo, listCodexAuthAccounts } from "../codex/auth-api";
import { MAIN_CODEX_ACCOUNT_ID } from "../codex/main-account";
import { resolveEnvValue } from "../config";
import { getValidAccessToken, getValidAccessTokenForAccount } from "../oauth";
@@ -12,6 +12,11 @@ import {
sweepExpiredOnWrite,
type GenerationContext,
} from "../lib/state-store-sweeper";
+import {
+ aggregateCodexPoolCapacity,
+ type CodexCapacityAggregation,
+ type CodexCapacityQuota,
+} from "./codex-capacity";
/** Match oauth/index REFRESH_SKEW_MS — use stored access without refresh when still fresh. */
const ACCOUNT_TOKEN_SKEW_MS = 60_000;
@@ -47,6 +52,7 @@ export interface ProviderQuotaReport {
quota: ProviderQuota;
updatedAt: number;
reverseEngineered?: boolean;
+ aggregation?: CodexCapacityAggregation;
}
export interface ProviderQuotaResponse {
@@ -70,7 +76,7 @@ function cacheKey(config: OcxConfig): string {
.map(([name, provider]) => `${name}:${provider.adapter}:${provider.authMode ?? "key"}:${providerCodexAccountMode(name, provider) ?? "none"}:${provider.disabled === true ? "off" : "on"}:${provider.baseUrl}`)
.sort()
.join("|");
- return `${config.defaultProvider}|${config.activeCodexAccountId ?? ""}|${providers}`;
+ return `${config.defaultProvider}|${config.activeCodexAccountId ?? ""}|${effectiveCodexAuthAccountId(config)}|${providers}`;
}
function hasQuotaRows(quota: ProviderQuota | null | undefined): quota is ProviderQuota {
@@ -123,7 +129,12 @@ function isBuiltInChatGptForwardProvider(name: string, provider: OcxProviderConf
return name === OPENAI_CODEX_PROVIDER_ID && isCanonicalOpenAiForwardProvider(provider);
}
-function report(provider: string, source: string, quota: ProviderQuota): ProviderQuotaReport | null {
+function report(
+ provider: string,
+ source: string,
+ quota: ProviderQuota,
+ aggregation?: CodexCapacityAggregation,
+): ProviderQuotaReport | null {
if (!hasQuotaRows(quota)) return null;
return {
provider,
@@ -131,6 +142,7 @@ function report(provider: string, source: string, quota: ProviderQuota): Provide
source,
quota,
updatedAt: quota.updatedAt,
+ ...(aggregation ? { aggregation } : {}),
};
}
@@ -146,12 +158,19 @@ async function fetchChatGptForwardQuota(
return quota ? report(provider, "chatgpt:wham", quota) : null;
}
const accounts = await listCodexAuthAccounts(config, forceRefresh);
- const activeId = config.activeCodexAccountId || MAIN_CODEX_ACCOUNT_ID;
- const active = accounts.find(account => account.id === activeId)
+ const activeId = effectiveCodexAuthAccountId(config);
+ const capacityAccounts = accounts.map(account => ({ ...account, active: account.id === activeId }));
+ const active = capacityAccounts.find(account => account.active)
?? accounts.find(account => account.id === MAIN_CODEX_ACCOUNT_ID)
?? accounts[0];
- const quota = active?.quota ? { ...active.quota, updatedAt: active.quota.updatedAt ?? Date.now() } as ProviderQuota : null;
- return quota ? report(provider, "chatgpt:wham", quota) : null;
+ const capacity = aggregateCodexPoolCapacity(capacityAccounts, Date.now());
+ if (capacity.aggregation && capacity.quota) {
+ return report(provider, "chatgpt:wham", capacity.quota as ProviderQuota, capacity.aggregation);
+ }
+ const quota = active?.quota
+ ? { ...active.quota, updatedAt: active.quota.updatedAt ?? Date.now() } as CodexCapacityQuota
+ : null;
+ return quota ? report(provider, "chatgpt:wham", quota as ProviderQuota) : null;
}
function centsValue(value: unknown): number | undefined {
diff --git a/tests/provider-capacity.test.ts b/tests/provider-capacity.test.ts
new file mode 100644
index 0000000000..5844d328c1
--- /dev/null
+++ b/tests/provider-capacity.test.ts
@@ -0,0 +1,101 @@
+import { describe, expect, test } from "bun:test";
+import { aggregateCodexPoolCapacity, type CodexCapacityAccount } from "../src/providers/codex-capacity";
+
+const NOW = 1_800_000_000_000;
+const account = (
+ plan: string | null,
+ weeklyPercent: number | undefined,
+ options: Partial & { weeklyResetAt?: number; monthlyPercent?: number; monthlyResetAt?: number } = {},
+): CodexCapacityAccount => ({
+ isMain: false,
+ plan,
+ paused: false,
+ quota: weeklyPercent === undefined && options.monthlyPercent === undefined ? null : {
+ ...(weeklyPercent !== undefined ? { weeklyPercent } : {}),
+ ...(options.weeklyResetAt !== undefined ? { weeklyResetAt: options.weeklyResetAt } : {}),
+ ...(options.monthlyPercent !== undefined ? { monthlyPercent: options.monthlyPercent } : {}),
+ ...(options.monthlyResetAt !== undefined ? { monthlyResetAt: options.monthlyResetAt } : {}),
+ updatedAt: NOW,
+ },
+ ...options,
+});
+
+describe("configured-weight Codex pool capacity", () => {
+ test("Pro + Prolite + Plus produces the issue #874 estimate and recovery share", () => {
+ const result = aggregateCodexPoolCapacity([
+ account("pro", 10, { isMain: true, active: true, weeklyResetAt: NOW + 30_000 }),
+ account("prolite", 100, { weeklyResetAt: NOW + 10_000 }),
+ account("plus", 100, { weeklyResetAt: NOW + 20_000 }),
+ ], NOW);
+ expect(result.quota?.weeklyPercent).toBeCloseTo(30.769230769, 8);
+ expect(result.aggregation?.weekly).toMatchObject({ totalWeight: 26, consumedWeight: 8, remainingWeight: 18 });
+ expect(result.aggregation?.weekly?.nextRecoveryAt).toBe(NOW + 10_000);
+ expect(result.aggregation?.weekly?.nextRecoveryPercent).toBeCloseTo(19.23076923, 8);
+ expect(result.aggregation?.currentAccount?.quota?.weeklyPercent).toBe(10);
+ });
+
+ test("observed 8/100/100 and refreshed 9/100/100 remain exact weighted regressions", () => {
+ const rows = (mainPercent: number) => [
+ account("pro", mainPercent, { isMain: true, active: true }),
+ account("prolite", 100),
+ account("prolite", 100),
+ ];
+ expect(aggregateCodexPoolCapacity(rows(8), NOW).quota?.weeklyPercent).toBeCloseTo(38.66666667, 8);
+ expect(aggregateCodexPoolCapacity(rows(9), NOW).quota?.weeklyPercent).toBeCloseTo(39.33333333, 8);
+ });
+
+ test("same-time resets group partial consumed capacity and expose only recovery percent", () => {
+ const result = aggregateCodexPoolCapacity([
+ account("pro", 25, { weeklyResetAt: NOW + 10_000 }),
+ account("prolite", 40, { weeklyResetAt: NOW + 10_000 }),
+ account("plus", 100, { weeklyResetAt: NOW + 20_000 }),
+ ], NOW);
+ expect(result.aggregation?.weekly?.nextRecoveryPercent).toBeCloseTo(7 / 26 * 100, 8);
+ expect(result.aggregation?.weekly).not.toHaveProperty("projectedUsedPercentAfterReset");
+ });
+
+ test("unknown, missing, paused, and reauth rows are excluded with incomplete coverage", () => {
+ const result = aggregateCodexPoolCapacity([
+ account("pro", 10, { active: true, isMain: true }),
+ account("team", 50),
+ account("plus", undefined),
+ account("prolite", 20, { paused: true }),
+ account("business", 30, { needsReauth: true }),
+ ], NOW);
+ expect(result.aggregation).toMatchObject({
+ includedAccounts: 1,
+ excludedAccounts: 4,
+ unknownPlanAccounts: 1,
+ missingQuotaAccounts: 1,
+ pausedAccounts: 1,
+ reauthAccounts: 1,
+ incomplete: true,
+ });
+ expect(result.quota?.weeklyPercent).toBe(10);
+ });
+
+ test("weekly and monthly windows aggregate independently", () => {
+ const result = aggregateCodexPoolCapacity([
+ account("pro", 20),
+ account("prolite", undefined, { monthlyPercent: 60 }),
+ account("plus", 100, { monthlyPercent: 10 }),
+ ], NOW);
+ expect(result.aggregation?.weekly?.totalWeight).toBe(21);
+ expect(result.aggregation?.monthly?.totalWeight).toBe(6);
+ expect(result.quota?.weeklyPercent).toBeCloseTo(23.8095238, 7);
+ expect(result.quota?.monthlyPercent).toBeCloseTo(51.6666667, 7);
+ });
+
+ test("expired resets are ignored and all-excluded pools retain effective-account fallback truth", () => {
+ const expired = aggregateCodexPoolCapacity([
+ account("pro", 10, { weeklyResetAt: NOW - 1, active: true, isMain: true }),
+ ], NOW);
+ expect(expired.aggregation?.weekly).not.toHaveProperty("nextRecoveryAt");
+ const fallback = aggregateCodexPoolCapacity([
+ account("team", 70, { active: true, isMain: true }),
+ account("go", 80),
+ ], NOW);
+ expect(fallback.aggregation).toBeNull();
+ expect(fallback.currentAccount?.quota?.weeklyPercent).toBe(70);
+ });
+});
diff --git a/tests/provider-quota.test.ts b/tests/provider-quota.test.ts
index 11e22aaa46..d6cd47e5aa 100644
--- a/tests/provider-quota.test.ts
+++ b/tests/provider-quota.test.ts
@@ -3,6 +3,7 @@ import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync
import { tmpdir } from "node:os";
import { join } from "node:path";
import { clearAccountQuota } from "../src/codex/quota";
+import { clearCodexUpstreamHealth } from "../src/codex/routing";
import { saveCodexAccountCredential } from "../src/codex/account-store";
import { saveCredential } from "../src/oauth/store";
import { clearProviderQuotaCache, fetchProviderQuotaReports } from "../src/providers/quota";
@@ -70,6 +71,7 @@ beforeEach(() => {
tokens: { access_token: "chatgpt-main-access", account_id: "chatgpt-main-account" },
}));
clearAccountQuota();
+ clearCodexUpstreamHealth();
clearProviderQuotaCache();
});
@@ -480,7 +482,7 @@ describe("fetchProviderQuotaReports", () => {
expect(expired.reports).toEqual([]);
});
- test("pool mode reports the active added account", async () => {
+ test("pool mode reports a weighted estimate while preserving the effective account raw quota", async () => {
saveCodexAccountCredential("added", {
accessToken: "added-access",
refreshToken: "added-refresh",
@@ -488,18 +490,26 @@ describe("fetchProviderQuotaReports", () => {
chatgptAccountId: "added-chatgpt-id",
});
const config = testConfig();
- config.codexAccounts = [{ id: "added", email: "a@example.test", isMain: false }];
+ config.codexAccounts = [{ id: "added", email: "a@example.test", plan: "prolite", isMain: false }];
config.activeCodexAccountId = "added";
globalThis.fetch = (async (_input: RequestInfo | URL, init?: RequestInit) => {
const headers = init?.headers as Record | undefined;
const percent = headers?.["ChatGPT-Account-Id"] === "added-chatgpt-id" ? 77 : 11;
return new Response(JSON.stringify({
+ plan_type: headers?.["ChatGPT-Account-Id"] === "added-chatgpt-id" ? "prolite" : "plus",
rate_limit: { secondary_window: { used_percent: percent, reset_at: 1_789_000_000 } },
}), { status: 200, headers: { "content-type": "application/json" } });
}) as typeof fetch;
const result = await fetchProviderQuotaReports(config, true);
- expect(result.reports.find(row => row.provider === "openai")?.quota.weeklyPercent).toBe(77);
+ const openai = result.reports.find(row => row.provider === "openai");
+ expect(openai?.quota.weeklyPercent).toBe(66);
+ expect(openai?.aggregation).toMatchObject({
+ includedAccounts: 2,
+ excludedAccounts: 0,
+ incomplete: false,
+ currentAccount: { plan: "prolite", quota: { weeklyPercent: 77 } },
+ });
});
test("direct mode reports main without reading or repairing the added-account store", async () => {
From f3163da7cf64302600df7ca1c579347a5de208f6 Mon Sep 17 00:00:00 2001
From: luvs01 <27862058+luvs01@users.noreply.github.com>
Date: Sun, 2 Aug 2026 16:25:35 +0900
Subject: [PATCH 02/10] fix(gui): preserve Codex pool capacity freshness
Carry weighted pool metadata through the provider workspace shell and reject stale per-account quota readings.
Key report caching to a privacy-safe signature of every aggregation-relevant account state while keeping configured weight units internal.
Refs #874
---
.../ProviderWorkspaceShell.tsx | 3 +-
gui/tests/provider-capacity-shell.test.tsx | 103 +++++++++++++++++
src/codex/auth-api.ts | 7 +-
src/providers/codex-capacity.ts | 56 ++++++++--
src/providers/quota.ts | 88 ++++++++++++++-
tests/provider-capacity.test.ts | 41 ++++++-
tests/provider-quota.test.ts | 104 +++++++++++++++++-
7 files changed, 382 insertions(+), 20 deletions(-)
create mode 100644 gui/tests/provider-capacity-shell.test.tsx
diff --git a/gui/src/components/provider-workspace/ProviderWorkspaceShell.tsx b/gui/src/components/provider-workspace/ProviderWorkspaceShell.tsx
index b771ca7208..583ad279a0 100644
--- a/gui/src/components/provider-workspace/ProviderWorkspaceShell.tsx
+++ b/gui/src/components/provider-workspace/ProviderWorkspaceShell.tsx
@@ -218,7 +218,7 @@ export default function ProviderWorkspaceShell({
// be bypassed. The old derived-key effect always read the cached view, which is why a
// switch could leave the bars showing the previous account's quota.
void fetch(`${apiBase}/api/provider-quotas${quotaForceRefresh ? "?refresh=1" : ""}`)
- .then(r => readJsonIfOk<{ reports?: Array<{ provider: string; label?: string; source?: string; updatedAt?: number; quota?: unknown }> }>(r))
+ .then(r => readJsonIfOk<{ reports?: Array<{ provider: string; label?: string; source?: string; updatedAt?: number; quota?: unknown; aggregation?: unknown }> }>(r))
.then((data) => {
if (cancelled || !data) return;
// Merge so a partial/failed probe cannot wipe a previously good provider row.
@@ -231,6 +231,7 @@ export default function ProviderWorkspaceShell({
source: report.source,
updatedAt: typeof report.updatedAt === "number" ? report.updatedAt : Date.now(),
quota: report.quota,
+ ...(report.aggregation !== undefined ? { aggregation: report.aggregation } : {}),
};
}
writeSessionListCache(quotasCacheKey, next);
diff --git a/gui/tests/provider-capacity-shell.test.tsx b/gui/tests/provider-capacity-shell.test.tsx
new file mode 100644
index 0000000000..7039bc50dd
--- /dev/null
+++ b/gui/tests/provider-capacity-shell.test.tsx
@@ -0,0 +1,103 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { Window } from "happy-dom";
+import { act } from "react";
+import type { Root } from "react-dom/client";
+import ProviderWorkspaceShell from "../src/components/provider-workspace/ProviderWorkspaceShell";
+import { LanguageProvider } from "../src/i18n/provider";
+
+const globals = ["document", "window", "navigator", "localStorage", "sessionStorage", "IS_REACT_ACT_ENVIRONMENT"] as const;
+let previous: Record<(typeof globals)[number], unknown>;
+let originalFetch: typeof globalThis.fetch;
+let win: Window;
+let host: HTMLElement;
+let root: Root | null = null;
+
+beforeEach(() => {
+ previous = Object.fromEntries(globals.map(key => [key, Reflect.get(globalThis, key)])) as typeof previous;
+ originalFetch = globalThis.fetch;
+ win = new Window({ url: "http://localhost/" });
+ Object.defineProperty(win.navigator, "language", { configurable: true, value: "en-US" });
+ Object.defineProperty(win, "event", { configurable: true, writable: true, value: undefined });
+ Object.defineProperties(globalThis, {
+ document: { configurable: true, value: win.document },
+ window: { configurable: true, value: win },
+ navigator: { configurable: true, value: win.navigator },
+ localStorage: { configurable: true, value: win.localStorage },
+ sessionStorage: { configurable: true, value: win.sessionStorage },
+ });
+ (globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+ const recoveryAt = Date.UTC(2026, 7, 8, 4, 32);
+ Object.defineProperty(globalThis, "fetch", {
+ configurable: true,
+ value: async (input: string) => {
+ const url = String(input);
+ const body = url.includes("/api/provider-quotas") ? {
+ reports: [{
+ provider: "openai",
+ label: "OpenAI (Codex login)",
+ source: "chatgpt:wham",
+ updatedAt: Date.now(),
+ quota: { weeklyPercent: 30.8, updatedAt: Date.now() },
+ aggregation: {
+ kind: "capacity-weighted-v1",
+ scope: "routable-known",
+ includedAccounts: 2,
+ excludedAccounts: 1,
+ unknownPlanAccounts: 1,
+ missingQuotaAccounts: 0,
+ pausedAccounts: 0,
+ reauthAccounts: 0,
+ staleQuotaAccounts: 0,
+ incomplete: true,
+ weekly: { usedPercent: 30.8, includedAccounts: 2, updatedAt: Date.now(), nextRecoveryAt: recoveryAt, nextRecoveryPercent: 19.2 },
+ currentAccount: { isMain: true, plan: "pro", quota: { weeklyPercent: 8, updatedAt: Date.now() } },
+ },
+ }],
+ } : {};
+ return { ok: true, status: 200, json: async () => body, text: async () => JSON.stringify(body) } as unknown as Response;
+ },
+ });
+ host = win.document.createElement("div") as unknown as HTMLElement;
+ win.document.body.appendChild(host as never);
+});
+
+afterEach(async () => {
+ if (root) {
+ const current = root;
+ await act(async () => { current.unmount(); });
+ root = null;
+ }
+ for (const key of globals) Object.defineProperty(globalThis, key, { configurable: true, value: previous[key] });
+ Object.defineProperty(globalThis, "fetch", { configurable: true, value: originalFetch });
+});
+
+test("provider quota fetch preserves aggregate capacity through shell state and render", async () => {
+ const { createRoot } = await import("react-dom/client");
+ await act(async () => {
+ root = createRoot(host);
+ root.render(
+
+ {}}
+ onAddProvider={() => {}}
+ />
+ ,
+ );
+ });
+ await act(async () => { await new Promise(resolve => setTimeout(resolve, 30)); });
+
+ const text = host.textContent ?? "";
+ expect(text).toContain("Configured-weight pool estimate");
+ expect(text).toContain("31% used");
+ expect(text).toContain("Current effective account · pro");
+ expect(text).toContain("8%");
+ expect(text).toContain("Incomplete coverage: 1 account(s) excluded, including 1 unknown plan(s)");
+ expect(text).toContain("Next capacity recovery");
+ expect(text).toContain("+19.2% pool capacity");
+ expect(text).toMatch(/Aug 8, 2026.*(4:32|1:32)/);
+ expect(text).not.toMatch(/configured units|weighted units|units remaining|projected/i);
+});
diff --git a/src/codex/auth-api.ts b/src/codex/auth-api.ts
index f4345d0fec..8f9e257ed7 100644
--- a/src/codex/auth-api.ts
+++ b/src/codex/auth-api.ts
@@ -834,7 +834,12 @@ export async function listCodexAuthAccounts(config: OcxConfig, forceRefresh = fa
paused: isCodexAccountPaused(runtimeConfig, MAIN_CODEX_ACCOUNT_ID),
hasCredential: hasMainCredential,
needsReauth: mainNeedsReauth,
- quota: mainInfo.quota ? { ...quotaForPlan({ ...mainInfo.quota, updatedAt: Date.now() }, mainInfo.plan) } : null,
+ quota: mainInfo.quota ? {
+ ...quotaForPlan({
+ ...mainInfo.quota,
+ updatedAt: getAccountQuota(MAIN_CODEX_ACCOUNT_ID)?.updatedAt ?? Date.now(),
+ }, mainInfo.plan),
+ } : null,
...oauthAccountHealthFields("codex", MAIN_CODEX_ACCOUNT_ID, mainHealth),
};
return [main, ...withQuota];
diff --git a/src/providers/codex-capacity.ts b/src/providers/codex-capacity.ts
index c24c4b741a..4e413e11fa 100644
--- a/src/providers/codex-capacity.ts
+++ b/src/providers/codex-capacity.ts
@@ -5,6 +5,9 @@ export const CODEX_CONFIGURED_CAPACITY_WEIGHTS = {
pro: 20,
} as const;
+/** Match the provider-report last-good freshness bound. */
+export const CODEX_CAPACITY_MAX_QUOTA_AGE_MS = 30 * 60_000;
+
export type CodexCapacityQuota = {
fiveHourPercent?: number;
fiveHourResetAt?: number;
@@ -28,9 +31,13 @@ export interface CodexCapacityAccount {
export interface CodexCapacityWindowAggregation {
usedPercent: number;
includedAccounts: number;
- totalWeight: number;
- consumedWeight: number;
- remainingWeight: number;
+ /** Internal calculation evidence; stripped from the management API response. */
+ totalWeight?: number;
+ /** Internal calculation evidence; stripped from the management API response. */
+ consumedWeight?: number;
+ /** Internal calculation evidence; stripped from the management API response. */
+ remainingWeight?: number;
+ updatedAt: number;
nextRecoveryAt?: number;
nextRecoveryPercent?: number;
}
@@ -44,6 +51,7 @@ export interface CodexCapacityAggregation {
missingQuotaAccounts: number;
pausedAccounts: number;
reauthAccounts: number;
+ staleQuotaAccounts: number;
incomplete: boolean;
fiveHour?: CodexCapacityWindowAggregation;
weekly?: CodexCapacityWindowAggregation;
@@ -67,6 +75,7 @@ type MutableWindow = {
consumedWeight: number;
includedAccounts: number;
recoveries: Map;
+ oldestUpdatedAt: number;
};
function configuredWeight(plan: string | null | undefined): number | undefined {
@@ -94,17 +103,20 @@ function addWindow(
weight: number,
percent: number,
resetAt: number | undefined,
+ updatedAt: number,
): void {
const window = windows.get(key) ?? {
totalWeight: 0,
consumedWeight: 0,
includedAccounts: 0,
recoveries: new Map(),
+ oldestUpdatedAt: updatedAt,
};
const consumed = weight * percent / 100;
window.totalWeight += weight;
window.consumedWeight += consumed;
window.includedAccounts += 1;
+ window.oldestUpdatedAt = Math.min(window.oldestUpdatedAt, updatedAt);
if (resetAt !== undefined) {
window.recoveries.set(resetAt, (window.recoveries.get(resetAt) ?? 0) + consumed);
}
@@ -120,6 +132,7 @@ function finalizeWindow(window: MutableWindow): CodexCapacityWindowAggregation {
totalWeight: window.totalWeight,
consumedWeight: window.consumedWeight,
remainingWeight: window.totalWeight - window.consumedWeight,
+ updatedAt: window.oldestUpdatedAt,
...(nextRecoveryAt !== undefined ? { nextRecoveryAt } : {}),
...(recovered !== undefined ? { nextRecoveryPercent: recovered / window.totalWeight * 100 } : {}),
};
@@ -144,7 +157,7 @@ export function aggregateCodexPoolCapacity(
let missingQuotaAccounts = 0;
let pausedAccounts = 0;
let reauthAccounts = 0;
- let updatedAt = 0;
+ let staleQuotaAccounts = 0;
for (const account of accounts) {
const weight = configuredWeight(account.plan);
@@ -152,6 +165,10 @@ export function aggregateCodexPoolCapacity(
if (account.paused) pausedAccounts += 1;
if (account.needsReauth) reauthAccounts += 1;
const quota = account.quota;
+ const quotaFresh = !!quota
+ && Number.isFinite(quota.updatedAt)
+ && now - quota.updatedAt <= CODEX_CAPACITY_MAX_QUOTA_AGE_MS;
+ if (quota && !quotaFresh) staleQuotaAccounts += 1;
const standard = quota ? [
["fiveHour", quota.fiveHourPercent, quota.fiveHourResetAt],
["weekly", quota.weeklyPercent, quota.weeklyResetAt],
@@ -161,28 +178,43 @@ export function aggregateCodexPoolCapacity(
const hasQuota = standard.some(([, percent]) => normalizedPercent(percent) !== undefined)
|| custom.some(window => normalizedPercent(window.percent) !== undefined);
if (!hasQuota) missingQuotaAccounts += 1;
- if (account.paused || account.needsReauth || weight === undefined || !quota || !hasQuota) continue;
+ if (account.paused || account.needsReauth || weight === undefined || !quota || !hasQuota || !quotaFresh) continue;
let contributed = false;
for (const [key, rawPercent, rawReset] of standard) {
const percent = normalizedPercent(rawPercent);
if (percent === undefined) continue;
- addWindow(windows, key, weight, percent, futureResetMs(rawReset, now));
+ addWindow(windows, key, weight, percent, futureResetMs(rawReset, now), quota.updatedAt);
contributed = true;
}
for (const customWindow of custom) {
const percent = normalizedPercent(customWindow.percent);
if (percent === undefined) continue;
- addWindow(windows, `custom:${customWindow.label}`, weight, percent, futureResetMs(customWindow.resetAt, now));
+ addWindow(windows, `custom:${customWindow.label}`, weight, percent, futureResetMs(customWindow.resetAt, now), quota.updatedAt);
contributed = true;
}
if (contributed) {
included.add(account);
- updatedAt = Math.max(updatedAt, quota.updatedAt);
}
}
- if (windows.size === 0) return { quota: null, aggregation: null, ...(currentAccount ? { currentAccount } : {}) };
+ if (windows.size === 0) {
+ if (staleQuotaAccounts === 0) return { quota: null, aggregation: null, ...(currentAccount ? { currentAccount } : {}) };
+ const aggregation: CodexCapacityAggregation = {
+ kind: "capacity-weighted-v1",
+ scope: "routable-known",
+ includedAccounts: 0,
+ excludedAccounts: accounts.length,
+ unknownPlanAccounts,
+ missingQuotaAccounts,
+ pausedAccounts,
+ reauthAccounts,
+ staleQuotaAccounts,
+ incomplete: true,
+ ...(currentAccount ? { currentAccount } : {}),
+ };
+ return { quota: null, aggregation, ...(currentAccount ? { currentAccount } : {}) };
+ }
const fiveHour = windows.get("fiveHour") ? finalizeWindow(windows.get("fiveHour")!) : undefined;
const weekly = windows.get("weekly") ? finalizeWindow(windows.get("weekly")!) : undefined;
const monthly = windows.get("monthly") ? finalizeWindow(windows.get("monthly")!) : undefined;
@@ -196,7 +228,10 @@ export function aggregateCodexPoolCapacity(
...(customWindows.length > 0 ? {
customWindows: customWindows.map(window => ({ label: window.label, percent: window.usedPercent })),
} : {}),
- updatedAt: updatedAt || now,
+ updatedAt: Math.min(
+ ...[fiveHour, weekly, monthly, ...customWindows]
+ .flatMap(window => window ? [window.updatedAt] : []),
+ ),
};
const excludedAccounts = accounts.length - included.size;
const aggregation: CodexCapacityAggregation = {
@@ -208,6 +243,7 @@ export function aggregateCodexPoolCapacity(
missingQuotaAccounts,
pausedAccounts,
reauthAccounts,
+ staleQuotaAccounts,
incomplete: excludedAccounts > 0,
...(fiveHour ? { fiveHour } : {}),
...(weekly ? { weekly } : {}),
diff --git a/src/providers/quota.ts b/src/providers/quota.ts
index b637993361..3fd18a8f24 100644
--- a/src/providers/quota.ts
+++ b/src/providers/quota.ts
@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
import { effectiveCodexAuthAccountId, fetchMainAccountInfo, listCodexAuthAccounts } from "../codex/auth-api";
import { MAIN_CODEX_ACCOUNT_ID } from "../codex/main-account";
import { resolveEnvValue } from "../config";
@@ -14,6 +15,7 @@ import {
} from "../lib/state-store-sweeper";
import {
aggregateCodexPoolCapacity,
+ CODEX_CAPACITY_MAX_QUOTA_AGE_MS,
type CodexCapacityAggregation,
type CodexCapacityQuota,
} from "./codex-capacity";
@@ -26,7 +28,7 @@ const REQUEST_TIMEOUT_MS = 8_000;
const KIMI_CODE_BASE_URL = "https://api.kimi.com/coding/v1";
const KIMI_CODE_USAGE_URL = `${KIMI_CODE_BASE_URL}/usages`;
/** Keep a failed probe's previous row at most this long before dropping it. */
-const LAST_GOOD_MAX_AGE_MS = 30 * 60_000;
+const LAST_GOOD_MAX_AGE_MS = CODEX_CAPACITY_MAX_QUOTA_AGE_MS;
export interface ProviderQuotaWindow {
label: string;
@@ -76,7 +78,73 @@ function cacheKey(config: OcxConfig): string {
.map(([name, provider]) => `${name}:${provider.adapter}:${provider.authMode ?? "key"}:${providerCodexAccountMode(name, provider) ?? "none"}:${provider.disabled === true ? "off" : "on"}:${provider.baseUrl}`)
.sort()
.join("|");
- return `${config.defaultProvider}|${config.activeCodexAccountId ?? ""}|${effectiveCodexAuthAccountId(config)}|${providers}`;
+ return `${config.defaultProvider}|${providers}`;
+}
+
+function quotaSignatureValue(quota: CodexCapacityQuota | null): unknown {
+ if (!quota) return null;
+ return {
+ fiveHourPercent: quota.fiveHourPercent,
+ fiveHourResetAt: quota.fiveHourResetAt,
+ weeklyPercent: quota.weeklyPercent,
+ weeklyResetAt: quota.weeklyResetAt,
+ monthlyPercent: quota.monthlyPercent,
+ monthlyResetAt: quota.monthlyResetAt,
+ updatedAt: quota.updatedAt,
+ customWindows: [...(quota.customWindows ?? [])]
+ .map(window => ({ label: window.label, percent: window.percent, resetAt: window.resetAt }))
+ .sort((a, b) => a.label.localeCompare(b.label)),
+ };
+}
+
+/** Hash only presentation-relevant state; account ids and email addresses never enter the key. */
+function cacheKeyWithAggregationState(config: OcxConfig): string | Promise {
+ const base = cacheKey(config);
+ const poolEnabled = Object.entries(config.providers).some(([name, provider]) => (
+ provider.disabled !== true
+ && isBuiltInChatGptForwardProvider(name, provider)
+ && providerCodexAccountMode(name, provider) !== "direct"
+ ));
+ if (!poolEnabled) return base;
+ return (async () => {
+ try {
+ const activeId = effectiveCodexAuthAccountId(config);
+ const rows = (await listCodexAuthAccounts(config, false)).map(account => ({
+ isMain: account.isMain,
+ active: account.id === activeId,
+ plan: account.plan?.trim().toLowerCase() ?? null,
+ paused: account.paused,
+ needsReauth: account.needsReauth === true,
+ quota: quotaSignatureValue(account.quota as CodexCapacityQuota | null),
+ }));
+ const canonicalRows = rows.map(row => JSON.stringify(row)).sort();
+ const digest = createHash("sha256").update(JSON.stringify(canonicalRows)).digest("hex").slice(0, 24);
+ return `${base}|codex-pool:${digest}`;
+ } catch {
+ return `${base}|codex-pool:unavailable`;
+ }
+ })();
+}
+
+function publicCapacityWindow(window: import("./codex-capacity").CodexCapacityWindowAggregation) {
+ const { totalWeight: _totalWeight, consumedWeight: _consumedWeight, remainingWeight: _remainingWeight, ...safe } = window;
+ return safe;
+}
+
+/** Management API metadata intentionally omits configured/weighted unit counts. */
+function publicCapacityAggregation(aggregation: CodexCapacityAggregation): CodexCapacityAggregation {
+ return {
+ ...aggregation,
+ ...(aggregation.fiveHour ? { fiveHour: publicCapacityWindow(aggregation.fiveHour) } : {}),
+ ...(aggregation.weekly ? { weekly: publicCapacityWindow(aggregation.weekly) } : {}),
+ ...(aggregation.monthly ? { monthly: publicCapacityWindow(aggregation.monthly) } : {}),
+ ...(aggregation.customWindows ? {
+ customWindows: aggregation.customWindows.map(window => ({
+ label: window.label,
+ ...publicCapacityWindow(window),
+ })),
+ } : {}),
+ };
}
function hasQuotaRows(quota: ProviderQuota | null | undefined): quota is ProviderQuota {
@@ -165,12 +233,17 @@ async function fetchChatGptForwardQuota(
?? accounts[0];
const capacity = aggregateCodexPoolCapacity(capacityAccounts, Date.now());
if (capacity.aggregation && capacity.quota) {
- return report(provider, "chatgpt:wham", capacity.quota as ProviderQuota, capacity.aggregation);
+ return report(provider, "chatgpt:wham", capacity.quota as ProviderQuota, publicCapacityAggregation(capacity.aggregation));
}
const quota = active?.quota
? { ...active.quota, updatedAt: active.quota.updatedAt ?? Date.now() } as CodexCapacityQuota
: null;
- return quota ? report(provider, "chatgpt:wham", quota as ProviderQuota) : null;
+ return quota ? report(
+ provider,
+ "chatgpt:wham",
+ quota as ProviderQuota,
+ capacity.aggregation ? publicCapacityAggregation(capacity.aggregation) : undefined,
+ ) : null;
}
function centsValue(value: unknown): number | undefined {
@@ -936,7 +1009,8 @@ async function maybeFetchProviderQuota(
}
export async function fetchProviderQuotaReports(config: OcxConfig, forceRefresh = false): Promise {
- const key = cacheKey(config);
+ const keyCandidate = cacheKeyWithAggregationState(config);
+ const key = typeof keyCandidate === "string" ? keyCandidate : await keyCandidate;
const writerGeneration = captureConfigGeneration();
const now = Date.now();
// The cache fast path must not extend a preserved last-good row past its 30-minute bound:
@@ -972,7 +1046,9 @@ export async function fetchProviderQuotaReports(config: OcxConfig, forceRefresh
// Commit only when this probe still holds authority (no clear/force superseded it).
if (epoch === invalidationEpoch) {
const reports = response.reports.filter(item => mayCommitProviderQuotaKey(item.provider, writerGeneration));
- cache = { key, ts: Date.now(), response: { ...response, reports } };
+ const commitKeyCandidate = cacheKeyWithAggregationState(config);
+ const commitKey = typeof commitKeyCandidate === "string" ? commitKeyCandidate : await commitKeyCandidate;
+ cache = { key: commitKey, ts: Date.now(), response: { ...response, reports } };
}
return response;
})();
diff --git a/tests/provider-capacity.test.ts b/tests/provider-capacity.test.ts
index 5844d328c1..4ae364d909 100644
--- a/tests/provider-capacity.test.ts
+++ b/tests/provider-capacity.test.ts
@@ -1,5 +1,5 @@
import { describe, expect, test } from "bun:test";
-import { aggregateCodexPoolCapacity, type CodexCapacityAccount } from "../src/providers/codex-capacity";
+import { aggregateCodexPoolCapacity, CODEX_CAPACITY_MAX_QUOTA_AGE_MS, type CodexCapacityAccount } from "../src/providers/codex-capacity";
const NOW = 1_800_000_000_000;
const account = (
@@ -98,4 +98,43 @@ describe("configured-weight Codex pool capacity", () => {
expect(fallback.aggregation).toBeNull();
expect(fallback.currentAccount?.quota?.weeklyPercent).toBe(70);
});
+
+ test("mixed-age rows exclude stale capacity and use the oldest included reading", () => {
+ const oldestIncluded = account("plus", 40);
+ oldestIncluded.quota = { ...oldestIncluded.quota!, updatedAt: NOW - 20_000 };
+ const newerIncluded = account("business", 20);
+ newerIncluded.quota = { ...newerIncluded.quota!, updatedAt: NOW - 5_000 };
+ const staleHighWeight = account("pro", 100);
+ staleHighWeight.quota = {
+ ...staleHighWeight.quota!,
+ updatedAt: NOW - CODEX_CAPACITY_MAX_QUOTA_AGE_MS - 1,
+ };
+
+ const result = aggregateCodexPoolCapacity([oldestIncluded, newerIncluded, staleHighWeight], NOW);
+ expect(result.quota?.weeklyPercent).toBeCloseTo(30, 8);
+ expect(result.quota?.updatedAt).toBe(NOW - 20_000);
+ expect(result.aggregation?.weekly?.updatedAt).toBe(NOW - 20_000);
+ expect(result.aggregation).toMatchObject({
+ includedAccounts: 2,
+ excludedAccounts: 1,
+ staleQuotaAccounts: 1,
+ incomplete: true,
+ });
+ });
+
+ test("all-stale rows expose incomplete coverage without an aggregate window", () => {
+ const rows = [account("pro", 80, { active: true, isMain: true }), account("prolite", 20)];
+ for (const row of rows) {
+ row.quota = { ...row.quota!, updatedAt: NOW - CODEX_CAPACITY_MAX_QUOTA_AGE_MS - 1 };
+ }
+ const result = aggregateCodexPoolCapacity(rows, NOW);
+ expect(result.quota).toBeNull();
+ expect(result.aggregation).toMatchObject({
+ includedAccounts: 0,
+ excludedAccounts: 2,
+ staleQuotaAccounts: 2,
+ incomplete: true,
+ });
+ expect(result.aggregation?.weekly).toBeUndefined();
+ });
});
diff --git a/tests/provider-quota.test.ts b/tests/provider-quota.test.ts
index d6cd47e5aa..38c6c3bc78 100644
--- a/tests/provider-quota.test.ts
+++ b/tests/provider-quota.test.ts
@@ -2,7 +2,8 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
-import { clearAccountQuota } from "../src/codex/quota";
+import { clearAccountQuota, updateAccountQuota } from "../src/codex/quota";
+import { clearAccountNeedsReauth, markAccountNeedsReauth } from "../src/codex/account-runtime-state";
import { clearCodexUpstreamHealth } from "../src/codex/routing";
import { saveCodexAccountCredential } from "../src/codex/account-store";
import { saveCredential } from "../src/oauth/store";
@@ -510,6 +511,107 @@ describe("fetchProviderQuotaReports", () => {
incomplete: false,
currentAccount: { plan: "prolite", quota: { weeklyPercent: 77 } },
});
+ expect(JSON.stringify(openai?.aggregation)).not.toMatch(/(?:total|consumed|remaining)Weight|projectedUsedPercent/i);
+ });
+
+ test("ordinary fetch reflects pausing a non-active pool account", async () => {
+ saveCodexAccountCredential("added", {
+ accessToken: "added-access", refreshToken: "added-refresh",
+ expiresAt: Date.now() + 3600_000, chatgptAccountId: "added-chatgpt-id",
+ });
+ const config = testConfig();
+ config.providers = { openai: config.providers.openai };
+ config.codexAccounts = [{ id: "added", email: "a@example.test", plan: "prolite", isMain: false }];
+ globalThis.fetch = (async (_input: RequestInfo | URL, init?: RequestInit) => {
+ const added = (init?.headers as Record | undefined)?.["ChatGPT-Account-Id"] === "added-chatgpt-id";
+ return new Response(JSON.stringify({
+ plan_type: added ? "prolite" : "plus",
+ rate_limit: { secondary_window: { used_percent: added ? 77 : 11, reset_at: 1_999_000_000 } },
+ }), { status: 200, headers: { "content-type": "application/json" } });
+ }) as typeof fetch;
+
+ expect((await fetchProviderQuotaReports(config, true)).reports[0]?.quota.weeklyPercent).toBe(66);
+ config.pausedCodexAccountIds = ["added"];
+ const paused = (await fetchProviderQuotaReports(config)).reports[0];
+ expect(paused?.quota.weeklyPercent).toBe(11);
+ expect(paused?.aggregation).toMatchObject({ includedAccounts: 1, excludedAccounts: 1, incomplete: true });
+ });
+
+ test("ordinary fetch separates plan, quota, and effective-account cache states", async () => {
+ saveCodexAccountCredential("added", {
+ accessToken: "added-access", refreshToken: "added-refresh",
+ expiresAt: Date.now() + 3600_000, chatgptAccountId: "added-chatgpt-id",
+ });
+ const config = testConfig();
+ config.providers = { openai: config.providers.openai };
+ config.codexAccounts = [{ id: "added", email: "a@example.test", plan: "prolite", isMain: false }];
+ globalThis.fetch = (async (_input: RequestInfo | URL, init?: RequestInit) => {
+ const added = (init?.headers as Record | undefined)?.["ChatGPT-Account-Id"] === "added-chatgpt-id";
+ return new Response(JSON.stringify({
+ plan_type: added ? "prolite" : "plus",
+ rate_limit: { secondary_window: { used_percent: added ? 77 : 11, reset_at: 1_999_000_000 } },
+ }), { status: 200, headers: { "content-type": "application/json" } });
+ }) as typeof fetch;
+
+ await fetchProviderQuotaReports(config, true);
+ config.codexAccounts[0]!.plan = "pro";
+ expect((await fetchProviderQuotaReports(config)).reports[0]?.aggregation?.weekly?.usedPercent).toBeCloseTo((20 * 77 + 11) / 21, 8);
+ config.activeCodexAccountId = "added";
+ expect((await fetchProviderQuotaReports(config)).reports[0]?.aggregation?.currentAccount).toMatchObject({ plan: "pro", quota: { weeklyPercent: 77 } });
+ updateAccountQuota("added", 20, 1_999_000_000);
+ expect((await fetchProviderQuotaReports(config)).reports[0]?.aggregation?.weekly?.usedPercent).toBeCloseTo((20 * 20 + 11) / 21, 8);
+ });
+
+ test("ordinary fetch reflects runtime reauthentication state", async () => {
+ saveCodexAccountCredential("added", {
+ accessToken: "added-access", refreshToken: "added-refresh",
+ expiresAt: Date.now() + 3600_000, chatgptAccountId: "added-chatgpt-id",
+ });
+ const config = testConfig();
+ config.providers = { openai: config.providers.openai };
+ config.codexAccounts = [{ id: "added", email: "a@example.test", plan: "prolite", isMain: false }];
+ globalThis.fetch = (async (_input: RequestInfo | URL, init?: RequestInit) => {
+ const added = (init?.headers as Record | undefined)?.["ChatGPT-Account-Id"] === "added-chatgpt-id";
+ return new Response(JSON.stringify({
+ plan_type: added ? "prolite" : "plus",
+ rate_limit: { secondary_window: { used_percent: added ? 77 : 11, reset_at: 1_999_000_000 } },
+ }), { status: 200, headers: { "content-type": "application/json" } });
+ }) as typeof fetch;
+
+ await fetchProviderQuotaReports(config, true);
+ markAccountNeedsReauth("added");
+ const reauth = (await fetchProviderQuotaReports(config)).reports[0];
+ expect(reauth?.aggregation).toMatchObject({ includedAccounts: 1, reauthAccounts: 1, incomplete: true });
+ clearAccountNeedsReauth("added");
+ });
+
+ test("ordinary fetch reflects pool account add and remove", async () => {
+ saveCodexAccountCredential("added", {
+ accessToken: "added-access", refreshToken: "added-refresh",
+ expiresAt: Date.now() + 3600_000, chatgptAccountId: "added-chatgpt-id",
+ });
+ const config = testConfig();
+ config.providers = { openai: config.providers.openai };
+ config.codexAccounts = [{ id: "added", email: "a@example.test", plan: "prolite", isMain: false }];
+ globalThis.fetch = (async (_input: RequestInfo | URL, init?: RequestInit) => {
+ const id = (init?.headers as Record | undefined)?.["ChatGPT-Account-Id"];
+ const plan = id === "added-chatgpt-id" ? "prolite" : id === "second-chatgpt-id" ? "business" : "plus";
+ const percent = id === "added-chatgpt-id" ? 77 : id === "second-chatgpt-id" ? 33 : 11;
+ return new Response(JSON.stringify({
+ plan_type: plan,
+ rate_limit: { secondary_window: { used_percent: percent, reset_at: 1_999_000_000 } },
+ }), { status: 200, headers: { "content-type": "application/json" } });
+ }) as typeof fetch;
+
+ expect((await fetchProviderQuotaReports(config, true)).reports[0]?.aggregation?.includedAccounts).toBe(2);
+ saveCodexAccountCredential("second", {
+ accessToken: "second-access", refreshToken: "second-refresh",
+ expiresAt: Date.now() + 3600_000, chatgptAccountId: "second-chatgpt-id",
+ });
+ config.codexAccounts.push({ id: "second", email: "b@example.test", plan: "business", isMain: false });
+ expect((await fetchProviderQuotaReports(config)).reports[0]?.aggregation?.includedAccounts).toBe(3);
+ config.codexAccounts = config.codexAccounts.filter(account => account.id !== "second");
+ expect((await fetchProviderQuotaReports(config)).reports[0]?.aggregation?.includedAccounts).toBe(2);
});
test("direct mode reports main without reading or repairing the added-account store", async () => {
From ca35a559f1a1afe57772a68a0b8cb2a73b87c9ef Mon Sep 17 00:00:00 2001
From: luvs01 <27862058+luvs01@users.noreply.github.com>
Date: Sun, 2 Aug 2026 16:33:26 +0900
Subject: [PATCH 03/10] docs: explain Codex pool capacity estimate
Document the Providers overview's weighted pool percentage, effective-account quota, recovery display, incomplete coverage, and display-only routing boundary.
Refs #874
---
docs-site/src/content/docs/guides/providers.md | 16 ++++++++++++++++
.../src/content/docs/guides/web-dashboard.md | 5 +++++
2 files changed, 21 insertions(+)
diff --git a/docs-site/src/content/docs/guides/providers.md b/docs-site/src/content/docs/guides/providers.md
index 341d822203..907e7efc9e 100644
--- a/docs-site/src/content/docs/guides/providers.md
+++ b/docs-site/src/content/docs/guides/providers.md
@@ -24,6 +24,22 @@ Auth page can restore it: absent rows are created from the canonical preset, dis
rows are re-enabled without replacing saved mode or model settings, and noncanonical `openai`
rows are not offered that recovery path.
+### Providers overview pool capacity
+
+For Codex login in Pool mode, the Providers overview shows a configured-weight estimate of the
+pool's used capacity rather than presenting one arbitrary account as the provider total. The same
+row also shows the current effective account's raw quota percentage, so you can distinguish the
+pool estimate from the account that a new request would use.
+
+When reset information is available, the overview shows the next reset time and the capacity that
+reset is expected to recover as `+N% pool capacity`. **Incomplete coverage** means one or more pool
+accounts could not safely contribute to the estimate, for example because their plan or quota is
+unknown, their reading is stale, or the account is paused or needs reauthentication.
+
+This estimate is display-only. It does not change account selection, session affinity, automatic
+switching, cooldowns, or any other routing decision. Use the [Codex Auth account pool](/guides/web-dashboard/#codex-auth-and-account-pools)
+for the individual account state and routing controls.
+
Shipped v1 configs migrate automatically to marker 2 and one option-aware row. The original config
is retained once at `~/.opencodex/config.json.pre-openai-tiers-v2.bak`; restore it with
`cp ~/.opencodex/config.json.pre-openai-tiers-v2.bak ~/.opencodex/config.json`.
diff --git a/docs-site/src/content/docs/guides/web-dashboard.md b/docs-site/src/content/docs/guides/web-dashboard.md
index a4198dbe59..04d74877c1 100644
--- a/docs-site/src/content/docs/guides/web-dashboard.md
+++ b/docs-site/src/content/docs/guides/web-dashboard.md
@@ -100,6 +100,11 @@ catalog entry.
The **Codex Auth** page manages the native ChatGPT/Codex route:
+The Providers overview separately summarizes Pool-mode usage as a display-only weighted capacity
+estimate, alongside the effective account's raw quota and the next capacity recovery. See
+[Providers overview pool capacity](/guides/providers/#providers-overview-pool-capacity) for the
+visible fields, incomplete-coverage meaning, and routing boundary.
+
- Manually choosing an account changes the next new Codex session; an already-bound thread keeps its
current account for that manual switch.
- Thread affinity prevents per-request flapping. With quota auto-switch enabled, a long-running
From eb5f7b356160a005481f9408f3238e09515f5355 Mon Sep 17 00:00:00 2001
From: luvs01 <27862058+luvs01@users.noreply.github.com>
Date: Sun, 2 Aug 2026 16:50:17 +0900
Subject: [PATCH 04/10] fix(gui): harden pool capacity presentation
Replace stale provider quota state authoritatively, retain per-window coverage, and distinguish aggregate, fallback, and coverage-only reports.
Reject cache commits when pool presentation state changes during a probe and allow recovery details to wrap in narrow panes.
Refs #874
---
.../ProviderOverviewDashboard.tsx | 10 +-
.../ProviderWorkspaceShell.tsx | 76 +++++++--
gui/src/provider-workspace/report.ts | 21 ++-
.../styles/provider-overview-dashboard.css | 21 +++
gui/tests/provider-capacity-shell.test.tsx | 144 ++++++++++++++----
gui/tests/provider-capacity.test.ts | 36 +++++
src/providers/codex-capacity.ts | 28 +++-
src/providers/quota.ts | 48 ++++--
tests/provider-capacity.test.ts | 33 +++-
tests/provider-quota.test.ts | 64 ++++++++
10 files changed, 414 insertions(+), 67 deletions(-)
diff --git a/gui/src/components/provider-workspace/ProviderOverviewDashboard.tsx b/gui/src/components/provider-workspace/ProviderOverviewDashboard.tsx
index 5ae0d6c5b3..ce0f676db4 100644
--- a/gui/src/components/provider-workspace/ProviderOverviewDashboard.tsx
+++ b/gui/src/components/provider-workspace/ProviderOverviewDashboard.tsx
@@ -239,7 +239,9 @@ function ProviderCapacityQuota({ report, pending }: { report: ProviderQuotaRepor
const t = useT();
const { locale } = useI18n();
const aggregation = capacityAggregationFromReport(report);
- const recoveryRows: Array<{ label: string; window: CapacityWindowView }> = aggregation ? [
+ const primaryQuota = accountQuotaFromReport(report);
+ const showsAggregate = aggregation?.presentation === "aggregate";
+ const recoveryRows: Array<{ label: string; window: CapacityWindowView }> = showsAggregate && aggregation ? [
...(aggregation.fiveHour ? [{ label: t("codexAuth.fiveHour"), window: aggregation.fiveHour }] : []),
...(aggregation.weekly ? [{ label: t("codexAuth.weekly"), window: aggregation.weekly }] : []),
...(aggregation.monthly ? [{ label: t("codexAuth.monthly"), window: aggregation.monthly }] : []),
@@ -253,8 +255,8 @@ function ProviderCapacityQuota({ report, pending }: { report: ProviderQuotaRepor
return (
<>
- {aggregation && {t("pws.capacity.estimate")}
}
-
+ {showsAggregate && {t("pws.capacity.estimate")}
}
+ {(primaryQuota || pending) && }
{aggregation && (
{recoveryRows.flatMap(({ label, window }) => (
@@ -265,7 +267,7 @@ function ProviderCapacityQuota({ report, pending }: { report: ProviderQuotaRepor
]
: []
))}
- {aggregation.currentAccount?.quota && (
+ {showsAggregate && aggregation.currentAccount?.quota && (
{t("pws.capacity.currentAccount")}
diff --git a/gui/src/components/provider-workspace/ProviderWorkspaceShell.tsx b/gui/src/components/provider-workspace/ProviderWorkspaceShell.tsx
index 583ad279a0..ecce71a6fc 100644
--- a/gui/src/components/provider-workspace/ProviderWorkspaceShell.tsx
+++ b/gui/src/components/provider-workspace/ProviderWorkspaceShell.tsx
@@ -53,6 +53,51 @@ const SORT_DEFS: { id: ProviderSortMode; labelKey: "pws.sort.az" | "pws.sort.za"
{ id: "accounts-first", labelKey: "pws.sort.accountsFirst" },
];
+const QUOTA_REPORT_MAX_AGE_MS = 30 * 60_000;
+
+function freshQuotaReport(value: unknown, now: number): ProviderQuotaReportView | null {
+ if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+ const row = value as Record;
+ if (typeof row.updatedAt !== "number" || !Number.isFinite(row.updatedAt)) return null;
+ if (now - row.updatedAt >= QUOTA_REPORT_MAX_AGE_MS) return null;
+ if (!("quota" in row)) return null;
+ if (row.label !== undefined && typeof row.label !== "string") return null;
+ if (row.source !== undefined && typeof row.source !== "string") return null;
+ return {
+ ...(typeof row.label === "string" ? { label: row.label } : {}),
+ ...(typeof row.source === "string" ? { source: row.source } : {}),
+ updatedAt: row.updatedAt,
+ quota: row.quota,
+ ...(row.aggregation !== undefined ? { aggregation: row.aggregation } : {}),
+ };
+}
+
+function freshQuotaReportRecord(value: unknown, now = Date.now()): Record | null {
+ if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+ const out: Record = {};
+ for (const [provider, raw] of Object.entries(value)) {
+ const report = freshQuotaReport(raw, now);
+ if (provider.trim() && report) out[provider] = report;
+ }
+ return out;
+}
+
+function readFreshQuotaReportCache(key: string): Record | null {
+ return freshQuotaReportRecord(readSessionListCache(key));
+}
+
+function freshQuotaReportsFromResponse(value: unknown, now = Date.now()): Record {
+ if (!Array.isArray(value)) return {};
+ const out: Record = {};
+ for (const raw of value) {
+ if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+ const provider = (raw as Record).provider;
+ const report = freshQuotaReport(raw, now);
+ if (typeof provider === "string" && provider.trim() && report) out[provider] = report;
+ }
+ return out;
+}
+
export default function ProviderWorkspaceShell({
providers,
apiBase,
@@ -119,10 +164,13 @@ export default function ProviderWorkspaceShell({
readSessionListCache<{ models: Record }>(usageCacheKey)?.models ?? {}
));
const [quotaReports, setQuotaReports] = useState>(() => (
- readSessionListCache>(quotasCacheKey) ?? {}
+ readFreshQuotaReportCache(quotasCacheKey) ?? {}
));
const [usageLoading, setUsageLoading] = useState(() => !readSessionListCache(usageCacheKey));
- const [quotasLoading, setQuotasLoading] = useState(() => !readSessionListCache(quotasCacheKey));
+ const [quotasLoading, setQuotasLoading] = useState(() => {
+ const cached = readFreshQuotaReportCache(quotasCacheKey);
+ return !cached || Object.keys(cached).length === 0;
+ });
const [modelsLoadEpoch, setModelsLoadEpoch] = useState(0);
const filterWrapRef = useRef(null);
@@ -213,7 +261,8 @@ export default function ProviderWorkspaceShell({
useEffect(() => {
let cancelled = false;
const timeout = window.setTimeout(() => {
- if (!readSessionListCache(quotasCacheKey)) setQuotasLoading(true);
+ const cached = readFreshQuotaReportCache(quotasCacheKey);
+ if (!cached || Object.keys(cached).length === 0) setQuotasLoading(true);
// A forced bump means a mutation just changed the answer, so the server's TTL has to
// be bypassed. The old derived-key effect always read the cached view, which is why a
// switch could leave the bars showing the previous account's quota.
@@ -221,24 +270,19 @@ export default function ProviderWorkspaceShell({
.then(r => readJsonIfOk<{ reports?: Array<{ provider: string; label?: string; source?: string; updatedAt?: number; quota?: unknown; aggregation?: unknown }> }>(r))
.then((data) => {
if (cancelled || !data) return;
- // Merge so a partial/failed probe cannot wipe a previously good provider row.
+ // A successful endpoint response is authoritative, including an empty report list.
+ const next = freshQuotaReportsFromResponse(data.reports);
+ setQuotaReports(next);
+ writeSessionListCache(quotasCacheKey, next);
+ })
+ .catch(() => {
+ // Keep last-good only inside the same server freshness bound.
setQuotaReports(prev => {
- const next = { ...prev };
- for (const report of data.reports ?? []) {
- if (!report?.provider) continue;
- next[report.provider] = {
- label: report.label,
- source: report.source,
- updatedAt: typeof report.updatedAt === "number" ? report.updatedAt : Date.now(),
- quota: report.quota,
- ...(report.aggregation !== undefined ? { aggregation: report.aggregation } : {}),
- };
- }
+ const next = freshQuotaReportRecord(prev) ?? {};
writeSessionListCache(quotasCacheKey, next);
return next;
});
})
- .catch(() => { /* keep last-good */ })
.finally(() => { if (!cancelled) setQuotasLoading(false); });
}, 0);
return () => {
diff --git a/gui/src/provider-workspace/report.ts b/gui/src/provider-workspace/report.ts
index b53b9d3bcc..9a8a3ec380 100644
--- a/gui/src/provider-workspace/report.ts
+++ b/gui/src/provider-workspace/report.ts
@@ -16,11 +16,14 @@ export interface ProviderQuotaReportView {
export interface CapacityWindowView {
usedPercent: number;
+ incomplete?: boolean;
+ excludedAccounts?: number;
nextRecoveryAt?: number;
nextRecoveryPercent?: number;
}
export interface ProviderCapacityAggregationView {
+ presentation: "aggregate" | "effective-account-fallback" | "coverage-only";
incomplete: boolean;
excludedAccounts: number;
unknownPlanAccounts: number;
@@ -80,6 +83,8 @@ function capacityWindow(value: unknown): CapacityWindowView | undefined {
if (usedPercent === undefined) return undefined;
return {
usedPercent,
+ ...(typeof row.incomplete === "boolean" ? { incomplete: row.incomplete } : {}),
+ ...(finite(row.excludedAccounts) !== undefined ? { excludedAccounts: row.excludedAccounts as number } : {}),
...(finite(row.nextRecoveryAt) !== undefined ? { nextRecoveryAt: row.nextRecoveryAt as number } : {}),
...(finite(row.nextRecoveryPercent) !== undefined ? { nextRecoveryPercent: row.nextRecoveryPercent as number } : {}),
};
@@ -105,13 +110,23 @@ export function capacityAggregationFromReport(report?: ProviderQuotaReportView):
return typeof custom.label === "string" && window ? [{ label: custom.label, ...window }] : [];
})
: [];
+ const fiveHour = capacityWindow(row.fiveHour);
+ const weekly = capacityWindow(row.weekly);
+ const monthly = capacityWindow(row.monthly);
+ const hasAggregateWindow = !!fiveHour || !!weekly || !!monthly || customWindows.length > 0;
+ const presentation = row.presentation === "aggregate"
+ || row.presentation === "effective-account-fallback"
+ || row.presentation === "coverage-only"
+ ? row.presentation
+ : hasAggregateWindow ? "aggregate" : "coverage-only";
return {
+ presentation,
incomplete: row.incomplete,
excludedAccounts,
unknownPlanAccounts,
- ...(capacityWindow(row.fiveHour) ? { fiveHour: capacityWindow(row.fiveHour) } : {}),
- ...(capacityWindow(row.weekly) ? { weekly: capacityWindow(row.weekly) } : {}),
- ...(capacityWindow(row.monthly) ? { monthly: capacityWindow(row.monthly) } : {}),
+ ...(fiveHour ? { fiveHour } : {}),
+ ...(weekly ? { weekly } : {}),
+ ...(monthly ? { monthly } : {}),
...(customWindows.length > 0 ? { customWindows } : {}),
...(currentRaw ? {
currentAccount: {
diff --git a/gui/src/styles/provider-overview-dashboard.css b/gui/src/styles/provider-overview-dashboard.css
index d09b8058fc..09f00fd1e2 100644
--- a/gui/src/styles/provider-overview-dashboard.css
+++ b/gui/src/styles/provider-overview-dashboard.css
@@ -211,14 +211,35 @@
.pws-capacity-recovery {
display: flex;
+ flex-wrap: wrap;
justify-content: space-between;
+ align-items: flex-start;
gap: 12px;
color: var(--fg-muted, #888);
}
+.pws-capacity-recovery span {
+ min-width: 0;
+ overflow-wrap: anywhere;
+}
+
.pws-capacity-recovery strong {
color: var(--text);
white-space: nowrap;
+ margin-left: auto;
+}
+
+@container (max-width: 520px) {
+ .pws-capacity-recovery {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr);
+ gap: 3px;
+ }
+
+ .pws-capacity-recovery strong {
+ margin-left: 0;
+ white-space: normal;
+ }
}
.pws-capacity-current {
diff --git a/gui/tests/provider-capacity-shell.test.tsx b/gui/tests/provider-capacity-shell.test.tsx
index 7039bc50dd..7712d73d57 100644
--- a/gui/tests/provider-capacity-shell.test.tsx
+++ b/gui/tests/provider-capacity-shell.test.tsx
@@ -4,6 +4,7 @@ import { act } from "react";
import type { Root } from "react-dom/client";
import ProviderWorkspaceShell from "../src/components/provider-workspace/ProviderWorkspaceShell";
import { LanguageProvider } from "../src/i18n/provider";
+import { readSessionListCache, writeSessionListCache } from "../src/session-list-cache";
const globals = ["document", "window", "navigator", "localStorage", "sessionStorage", "IS_REACT_ACT_ENVIRONMENT"] as const;
let previous: Record<(typeof globals)[number], unknown>;
@@ -11,6 +12,49 @@ let originalFetch: typeof globalThis.fetch;
let win: Window;
let host: HTMLElement;
let root: Root | null = null;
+let quotaPayload: unknown;
+let rejectQuotaFetch = false;
+
+const QUOTA_CACHE_KEY = "ocx.providers.quotas.v1:";
+const RECOVERY_AT = Date.UTC(2026, 7, 8, 4, 32);
+const providers = {
+ openai: { adapter: "openai-responses", authMode: "forward", baseUrl: "https://chatgpt.com/backend-api/codex" },
+} as never;
+
+function aggregatePayload() {
+ return {
+ reports: [{
+ provider: "openai",
+ label: "OpenAI (Codex login)",
+ source: "chatgpt:wham",
+ updatedAt: Date.now(),
+ quota: { weeklyPercent: 30.8, updatedAt: Date.now() },
+ aggregation: {
+ kind: "capacity-weighted-v1",
+ scope: "routable-known",
+ presentation: "aggregate",
+ includedAccounts: 2,
+ excludedAccounts: 1,
+ unknownPlanAccounts: 1,
+ missingQuotaAccounts: 0,
+ pausedAccounts: 0,
+ reauthAccounts: 0,
+ staleQuotaAccounts: 0,
+ incomplete: true,
+ weekly: {
+ usedPercent: 30.8,
+ includedAccounts: 2,
+ excludedAccounts: 1,
+ incomplete: true,
+ updatedAt: Date.now(),
+ nextRecoveryAt: RECOVERY_AT,
+ nextRecoveryPercent: 19.2,
+ },
+ currentAccount: { isMain: true, plan: "pro", quota: { weeklyPercent: 8, updatedAt: Date.now() } },
+ },
+ }],
+ };
+}
beforeEach(() => {
previous = Object.fromEntries(globals.map(key => [key, Reflect.get(globalThis, key)])) as typeof previous;
@@ -26,34 +70,14 @@ beforeEach(() => {
sessionStorage: { configurable: true, value: win.sessionStorage },
});
(globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
- const recoveryAt = Date.UTC(2026, 7, 8, 4, 32);
+ quotaPayload = aggregatePayload();
+ rejectQuotaFetch = false;
Object.defineProperty(globalThis, "fetch", {
configurable: true,
value: async (input: string) => {
const url = String(input);
- const body = url.includes("/api/provider-quotas") ? {
- reports: [{
- provider: "openai",
- label: "OpenAI (Codex login)",
- source: "chatgpt:wham",
- updatedAt: Date.now(),
- quota: { weeklyPercent: 30.8, updatedAt: Date.now() },
- aggregation: {
- kind: "capacity-weighted-v1",
- scope: "routable-known",
- includedAccounts: 2,
- excludedAccounts: 1,
- unknownPlanAccounts: 1,
- missingQuotaAccounts: 0,
- pausedAccounts: 0,
- reauthAccounts: 0,
- staleQuotaAccounts: 0,
- incomplete: true,
- weekly: { usedPercent: 30.8, includedAccounts: 2, updatedAt: Date.now(), nextRecoveryAt: recoveryAt, nextRecoveryPercent: 19.2 },
- currentAccount: { isMain: true, plan: "pro", quota: { weeklyPercent: 8, updatedAt: Date.now() } },
- },
- }],
- } : {};
+ if (url.includes("/api/provider-quotas") && rejectQuotaFetch) throw new Error("quota unavailable");
+ const body = url.includes("/api/provider-quotas") ? quotaPayload : {};
return { ok: true, status: 200, json: async () => body, text: async () => JSON.stringify(body) } as unknown as Response;
},
});
@@ -71,14 +95,14 @@ afterEach(async () => {
Object.defineProperty(globalThis, "fetch", { configurable: true, value: originalFetch });
});
-test("provider quota fetch preserves aggregate capacity through shell state and render", async () => {
+async function mountShell() {
const { createRoot } = await import("react-dom/client");
await act(async () => {
root = createRoot(host);
root.render(
{ await new Promise(resolve => setTimeout(resolve, 30)); });
+}
+
+test("provider quota fetch preserves aggregate capacity through shell state and render", async () => {
+ await mountShell();
const text = host.textContent ?? "";
expect(text).toContain("Configured-weight pool estimate");
@@ -101,3 +129,67 @@ test("provider quota fetch preserves aggregate capacity through shell state and
expect(text).toMatch(/Aug 8, 2026.*(4:32|1:32)/);
expect(text).not.toMatch(/configured units|weighted units|units remaining|projected/i);
});
+
+test("successful empty quota response removes cached providers and updates session cache", async () => {
+ const seeded = (aggregatePayload().reports[0]);
+ const { provider: _provider, ...cached } = seeded;
+ writeSessionListCache(QUOTA_CACHE_KEY, { openai: cached });
+ quotaPayload = { reports: [] };
+
+ await mountShell();
+
+ expect(host.textContent ?? "").not.toContain("Configured-weight pool estimate");
+ expect(readSessionListCache(QUOTA_CACHE_KEY)).toEqual({});
+});
+
+test("expired session quota is rejected and a failed fetch cannot keep it rendered", async () => {
+ const old = Date.now() - 31 * 60_000;
+ writeSessionListCache(QUOTA_CACHE_KEY, {
+ openai: {
+ label: "OpenAI (Codex login)",
+ source: "chatgpt:wham",
+ updatedAt: old,
+ quota: { weeklyPercent: 99, updatedAt: old },
+ aggregation: { ...aggregatePayload().reports[0].aggregation, presentation: "aggregate" },
+ },
+ });
+ rejectQuotaFetch = true;
+
+ await mountShell();
+
+ const text = host.textContent ?? "";
+ expect(text).not.toContain("Configured-weight pool estimate");
+ expect(text).not.toContain("99% used");
+ expect(readSessionListCache(QUOTA_CACHE_KEY)).toEqual({});
+});
+
+test("all-stale effective fallback renders one raw bar without aggregate labelling", async () => {
+ const old = Date.now() - 31 * 60_000;
+ quotaPayload = {
+ reports: [{
+ provider: "openai",
+ label: "OpenAI (Codex login)",
+ source: "chatgpt:wham",
+ updatedAt: Date.now(),
+ quota: { weeklyPercent: 80, updatedAt: old },
+ aggregation: {
+ kind: "capacity-weighted-v1",
+ scope: "routable-known",
+ presentation: "effective-account-fallback",
+ includedAccounts: 0,
+ excludedAccounts: 2,
+ unknownPlanAccounts: 0,
+ incomplete: true,
+ currentAccount: { isMain: true, plan: "pro", quota: { weeklyPercent: 80, updatedAt: old } },
+ },
+ }],
+ };
+
+ await mountShell();
+
+ const text = host.textContent ?? "";
+ expect(text).not.toContain("Configured-weight pool estimate");
+ expect(text).not.toContain("Current effective account");
+ expect(text.match(/80% used/g)?.length).toBe(1);
+ expect(text).toContain("Incomplete coverage: 2 account(s) excluded");
+});
diff --git a/gui/tests/provider-capacity.test.ts b/gui/tests/provider-capacity.test.ts
index 863bb5c2ad..23bfb11f0d 100644
--- a/gui/tests/provider-capacity.test.ts
+++ b/gui/tests/provider-capacity.test.ts
@@ -11,6 +11,7 @@ test("capacity metadata preserves estimate, raw current quota, recovery percent,
aggregation: {
kind: "capacity-weighted-v1",
scope: "routable-known",
+ presentation: "aggregate",
incomplete: true,
excludedAccounts: 2,
unknownPlanAccounts: 1,
@@ -26,6 +27,7 @@ test("capacity metadata preserves estimate, raw current quota, recovery percent,
},
});
expect(aggregation).toMatchObject({
+ presentation: "aggregate",
incomplete: true,
excludedAccounts: 2,
unknownPlanAccounts: 1,
@@ -35,6 +37,40 @@ test("capacity metadata preserves estimate, raw current quota, recovery percent,
expect(aggregation?.weekly).not.toHaveProperty("projectedUsedPercentAfterReset");
});
+test("fallback and coverage-only metadata never become aggregate presentation", () => {
+ const fallback = capacityAggregationFromReport({
+ quota: { weeklyPercent: 80, updatedAt: 123 },
+ aggregation: {
+ kind: "capacity-weighted-v1",
+ scope: "routable-known",
+ presentation: "effective-account-fallback",
+ incomplete: true,
+ excludedAccounts: 2,
+ unknownPlanAccounts: 0,
+ },
+ });
+ expect(fallback?.presentation).toBe("effective-account-fallback");
+ const legacyCoverage = capacityAggregationFromReport({
+ aggregation: {
+ kind: "capacity-weighted-v1",
+ scope: "routable-known",
+ incomplete: true,
+ excludedAccounts: 2,
+ unknownPlanAccounts: 1,
+ },
+ });
+ expect(legacyCoverage?.presentation).toBe("coverage-only");
+});
+
+test("capacity recovery layout wraps and stacks in narrow provider panes", async () => {
+ const css = await Bun.file(new URL("../src/styles/provider-overview-dashboard.css", import.meta.url)).text();
+ expect(css).toContain(".pws-capacity-recovery {");
+ expect(css).toContain("flex-wrap: wrap;");
+ expect(css).toContain("overflow-wrap: anywhere;");
+ expect(css).toContain("@container (max-width: 520px)");
+ expect(css.slice(css.indexOf("@container (max-width: 520px)"))).toContain("grid-template-columns: minmax(0, 1fr);");
+});
+
test("malformed or future aggregation contracts fail closed", () => {
expect(capacityAggregationFromReport({ aggregation: { kind: "capacity-weighted-v2" } })).toBeNull();
expect(capacityAggregationFromReport({ aggregation: { kind: "capacity-weighted-v1", scope: "routable-known" } })).toBeNull();
diff --git a/src/providers/codex-capacity.ts b/src/providers/codex-capacity.ts
index 4e413e11fa..698d82f732 100644
--- a/src/providers/codex-capacity.ts
+++ b/src/providers/codex-capacity.ts
@@ -31,6 +31,8 @@ export interface CodexCapacityAccount {
export interface CodexCapacityWindowAggregation {
usedPercent: number;
includedAccounts: number;
+ excludedAccounts: number;
+ incomplete: boolean;
/** Internal calculation evidence; stripped from the management API response. */
totalWeight?: number;
/** Internal calculation evidence; stripped from the management API response. */
@@ -53,6 +55,7 @@ export interface CodexCapacityAggregation {
reauthAccounts: number;
staleQuotaAccounts: number;
incomplete: boolean;
+ presentation?: "aggregate" | "effective-account-fallback" | "coverage-only";
fiveHour?: CodexCapacityWindowAggregation;
weekly?: CodexCapacityWindowAggregation;
monthly?: CodexCapacityWindowAggregation;
@@ -123,12 +126,14 @@ function addWindow(
windows.set(key, window);
}
-function finalizeWindow(window: MutableWindow): CodexCapacityWindowAggregation {
+function finalizeWindow(window: MutableWindow, totalAccounts: number): CodexCapacityWindowAggregation {
const nextRecoveryAt = [...window.recoveries.keys()].sort((a, b) => a - b)[0];
const recovered = nextRecoveryAt === undefined ? undefined : window.recoveries.get(nextRecoveryAt);
return {
usedPercent: window.consumedWeight / window.totalWeight * 100,
includedAccounts: window.includedAccounts,
+ excludedAccounts: totalAccounts - window.includedAccounts,
+ incomplete: window.includedAccounts < totalAccounts,
totalWeight: window.totalWeight,
consumedWeight: window.consumedWeight,
remainingWeight: window.totalWeight - window.consumedWeight,
@@ -153,6 +158,7 @@ export function aggregateCodexPoolCapacity(
} : undefined;
const windows = new Map();
const included = new Set();
+ const contributions = new Map>();
let unknownPlanAccounts = 0;
let missingQuotaAccounts = 0;
let pausedAccounts = 0;
@@ -181,25 +187,29 @@ export function aggregateCodexPoolCapacity(
if (account.paused || account.needsReauth || weight === undefined || !quota || !hasQuota || !quotaFresh) continue;
let contributed = false;
+ const contributionKeys = new Set();
for (const [key, rawPercent, rawReset] of standard) {
const percent = normalizedPercent(rawPercent);
if (percent === undefined) continue;
addWindow(windows, key, weight, percent, futureResetMs(rawReset, now), quota.updatedAt);
+ contributionKeys.add(key);
contributed = true;
}
for (const customWindow of custom) {
const percent = normalizedPercent(customWindow.percent);
if (percent === undefined) continue;
addWindow(windows, `custom:${customWindow.label}`, weight, percent, futureResetMs(customWindow.resetAt, now), quota.updatedAt);
+ contributionKeys.add(`custom:${customWindow.label}`);
contributed = true;
}
if (contributed) {
included.add(account);
+ contributions.set(account, contributionKeys);
}
}
if (windows.size === 0) {
- if (staleQuotaAccounts === 0) return { quota: null, aggregation: null, ...(currentAccount ? { currentAccount } : {}) };
+ if (accounts.length === 0) return { quota: null, aggregation: null, ...(currentAccount ? { currentAccount } : {}) };
const aggregation: CodexCapacityAggregation = {
kind: "capacity-weighted-v1",
scope: "routable-known",
@@ -215,11 +225,11 @@ export function aggregateCodexPoolCapacity(
};
return { quota: null, aggregation, ...(currentAccount ? { currentAccount } : {}) };
}
- const fiveHour = windows.get("fiveHour") ? finalizeWindow(windows.get("fiveHour")!) : undefined;
- const weekly = windows.get("weekly") ? finalizeWindow(windows.get("weekly")!) : undefined;
- const monthly = windows.get("monthly") ? finalizeWindow(windows.get("monthly")!) : undefined;
+ const fiveHour = windows.get("fiveHour") ? finalizeWindow(windows.get("fiveHour")!, accounts.length) : undefined;
+ const weekly = windows.get("weekly") ? finalizeWindow(windows.get("weekly")!, accounts.length) : undefined;
+ const monthly = windows.get("monthly") ? finalizeWindow(windows.get("monthly")!, accounts.length) : undefined;
const customWindows = [...windows.entries()].flatMap(([key, window]) => key.startsWith("custom:")
- ? [{ label: key.slice("custom:".length), ...finalizeWindow(window) }]
+ ? [{ label: key.slice("custom:".length), ...finalizeWindow(window, accounts.length) }]
: []);
const quota: CodexCapacityQuota = {
...(fiveHour ? { fiveHourPercent: fiveHour.usedPercent } : {}),
@@ -233,7 +243,11 @@ export function aggregateCodexPoolCapacity(
.flatMap(window => window ? [window.updatedAt] : []),
),
};
- const excludedAccounts = accounts.length - included.size;
+ const visibleWindowKeys = [...windows.keys()];
+ const excludedAccounts = accounts.filter(account => {
+ const keys = contributions.get(account);
+ return !keys || visibleWindowKeys.some(key => !keys.has(key));
+ }).length;
const aggregation: CodexCapacityAggregation = {
kind: "capacity-weighted-v1",
scope: "routable-known",
diff --git a/src/providers/quota.ts b/src/providers/quota.ts
index 3fd18a8f24..2bf1d1f5c4 100644
--- a/src/providers/quota.ts
+++ b/src/providers/quota.ts
@@ -132,9 +132,13 @@ function publicCapacityWindow(window: import("./codex-capacity").CodexCapacityWi
}
/** Management API metadata intentionally omits configured/weighted unit counts. */
-function publicCapacityAggregation(aggregation: CodexCapacityAggregation): CodexCapacityAggregation {
+function publicCapacityAggregation(
+ aggregation: CodexCapacityAggregation,
+ presentation: NonNullable,
+): CodexCapacityAggregation {
return {
...aggregation,
+ presentation,
...(aggregation.fiveHour ? { fiveHour: publicCapacityWindow(aggregation.fiveHour) } : {}),
...(aggregation.weekly ? { weekly: publicCapacityWindow(aggregation.weekly) } : {}),
...(aggregation.monthly ? { monthly: publicCapacityWindow(aggregation.monthly) } : {}),
@@ -233,17 +237,39 @@ async function fetchChatGptForwardQuota(
?? accounts[0];
const capacity = aggregateCodexPoolCapacity(capacityAccounts, Date.now());
if (capacity.aggregation && capacity.quota) {
- return report(provider, "chatgpt:wham", capacity.quota as ProviderQuota, publicCapacityAggregation(capacity.aggregation));
+ return report(
+ provider,
+ "chatgpt:wham",
+ capacity.quota as ProviderQuota,
+ publicCapacityAggregation(capacity.aggregation, "aggregate"),
+ );
}
const quota = active?.quota
? { ...active.quota, updatedAt: active.quota.updatedAt ?? Date.now() } as CodexCapacityQuota
: null;
- return quota ? report(
- provider,
- "chatgpt:wham",
- quota as ProviderQuota,
- capacity.aggregation ? publicCapacityAggregation(capacity.aggregation) : undefined,
- ) : null;
+ if (quota) {
+ const fallback = report(
+ provider,
+ "chatgpt:wham",
+ quota as ProviderQuota,
+ capacity.aggregation
+ ? publicCapacityAggregation(capacity.aggregation, "effective-account-fallback")
+ : undefined,
+ );
+ return fallback ? { ...fallback, updatedAt: Date.now() } : null;
+ }
+ if (capacity.aggregation) {
+ const updatedAt = Date.now();
+ return {
+ provider,
+ label: providerLabel(provider),
+ source: "chatgpt:wham",
+ quota: { updatedAt },
+ updatedAt,
+ aggregation: publicCapacityAggregation(capacity.aggregation, "coverage-only"),
+ };
+ }
+ return null;
}
function centsValue(value: unknown): number | undefined {
@@ -1045,10 +1071,12 @@ export async function fetchProviderQuotaReports(config: OcxConfig, forceRefresh
const response = { generatedAt: Date.now(), reports: [...byProvider.values()] };
// Commit only when this probe still holds authority (no clear/force superseded it).
if (epoch === invalidationEpoch) {
- const reports = response.reports.filter(item => mayCommitProviderQuotaKey(item.provider, writerGeneration));
const commitKeyCandidate = cacheKeyWithAggregationState(config);
const commitKey = typeof commitKeyCandidate === "string" ? commitKeyCandidate : await commitKeyCandidate;
- cache = { key: commitKey, ts: Date.now(), response: { ...response, reports } };
+ if (epoch === invalidationEpoch && commitKey === key) {
+ const reports = response.reports.filter(item => mayCommitProviderQuotaKey(item.provider, writerGeneration));
+ cache = { key, ts: Date.now(), response: { ...response, reports } };
+ }
}
return response;
})();
diff --git a/tests/provider-capacity.test.ts b/tests/provider-capacity.test.ts
index 4ae364d909..96384a2fc7 100644
--- a/tests/provider-capacity.test.ts
+++ b/tests/provider-capacity.test.ts
@@ -82,6 +82,9 @@ describe("configured-weight Codex pool capacity", () => {
], NOW);
expect(result.aggregation?.weekly?.totalWeight).toBe(21);
expect(result.aggregation?.monthly?.totalWeight).toBe(6);
+ expect(result.aggregation).toMatchObject({ incomplete: true, excludedAccounts: 2 });
+ expect(result.aggregation?.weekly).toMatchObject({ includedAccounts: 2, excludedAccounts: 1, incomplete: true });
+ expect(result.aggregation?.monthly).toMatchObject({ includedAccounts: 2, excludedAccounts: 1, incomplete: true });
expect(result.quota?.weeklyPercent).toBeCloseTo(23.8095238, 7);
expect(result.quota?.monthlyPercent).toBeCloseTo(51.6666667, 7);
});
@@ -95,7 +98,12 @@ describe("configured-weight Codex pool capacity", () => {
account("team", 70, { active: true, isMain: true }),
account("go", 80),
], NOW);
- expect(fallback.aggregation).toBeNull();
+ expect(fallback.aggregation).toMatchObject({
+ includedAccounts: 0,
+ excludedAccounts: 2,
+ unknownPlanAccounts: 2,
+ incomplete: true,
+ });
expect(fallback.currentAccount?.quota?.weeklyPercent).toBe(70);
});
@@ -137,4 +145,27 @@ describe("configured-weight Codex pool capacity", () => {
});
expect(result.aggregation?.weekly).toBeUndefined();
});
+
+ test("all exclusion reasons retain a coverage envelope without a quota window", () => {
+ const stale = account("pro", 90);
+ stale.quota = { ...stale.quota!, updatedAt: NOW - CODEX_CAPACITY_MAX_QUOTA_AGE_MS - 1 };
+ const result = aggregateCodexPoolCapacity([
+ account("team", 10, { active: true, isMain: true }),
+ account("plus", undefined),
+ account("prolite", 20, { paused: true }),
+ account("business", 30, { needsReauth: true }),
+ stale,
+ ], NOW);
+ expect(result.quota).toBeNull();
+ expect(result.aggregation).toMatchObject({
+ includedAccounts: 0,
+ excludedAccounts: 5,
+ unknownPlanAccounts: 1,
+ missingQuotaAccounts: 1,
+ pausedAccounts: 1,
+ reauthAccounts: 1,
+ staleQuotaAccounts: 1,
+ incomplete: true,
+ });
+ });
});
diff --git a/tests/provider-quota.test.ts b/tests/provider-quota.test.ts
index 38c6c3bc78..5fbe6bf323 100644
--- a/tests/provider-quota.test.ts
+++ b/tests/provider-quota.test.ts
@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
import { join } from "node:path";
import { clearAccountQuota, updateAccountQuota } from "../src/codex/quota";
import { clearAccountNeedsReauth, markAccountNeedsReauth } from "../src/codex/account-runtime-state";
+import { clearMainAccountInfoCache } from "../src/codex/auth-api";
import { clearCodexUpstreamHealth } from "../src/codex/routing";
import { saveCodexAccountCredential } from "../src/codex/account-store";
import { saveCredential } from "../src/oauth/store";
@@ -514,6 +515,26 @@ describe("fetchProviderQuotaReports", () => {
expect(JSON.stringify(openai?.aggregation)).not.toMatch(/(?:total|consumed|remaining)Weight|projectedUsedPercent/i);
});
+ test("all-excluded pool still returns a coverage-only OpenAI report", async () => {
+ rmSync(join(codexHome, "auth.json"), { force: true });
+ clearMainAccountInfoCache();
+ const config = testConfig();
+ config.providers = { openai: config.providers.openai };
+ config.codexAccounts = [{ id: "missing", email: "missing@example.test", plan: "plus", isMain: false }];
+
+ const result = await fetchProviderQuotaReports(config);
+ const openai = result.reports.find(row => row.provider === "openai");
+ expect(openai).toBeDefined();
+ expect(openai?.quota).toEqual({ updatedAt: openai?.updatedAt });
+ expect(openai?.aggregation).toMatchObject({
+ presentation: "coverage-only",
+ includedAccounts: 0,
+ excludedAccounts: 2,
+ reauthAccounts: 2,
+ incomplete: true,
+ });
+ });
+
test("ordinary fetch reflects pausing a non-active pool account", async () => {
saveCodexAccountCredential("added", {
accessToken: "added-access", refreshToken: "added-refresh",
@@ -859,6 +880,49 @@ describe("fetchProviderQuotaReports", () => {
expect(cached.reports[0]?.quota.monthlyPercent).toBe(90);
});
+ test("effective-account change during a pool probe cannot cache under the new signature", async () => {
+ saveCodexAccountCredential("added", {
+ accessToken: "added-access", refreshToken: "added-refresh",
+ expiresAt: Date.now() + 3600_000, chatgptAccountId: "added-chatgpt-id",
+ });
+ const config = testConfig();
+ config.providers = { openai: config.providers.openai };
+ config.codexAccounts = [{ id: "added", email: "a@example.test", plan: "prolite", isMain: false }];
+ const responseFor = (init?: RequestInit) => {
+ const added = (init?.headers as Record | undefined)?.["ChatGPT-Account-Id"] === "added-chatgpt-id";
+ return new Response(JSON.stringify({
+ plan_type: added ? "prolite" : "plus",
+ rate_limit: { secondary_window: { used_percent: added ? 77 : 11, reset_at: 1_999_000_000 } },
+ }), { status: 200, headers: { "content-type": "application/json" } });
+ };
+ globalThis.fetch = (async (_input: RequestInfo | URL, init?: RequestInit) => responseFor(init)) as typeof fetch;
+ await fetchProviderQuotaReports(config, true);
+ clearProviderQuotaCache();
+
+ let release!: () => void;
+ const gate = new Promise(resolve => { release = resolve; });
+ let startedResolve!: () => void;
+ const started = new Promise(resolve => { startedResolve = resolve; });
+ let startedProbe = false;
+ globalThis.fetch = (async (_input: RequestInfo | URL, init?: RequestInit) => {
+ if (!startedProbe) {
+ startedProbe = true;
+ startedResolve();
+ }
+ await gate;
+ return responseFor(init);
+ }) as typeof fetch;
+
+ const racing = fetchProviderQuotaReports(config, true);
+ await started;
+ config.activeCodexAccountId = "added";
+ release();
+ const racedResponse = await racing;
+ const next = await fetchProviderQuotaReports(config);
+ expect(next).not.toBe(racedResponse);
+ expect(next.reports[0]?.aggregation?.currentAccount).toMatchObject({ plan: "prolite", quota: { weeklyPercent: 77 } });
+ });
+
test("last-good rows survive a transient failure with original timestamps, are replaced by fresh rows, expire past the cap, and a disabled provider yields no rows", async () => {
await saveCredential("cursor", { access: "cursor-access-secret", refresh: "cursor-refresh-secret", expires: Date.now() + 3600_000 });
let mode: "ok" | "fail" = "ok";
From f428336a30276c89712f0131fbcbe57ad835c945 Mon Sep 17 00:00:00 2001
From: luvs01 <27862058+luvs01@users.noreply.github.com>
Date: Sun, 2 Aug 2026 17:18:22 +0900
Subject: [PATCH 05/10] fix(gui): surface partial and coverage-only capacity
Keep pool account counts partitioned while reporting partial limit-window coverage separately.
Render coverage-only reports in the Providers overview and expire stale effective-account fallbacks without restamping their quota data.
Refs #874
---
.../ProviderOverviewDashboard.tsx | 12 +++-
gui/src/i18n/de.ts | 1 +
gui/src/i18n/en.ts | 1 +
gui/src/i18n/ja.ts | 1 +
gui/src/i18n/ko.ts | 1 +
gui/src/i18n/ru.ts | 1 +
gui/src/i18n/zh.ts | 1 +
gui/src/provider-workspace/report.ts | 2 +
gui/tests/provider-capacity-shell.test.tsx | 63 +++++++++++++++++--
gui/tests/provider-capacity.test.ts | 2 +
src/providers/codex-capacity.ts | 10 ++-
src/providers/quota.ts | 14 ++++-
tests/provider-capacity.test.ts | 7 ++-
tests/provider-quota.test.ts | 44 +++++++++++++
14 files changed, 145 insertions(+), 15 deletions(-)
diff --git a/gui/src/components/provider-workspace/ProviderOverviewDashboard.tsx b/gui/src/components/provider-workspace/ProviderOverviewDashboard.tsx
index ce0f676db4..68c86d2223 100644
--- a/gui/src/components/provider-workspace/ProviderOverviewDashboard.tsx
+++ b/gui/src/components/provider-workspace/ProviderOverviewDashboard.tsx
@@ -69,8 +69,9 @@ export default function ProviderOverviewDashboard({
for (const item of allItems) {
const report = quotaReports[item.name];
const quota = report ? accountQuotaFromReport(report) : null;
- if (report && quota) {
- result.push({ item, report, urgency: maxQuotaUtilisation(quota) });
+ const aggregation = report ? capacityAggregationFromReport(report) : null;
+ if (report && (quota || aggregation?.presentation === "coverage-only")) {
+ result.push({ item, report, urgency: quota ? maxQuotaUtilisation(quota) : -1 });
}
}
return result.sort((a, b) => b.urgency - a.urgency || a.item.name.localeCompare(b.item.name));
@@ -276,7 +277,7 @@ function ProviderCapacityQuota({ report, pending }: { report: ProviderQuotaRepor
)}
- {aggregation.incomplete && (
+ {aggregation.incomplete && aggregation.excludedAccounts > 0 && (
{t("pws.capacity.incomplete", {
excluded: aggregation.excludedAccounts,
@@ -284,6 +285,11 @@ function ProviderCapacityQuota({ report, pending }: { report: ProviderQuotaRepor
})}
)}
+ {aggregation.partialWindowAccounts > 0 && (
+
+ {t("pws.capacity.partial", { count: aggregation.partialWindowAccounts })}
+
+ )}