@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
539 lines (519 loc) • 26.8 kB
text/typescript
import { codexCreditsDtoField, hasCodexCreditsObservation, pruneCodexCredits } from "../credits";
import type { CodexCredits } from "../credits";
import { getMainChatgptAccountId } from "../auth-collision";
import { codexAccountLogLabel } from "../account-label";
import { poolQuotaHistoryIdentity, getCodexAccountCredential, getValidCodexToken, isCodexAccountGenerationLive, readCodexAccountRecord } from "../account-store";
import { getAccountQuota, isCodexQuotaExhausted, setAccountQuotaFromParsed, withoutRetiredCodexQuota } from "../quota";
import type { StoredAccountQuota } from "../quota";
import { ConfigMutationLockError, mutatePersistedConfig } from "../../config";
import { reconcileMainCodexAccountRuntimeState } from "../account-lifecycle";
import { isCodexAccountPaused, setCodexAccountPaused } from "../account-pause";
import { getCodexAccountPriority } from "../account-priority";
import { getCodexAccountAutoSwitchThresholdOverride } from "../account-auto-switch";
import { clearThreadAccountMapForAccount, isCodexAccountPlanExcluded, reconcileCodexActiveAfterExclusion } from "../routing";
import { codexPlanValue, isThirtyDayOnlyCodexPlan } from "../plan";
import { isAccountNeedsReauth, markAccountNeedsReauth } from "../account-runtime-state";
import { getValidMainAccountToken, MainAccountTokenRefreshError, MAIN_CODEX_ACCOUNT_ID } from "../main-account";
import { captureConfigGeneration } from "../../lib/state-store-sweeper";
import { captureMainAccountIdentityGeneration, getMainAccountCredentialPresence, getMainAccountInfoCache, isMainAccountIdentityGenerationLive } from "../main-account-cache";
import type { CodexQuotaRefreshOutcome } from "../quota-refresh-outcome";
import { getMainAccountHardLockStatus } from "../main-account-hard-lock";
import type { MainAccountHardLockStatus } from "../main-account-hard-lock";
import { emailMaskingEnabled, projectEmail } from "../../lib/privacy";
import type { CodexAccount, OcxConfig } from "../../types";
import { oauthAccountHealthFields, projectCodexAccountHealth } from "../../oauth/health";
import type { OAuthAccountHealth, OAuthHealthLabel } from "../../oauth/health";
import { isSelectableCodexPoolAccount } from "../account-id";
import type { AdmissionLease } from "../../lib/admission";
import { tryAcquireNativeMainProfileClaim } from "../native-main-admission";
import { withNativeMainCredentialClaim, isNativeMainClaimUnavailable } from "./http";
import { fetchMainAccountInfoAttempt, EMPTY_MAIN_ACCOUNT_INFO, mainResetCreditsForCurrentIdentity } from "./main-account-probe";
import { fetchPoolAccountQuota, PoolQuotaProbeBusyError, POOL_QUOTA_REFRESH_CONCURRENCY } from "./pool-quota-probe";
import type { PoolQuotaResult } from "./pool-quota-probe";
import { getRuntimeConfig, configuredPoolAccount, mapWithConcurrency } from "./runtime-config";
export function quotaForPlan<T extends Omit<StoredAccountQuota, "updatedAt"> | StoredAccountQuota | null>(
quota: T,
plan: unknown,
): T | null {
const visible = withoutRetiredCodexQuota(quota);
if (!visible || !isThirtyDayOnlyCodexPlan(plan)) return visible;
const quotaWindows = visible;
return {
...(quotaWindows.monthlyPercent !== undefined ? { monthlyPercent: quotaWindows.monthlyPercent } : {}),
...(quotaWindows.monthlyResetAt !== undefined ? { monthlyResetAt: quotaWindows.monthlyResetAt } : {}),
// A 30-day plan can still carry a burst window, and it blocks the account on its own.
// Dropping it here would show a healthy card for an account upstream is refusing (#1791).
...(quotaWindows.shortPercent !== undefined ? { shortPercent: quotaWindows.shortPercent } : {}),
...(quotaWindows.shortResetAt !== undefined ? { shortResetAt: quotaWindows.shortResetAt } : {}),
...(quotaWindows.shortWindowSeconds !== undefined ? { shortWindowSeconds: quotaWindows.shortWindowSeconds } : {}),
...(quotaWindows.customWindows !== undefined ? { customWindows: quotaWindows.customWindows } : {}),
...(quotaWindows.resetCredits !== undefined ? { resetCredits: quotaWindows.resetCredits } : {}),
...("updatedAt" in quotaWindows ? { updatedAt: quotaWindows.updatedAt } : {}),
} as T;
}
/**
* The main account is the only account whose DTO quota comes from the raw WHAM parse
* result instead of the merged store: `poolAccountDto` serializes what
* `commitPoolQuotaResponse` read back out of `getAccountQuota()`, while the main DTO
* spreads `mainInfo.quota` directly. `/wham/usage` carries `rate_limit_reset_credits`
* only intermittently, and the store exists to bridge that gap
* (`setAccountQuotaFromParsed` carries an existing `resetCredits` forward when the new
* snapshot omits it), so the main card lost its ticket badge on every response that
* happened to omit the summary while pool cards kept theirs.
*
* Only `resetCredits` is carried, deliberately, and only from an identity-tagged
* in-process observation rather than the alias-keyed store. The window fields have
* *clearing* semantics — a monthly-only snapshot must drop a stale weekly value (#382) —
* so reinstating the whole stored object would resurrect a window the parse meant to
* clear whenever the store write was refused by generation gating. A freshly parsed value
* always wins, including `0`: zero is defined, so it never takes the fill branch.
*/
export function mainQuotaWithCarriedResetCredits(
parsed: Omit<StoredAccountQuota, "updatedAt">,
): StoredAccountQuota {
const carried = parsed.resetCredits === undefined
? mainResetCreditsForCurrentIdentity()
: undefined;
return {
...parsed,
...(carried !== undefined ? { resetCredits: carried } : {}),
updatedAt: getAccountQuota(MAIN_CODEX_ACCOUNT_ID)?.updatedAt ?? Date.now(),
};
}
/**
* Why an account needs the operator. `missing_credential`, `refresh_failed`, and
* `quota_unauthorized` are the three causes this surface tells apart on its own. `unauthorized`
* and `forbidden` come from the shared health projection: `projectCodexAccountHealth` maps a
* stored verification failure's `http_status:401`/`http_status:403` to them, so the union has
* to accept every reason the projection can emit rather than silently dropping one.
*/
export type CodexAccountReauthReason =
| "missing_credential"
| "refresh_failed"
| "quota_unauthorized"
| "unauthorized"
| "forbidden";
export function poolAccountDto(
config: OcxConfig,
account: CodexAccount,
quotaResult: PoolQuotaResult,
hasCredential: boolean,
paused: boolean,
priority: number,
maskEmails: boolean,
): CodexAuthAccountDto {
const plan = codexPlanValue(account.plan);
const quota = quotaForPlan(quotaResult.quota, plan);
const runtimeReauth = isAccountNeedsReauth(account.id);
const rawReauthReason: CodexAccountReauthReason | undefined = !hasCredential
? "missing_credential"
: quotaResult.reauthReason;
const needsReauth = !hasCredential || quotaResult.needsReauth || runtimeReauth;
// An in-memory reauth mark carries no cause of its own, so it must not name one: passing
// a caller reason here would outrank the stored verdict's http_status inside the
// projection and hide unauthorized/forbidden until the mark is gone. With no caller
// reason the projection falls back to the persisted cause, then to refresh_failed.
const healthReason = rawReauthReason === "quota_unauthorized" || rawReauthReason === "missing_credential"
? "unauthorized"
: rawReauthReason;
const health = projectCodexAccountHealth({
accountId: account.id,
needsReauth,
reauthReason: needsReauth ? healthReason : undefined,
});
// `needsReauth` is an OR of three independent causes plus a persisted verdict resolved inside the
// health projection. Emitting only the boolean is what left #4212's reporter guessing which
// account took their model away and why, so name the cause they actually have to act on.
const reauthReason: CodexAccountReauthReason | undefined = rawReauthReason ?? (health.status === "reauth_required" ? health.reason : undefined);
return {
id: account.id,
email: projectEmail(account.email, maskEmails) ?? account.email,
...(account.alias !== undefined ? { alias: account.alias } : {}),
...(plan !== undefined ? { plan } : {}),
logLabel: codexAccountLogLabel(account),
isMain: false,
paused,
priority,
autoSwitchThresholdOverride: getCodexAccountAutoSwitchThresholdOverride(config, account.id),
quota: quota ? { ...quota } : null,
...codexCreditsDtoField(config, account.id, poolQuotaHistoryIdentity(account.id) ?? null),
needsReauth: needsReauth || health.status === "reauth_required",
...(reauthReason !== undefined ? { reauthReason } : {}),
...(isCodexAccountPlanExcluded(config, account.id) ? {
selectionExcludedReason: "plan_excluded" as const,
selectionExcludedPlan: codexPlanValue(config.codexAccounts?.find(row => row.id === account.id)?.plan),
} : {}),
hasCredential,
...(quotaResult.quotaProbeSkipped ? { quotaProbeSkipped: true as const } : {}),
...oauthAccountHealthFields("codex", account.id, health),
};
}
export interface CodexAuthAccountDto {
id: string;
alias?: string;
email: string;
plan?: string | null;
logLabel?: string;
isMain: boolean;
paused: boolean;
/** Selection order; higher is used earlier. Always present, 0 when unset. */
priority: number;
/** Null inherits the global usage-switch threshold; 0 disables it for this account. */
autoSwitchThresholdOverride: number | null;
quota: (StoredAccountQuota | (Omit<StoredAccountQuota, "updatedAt"> & { updatedAt: number })) | null;
credits?: CodexCredits;
needsReauth?: boolean;
/**
* Which of the independent causes behind `needsReauth` fired. Present only when the account
* needs the operator; `/api/oauth/accounts` already carries the same field name.
*/
reauthReason?: CodexAccountReauthReason;
/** Automatic selection policy only; explicit routes retain their usual auth checks. */
selectionExcludedReason?: "plan_excluded";
selectionExcludedPlan?: string;
hasCredential: boolean;
health: OAuthAccountHealth;
healthLabel: OAuthHealthLabel;
healthSummary: string;
healthAction?: string;
quotaProbeSkipped?: true;
quotaRefresh?: CodexQuotaRefreshOutcome;
mainAccountHardLock?: MainAccountHardLockStatus;
}
export interface FreshPoolPlanUpdate {
accountId: string;
plan: string;
credentialGeneration: number;
}
/**
* Persist only validated plan leaves against the latest disk snapshot. A quota GET must not save
* the long-lived runtime object wholesale: unrelated manual/provider writes may have landed while
* WHAM requests were in flight. Missing or malformed files fail closed: a read path must not
* recreate a deleted config from the server's older in-memory snapshot.
*/
export function reconcileFreshPoolAccountPlans(runtimeConfig: OcxConfig, updates: FreshPoolPlanUpdate[]): void {
if (updates.length === 0) return;
let outcome: ReturnType<typeof mutatePersistedConfig<FreshPoolPlanUpdate[]>>;
try {
outcome = mutatePersistedConfig(persistedConfig => {
const accepted: FreshPoolPlanUpdate[] = [];
let changed = false;
for (const update of updates) {
if (!isCodexAccountGenerationLive(update.accountId, update.credentialGeneration)) continue;
const liveAccount = configuredPoolAccount(runtimeConfig, update.accountId);
const persistedAccount = configuredPoolAccount(persistedConfig, update.accountId);
if (!liveAccount || !persistedAccount) continue;
accepted.push(update);
if (persistedAccount.plan !== update.plan) {
persistedAccount.plan = update.plan;
// WHAM is the authoritative plan source: stamp provenance so a later JWT
// reconcile cannot overwrite this observation within the same credential
// generation (src/codex/plan-from-token.ts jwtMayWritePlan). Stamped only
// alongside a real plan change: a steady-state refresh whose plan is
// unchanged must stay write-free (no-config-write contract), and an
// unchanged value needs no fence — a JWT rewrite to the same text is a
// no-op under the caller's own equality check.
persistedAccount.planSource = "wham";
persistedAccount.planCredentialGeneration = update.credentialGeneration;
changed = true;
}
}
return { changed, value: accepted };
});
} catch (error) {
// Plan persistence is derived metadata on a read route. Contention must fail closed without
// turning account listing into a 500; a later refresh can retry against the latest files.
if (error instanceof ConfigMutationLockError) return;
throw error;
}
if (outcome.status === "unavailable") return;
for (const update of outcome.value) {
// A replacement immediately after the durable commit is allowed to supersede the result, but
// the long-lived object must never be updated from that stale generation.
if (!isCodexAccountGenerationLive(update.accountId, update.credentialGeneration)) continue;
const liveAccount = configuredPoolAccount(runtimeConfig, update.accountId);
if (liveAccount) {
liveAccount.plan = update.plan;
liveAccount.planSource = "wham";
liveAccount.planCredentialGeneration = update.credentialGeneration;
}
}
}
export interface CodexAuthAccountsSnapshot {
accounts: CodexAuthAccountDto[];
mainIdentityGeneration: number;
}
export async function listCodexAuthAccountsSnapshot(
config: OcxConfig,
forceRefresh = false,
options: { validatePending?: boolean } = {},
): Promise<CodexAuthAccountsSnapshot> {
const runtimeConfig = getRuntimeConfig(config);
const poolAccounts = (runtimeConfig.codexAccounts ?? []).filter(isSelectableCodexPoolAccount);
pruneCodexCredits([MAIN_CODEX_ACCOUNT_ID, ...poolAccounts.map(account => account.id)]);
// One redaction decision for the whole snapshot, read once from the operator's config (#3859).
const maskEmails = emailMaskingEnabled(runtimeConfig);
const mainResult = await fetchMainAccountInfoAttempt(forceRefresh, 1, undefined, false,
forceRefresh, false, runtimeConfig);
const refreshedPool = await mapWithConcurrency(poolAccounts, POOL_QUOTA_REFRESH_CONCURRENCY, async account => {
const cred = getCodexAccountCredential(account.id);
let quotaResult: PoolQuotaResult;
if (!cred) {
quotaResult = { quota: null, needsReauth: true };
} else {
try {
// Credits are process-local while pool quota is hydrated from disk, so right after a
// restart the cache would hide credits for up to POOL_CACHE_TTL. Bypass it once per
// identity when the switch is on and nothing has been observed yet.
const creditsIdentity = runtimeConfig.showCodexCredits === true ? poolQuotaHistoryIdentity(account.id) ?? null : null;
const creditsUnobserved = creditsIdentity !== null && !hasCodexCreditsObservation(account.id, creditsIdentity);
quotaResult = await fetchPoolAccountQuota(account.id, forceRefresh || creditsUnobserved, account.plan, getValidCodexToken, options.validatePending === true);
} catch (error) {
if (!(error instanceof PoolQuotaProbeBusyError)) throw error;
quotaResult = {
quota: getAccountQuota(account.id),
needsReauth: false,
credentialGeneration: readCodexAccountRecord(account.id)?.generation,
quotaProbeSkipped: true,
};
}
}
return { accountId: account.id, quotaResult };
});
// WHAM plan_type is authoritative only for the credential generation that fetched it. Collect
// changes after every parallel read settles, then apply one narrow disk patch for the batch.
const planUpdates = refreshedPool.flatMap(({ accountId, quotaResult }): FreshPoolPlanUpdate[] => {
const plan = quotaResult.freshPlan;
const credentialGeneration = quotaResult.freshCredentialGeneration;
return plan && credentialGeneration !== undefined
? [{ accountId, plan, credentialGeneration }]
: [];
});
reconcileFreshPoolAccountPlans(runtimeConfig, planUpdates);
const withQuota = refreshedPool.flatMap(({ accountId, quotaResult }) => {
const currentAccount = configuredPoolAccount(runtimeConfig, accountId);
if (!currentAccount) return [];
const currentCredential = getCodexAccountCredential(accountId);
if (!currentCredential) {
return [poolAccountDto(
runtimeConfig,
currentAccount,
{ quota: null, needsReauth: true },
false,
isCodexAccountPaused(runtimeConfig, accountId),
getCodexAccountPriority(runtimeConfig, accountId),
maskEmails,
)];
}
const resultGeneration = quotaResult.credentialGeneration ?? quotaResult.freshCredentialGeneration;
const generationLive = resultGeneration === undefined
|| isCodexAccountGenerationLive(accountId, resultGeneration);
const effectiveQuotaResult = !generationLive
? { quota: null, needsReauth: false }
: quotaResult;
// Response DTO can show the WHAM plan even when disk persistence fails closed (lock busy /
// missing config). Persistence still remains generation-gated via reconcileFreshPoolAccountPlans.
const dtoAccount = generationLive && quotaResult.freshPlan
? { ...currentAccount, plan: quotaResult.freshPlan }
: currentAccount;
return [poolAccountDto(
runtimeConfig,
dtoAccount,
effectiveQuotaResult,
true,
isCodexAccountPaused(runtimeConfig, accountId),
getCodexAccountPriority(runtimeConfig, accountId),
maskEmails,
)];
});
const fetchedMainGeneration = mainResult.identityGeneration ?? captureMainAccountIdentityGeneration();
const mainSnapshotLive = isMainAccountIdentityGenerationLive(fetchedMainGeneration);
// An ordinary same-account return can be parsed after its credential was replaced.
// The card and hard-lock status must describe the same published quota snapshot.
const mainInfo = mainSnapshotLive
? mainResult.infoUnpublished ? getMainAccountInfoCache() ?? EMPTY_MAIN_ACCOUNT_INFO : mainResult.info
: EMPTY_MAIN_ACCOUNT_INFO;
const hasMainCredential = mainSnapshotLive && mainResult.credentialChecked
? mainResult.hasCredential
: getMainAccountCredentialPresence() ?? false;
const mainMissingCredential = mainSnapshotLive && mainResult.credentialChecked && !hasMainCredential;
const mainNeedsReauth = mainMissingCredential || isAccountNeedsReauth(MAIN_CODEX_ACCOUNT_ID);
const mainHealth = projectCodexAccountHealth({
accountId: MAIN_CODEX_ACCOUNT_ID,
needsReauth: mainNeedsReauth,
});
// The main row carries the same attribution as a pool row. Reaching this point without
// `mainMissingCredential` means the runtime reauth flag is what set `mainNeedsReauth`, so the
// cause is a refresh that did not complete.
const mainReauthReason: CodexAccountReauthReason | undefined = mainMissingCredential
? "missing_credential"
: mainNeedsReauth
? "refresh_failed"
: mainHealth.status === "reauth_required" ? mainHealth.reason : undefined;
const main: CodexAuthAccountDto = {
id: MAIN_CODEX_ACCOUNT_ID,
email: projectEmail(mainInfo.email, maskEmails) ?? "Codex App login",
plan: mainInfo.plan,
...(mainSnapshotLive && mainResult.quotaRefresh && mainResult.quotaRefreshGeneration !== undefined
&& isMainAccountIdentityGenerationLive(mainResult.quotaRefreshGeneration)
? { quotaRefresh: mainResult.quotaRefresh } : {}),
logLabel: "main",
isMain: true,
paused: isCodexAccountPaused(runtimeConfig, MAIN_CODEX_ACCOUNT_ID),
mainAccountHardLock: getMainAccountHardLockStatus(runtimeConfig),
priority: getCodexAccountPriority(runtimeConfig, MAIN_CODEX_ACCOUNT_ID),
autoSwitchThresholdOverride: getCodexAccountAutoSwitchThresholdOverride(runtimeConfig, MAIN_CODEX_ACCOUNT_ID),
hasCredential: hasMainCredential,
needsReauth: mainNeedsReauth,
...(mainReauthReason !== undefined ? { reauthReason: mainReauthReason } : {}),
quota: mainInfo.quota
? quotaForPlan(mainQuotaWithCarriedResetCredits(mainInfo.quota), mainInfo.plan)
: null,
...codexCreditsDtoField(runtimeConfig, MAIN_CODEX_ACCOUNT_ID, getMainChatgptAccountId()),
...oauthAccountHealthFields("codex", MAIN_CODEX_ACCOUNT_ID, mainHealth),
};
return {
accounts: [main, ...withQuota],
mainIdentityGeneration: mainSnapshotLive
? fetchedMainGeneration
: captureMainAccountIdentityGeneration(),
};
}
/** One opted-in account's metadata; reuse the bounded WHAM 401 recovery and generation fence. */
export async function refreshCodexQuotaForActivation(config: OcxConfig, accountId: string): Promise<void> {
if (accountId === MAIN_CODEX_ACCOUNT_ID) {
const lease = tryAcquireNativeMainProfileClaim();
if (!lease) return;
try {
reconcileMainCodexAccountRuntimeState();
if (isAccountNeedsReauth(accountId)) return;
const identityGeneration = captureMainAccountIdentityGeneration();
const writerGeneration = captureConfigGeneration();
try {
// Refresh may need an exclusive claim; prepare before WHAM takes its shared claim.
if (!await getValidMainAccountToken({ preserveReauth: true })) return;
} catch (error) {
if (error instanceof MainAccountTokenRefreshError && error.reason === "reauth"
&& isMainAccountIdentityGenerationLive(identityGeneration)) {
markAccountNeedsReauth(accountId, writerGeneration);
}
return;
}
if (isAccountNeedsReauth(accountId)) return;
await fetchMainAccountInfoAttempt(true, 1, lease, false, false, false, config);
} finally {
lease.release();
}
return;
}
const account = configuredPoolAccount(config, accountId);
if (!account) return;
const writerGeneration = captureConfigGeneration();
const result = await fetchPoolAccountQuota(accountId, true, account.plan);
if (result.needsReauth && result.credentialGeneration !== undefined) {
markAccountNeedsReauth(accountId, writerGeneration, result.credentialGeneration);
}
}
export async function listCodexAuthAccounts(
config: OcxConfig,
forceRefresh = false,
options: { validatePending?: boolean } = {},
): Promise<CodexAuthAccountDto[]> {
return (await listCodexAuthAccountsSnapshot(config, forceRefresh, options)).accounts;
}
export interface PauseExhaustedResult {
pausedAccountIds: string[];
checkedAccountCount: number;
failedAccountCount: number;
}
export function selectFallbackAfterPause(config: OcxConfig, pausedActiveId: string): void {
reconcileCodexActiveAfterExclusion(config, pausedActiveId);
}
export async function pauseExhaustedCodexAccounts(
config: OcxConfig,
persistPausedAccounts: () => void,
): Promise<PauseExhaustedResult> {
const poolAccounts = (config.codexAccounts ?? []).filter(account => !account.isMain);
const nativeMainLease = tryAcquireNativeMainProfileClaim();
try {
const performPause = async (mainLease?: AdmissionLease): Promise<PauseExhaustedResult> => {
const mainWork = async (): Promise<{
shouldPause: boolean;
checkedAccountCount: number;
failedAccountCount: number;
}> => {
if (!mainLease) return { shouldPause: false, checkedAccountCount: 0, failedAccountCount: 1 };
const mainResult = await fetchMainAccountInfoAttempt(true, 1, mainLease, true,
true, false, config);
if (!mainResult.credentialChecked || !mainResult.hasCredential) {
return { shouldPause: false, checkedAccountCount: 0, failedAccountCount: 0 };
}
if (!mainResult.freshQuota || !mainResult.info.plan) {
return { shouldPause: false, checkedAccountCount: 0, failedAccountCount: 1 };
}
return {
shouldPause: !isCodexAccountPaused(config, MAIN_CODEX_ACCOUNT_ID)
&& isCodexQuotaExhausted(mainResult.freshQuota, mainResult.info.plan),
checkedAccountCount: 1,
failedAccountCount: 0,
};
};
const [mainResult, poolResults] = await Promise.all([
mainWork(),
mapWithConcurrency(poolAccounts, POOL_QUOTA_REFRESH_CONCURRENCY, async account => {
if (!getCodexAccountCredential(account.id)) return { account, quotaResult: null };
try {
return {
account,
quotaResult: await fetchPoolAccountQuota(account.id, true, account.plan),
};
} catch {
// Settle each pool probe independently so a busy/failing account cannot
// abandon an already-confirmed main decision before atomic publication.
return { account, quotaResult: null };
}
}),
]);
let checkedAccountCount = mainResult.checkedAccountCount;
let failedAccountCount = mainResult.failedAccountCount;
const exhaustedIds: string[] = mainResult.shouldPause ? [MAIN_CODEX_ACCOUNT_ID] : [];
for (const { account, quotaResult } of poolResults) {
const currentAccount = (config.codexAccounts ?? []).find(candidate => candidate.id === account.id && !candidate.isMain);
if (!currentAccount) continue;
const generation = quotaResult?.freshCredentialGeneration;
const plan = quotaResult?.freshPlan ?? currentAccount.plan;
if (!quotaResult?.freshQuota || generation === undefined || !isCodexAccountGenerationLive(account.id, generation) || !plan) {
failedAccountCount += 1;
continue;
}
checkedAccountCount += 1;
if (!isCodexAccountPaused(config, account.id) && isCodexQuotaExhausted(quotaResult.freshQuota, plan)) {
exhaustedIds.push(account.id);
}
}
for (const id of exhaustedIds) {
setCodexAccountPaused(config, id, true);
clearThreadAccountMapForAccount(id);
}
for (const id of exhaustedIds) selectFallbackAfterPause(config, id);
const result = {
pausedAccountIds: exhaustedIds,
checkedAccountCount,
failedAccountCount,
};
// Persist while both the in-process admission and cross-process shared
// claim still own the physical-main identity used for the decision.
if (result.pausedAccountIds.length > 0) persistPausedAccounts();
return result;
};
if (!nativeMainLease) return await performPause();
try {
return await withNativeMainCredentialClaim(() => performPause(nativeMainLease));
} catch (error) {
if (isNativeMainClaimUnavailable(error)) return await performPause();
throw error;
}
} finally {
nativeMainLease?.release();
}
}