UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

604 lines (572 loc) • 29.8 kB
import { parseCodexCredits, rememberCodexCredits } from "../credits"; import { fetchCodexUsage } from "../quota-query-backoff"; import type { CodexUsageOwner } from "../quota-query-backoff"; import { capturePoolQuotaWriter, getValidCodexToken, isCodexAccountGenerationLive, forceRefreshCodexPoolToken, markCodexAccountValidated, markCodexAccountValidationFailed, readCodexAccountRecord, isTerminalCodexPoolRefreshFailure, CodexCredentialGenerationConflictError, CodexCredentialRefreshLockTimeoutError, CodexCredentialRefreshBusyError, CodexCredentialRefreshStaleError, TokenRefreshError } from "../account-store"; import type { PoolQuotaWriter } from "../quota-types"; import { isValidWhamHistoryObservation, getAccountQuota, isCompleteCodexQuotaRecoverySnapshot, parseUsageQuota, setAccountQuotaFromParsed } from "../quota"; import type { StoredAccountQuota, WhamUsageResponse } from "../quota"; import type { ManualResetRefreshLineage } from "../routing"; import { clearAccountNeedsReauth, markAccountNeedsReauth } from "../account-runtime-state"; import { captureConfigGeneration } from "../../lib/state-store-sweeper"; import { codexWarmupFailureReason, warmCodexAccount } from "../warmup"; import { readBoundedResponseBody } from "../../lib/bounded-body"; import { ResourceAdmissionError } from "../../lib/admission"; import { WHAM_REQUEST_TIMEOUT_MS } from "../quota-recovery-timing"; import { claimQuotaRecovery, fencePropagatedQuotaRecovery, quotaRecoveryTerminalFor, releaseQuotaRecovery, settleQuotaRecovery, settleQuotaRecoveryTerminal } from "../quota-401-recovery"; import { seedLoginRowsForTests } from "./login-state"; import { nonEmptyPlan } from "./runtime-config"; export const POOL_CACHE_TTL = 5 * 60_000; export const POOL_QUOTA_REFRESH_CONCURRENCY = 4; export const MAIN_TERMINAL_AUTH_CODES = new Set([ "invalid_workspace_selected", "invalid_refresh_token", ]); export async function readMainAuthErrorCode(resp: Response): Promise<unknown> { try { const body = await readBoundedResponseBody(resp, { totalTimeoutMs: 1_000, inactivityTimeoutMs: 1_000 }); if (!body.displaySafe) return undefined; const parsed = JSON.parse(body.text) as { detail?: { code?: unknown } | string; error?: { code?: unknown } | string; code?: unknown; }; const code = typeof parsed.detail === "object" && parsed.detail !== null ? parsed.detail.code : typeof parsed.error === "object" && parsed.error !== null ? parsed.error.code : parsed.code; return code; } catch { return undefined; } } export interface PoolQuotaResult { /** Actual refresh result attached only to the successful usage replay. */ resetRefreshLineage?: ManualResetRefreshLineage; quota: StoredAccountQuota | null; needsReauth: boolean; /** Failure source observed while obtaining the quota, when reauthentication is required. */ reauthReason?: "refresh_failed" | "quota_unauthorized"; /** Credential generation whose cache or network result this DTO state belongs to. */ credentialGeneration?: number; /** Present only when this call freshly parsed a WHAM usage response. */ freshQuota?: Omit<StoredAccountQuota, "updatedAt">; /** Present only when this call's WHAM response included a non-empty `plan_type`. */ freshPlan?: string; /** Credential generation used by this fresh quota request. */ freshCredentialGeneration?: number; /** Present only when this call's WHAM response included `rate_limit_reset_credits.available_count`. */ freshResetCredits?: number; quotaProbeSkipped?: true; /** Positive evidence captured immediately before an upstream WHAM dispatch. */ quotaProbeAttempted?: { at: number; credentialGeneration: number; dispatchSequence: number }; } // Process-local ordering, never a timestamp or a serialized account identifier. let quotaDispatchSequence = 0; // Shared native-main ownership permits concurrent usage readers. Only a later // successfully published response advances this fence; failed reads do not win. let mainQuotaPublishedSequence = 0; export function nextQuotaDispatchSequence(): number { return ++quotaDispatchSequence; } export function currentQuotaDispatchSequence(): number { return quotaDispatchSequence; } export function isQuotaDispatchCurrent(sequence: number): boolean { return sequence >= mainQuotaPublishedSequence; } export function publishQuotaDispatch(sequence: number): void { mainQuotaPublishedSequence = sequence; } export interface PoolQuotaProbeEvidence { onDispatch?: (sequence: number) => void; mayPublish?: () => boolean; attempted?: NonNullable<PoolQuotaResult["quotaProbeAttempted"]>; } export function markQuotaProbeAttempted(evidence: PoolQuotaProbeEvidence, credentialGeneration: number): void { const dispatchSequence = nextQuotaDispatchSequence(); evidence.attempted = { at: Date.now(), credentialGeneration, dispatchSequence }; evidence.onDispatch?.(dispatchSequence); } export function withQuotaProbeEvidence( result: PoolQuotaResult, evidence: PoolQuotaProbeEvidence, ): PoolQuotaResult { return evidence.attempted && (result.quotaProbeAttempted?.dispatchSequence ?? 0) < evidence.attempted.dispatchSequence ? { ...result, quotaProbeAttempted: evidence.attempted } : result; } export interface PoolQuotaRefreshFlight { state: { dispatchSequence?: number; superseded?: boolean; startCredentialGeneration?: number; resolvedCredentialGeneration?: number; validatePending?: boolean; }; promise: Promise<PoolQuotaResult>; } export const poolQuotaRefreshInFlight = new Map<string, Set<PoolQuotaRefreshFlight>>(); export const MAX_POOL_QUOTA_FLIGHTS = 16; export class PoolQuotaProbeBusyError extends ResourceAdmissionError { constructor() { super("pool_quota_flights", MAX_POOL_QUOTA_FLIGHTS); this.name = "PoolQuotaProbeBusyError"; } } export function poolQuotaFlightCount(): number { let count = 0; for (const flights of poolQuotaRefreshInFlight.values()) count += flights.size; return count; } /** Focused admission tests only; returns cleanup for the synthetic owners it inserts. */ export function seedCodexAuthAdmissionForTests(options: { loginFlows?: number; quotaFlights?: number }): () => void { const prefix = `admission-test-${crypto.randomUUID()}`; const cleanupLoginRows = seedLoginRowsForTests(prefix, options.loginFlows ?? 0); for (let index = 0; index < (options.quotaFlights ?? 0); index++) { poolQuotaRefreshInFlight.set(`${prefix}-quota-${index}`, new Set([{ state: {}, promise: new Promise<PoolQuotaResult>(() => {}), }])); } return () => { cleanupLoginRows(); for (const key of [...poolQuotaRefreshInFlight.keys()]) if (key.startsWith(prefix)) poolQuotaRefreshInFlight.delete(key); }; } /** * One refresh-and-replay for a pool account whose WHAM request came back 401 (#3019). * * The account list used to convert any 401 straight into `needsReauth`, and a bare 401 is * exactly what a stale-but-refreshable bearer produces after a plan change — so a healthy * credential was thrown away and the operator was told to log in again. * * Bounded by the recovery store: one attempt per credential lineage. An unbounded retry * against an upstream 401 is a self-inflicted credential-stuffing loop, which is why the * claim is taken BEFORE the refresh and settled by the flight rather than by this caller. */ export async function recoverPoolQuotaFrom401(ctx: { accountId: string; existing: StoredAccountQuota | null; configuredPlan: string | undefined; rejectedAccessToken: string; rejectedGeneration: number; resp: Response; quotaProbeEvidence: PoolQuotaProbeEvidence; onCredentialGeneration?: (generation: number) => void; recoveryProbeNow?: number; }): Promise<PoolQuotaResult> { const { accountId, existing, configuredPlan, rejectedAccessToken, rejectedGeneration, resp } = ctx; // Structured terminal evidence short-circuits everything: the same allowlist and bounded // parser the main account uses, because it is the same endpoint answering. if (await isTerminalPoolAuthResponse(resp)) { // Durable, not just this response: the account list re-polls, and without a recorded // mark the next bare 401 finds nothing terminal and reports the account healthy. // // Scoped to the generation this evidence is ABOUT. An account-wide mark would outlive // the credential it condemned, so a late terminal response arriving after the operator // re-authenticated would quarantine the replacement. markAccountNeedsReauth(accountId, captureConfigGeneration(), rejectedGeneration); return { quota: existing ?? null, needsReauth: true, reauthReason: "quota_unauthorized", credentialGeneration: rejectedGeneration }; } const claim = claimQuotaRecovery(accountId, rejectedGeneration); if (!claim.granted) { // A lineage fenced by a TERMINAL refresh failure stays terminal. Without this, the // budget being used would make the next bare 401 report a dead credential as healthy. if (quotaRecoveryTerminalFor(accountId, rejectedGeneration)) { return { quota: existing ?? null, needsReauth: true, reauthReason: "refresh_failed", credentialGeneration: rejectedGeneration }; } // Otherwise: this lineage spent its attempt, another caller is mid-refresh, or a // transient failure is backing off. Report transient and let the next poll try — // quarantining here would undo the whole point of the budget. return { quota: existing ?? null, needsReauth: false, credentialGeneration: rejectedGeneration }; } let refreshed: Awaited<ReturnType<typeof forceRefreshCodexPoolToken>>; try { refreshed = await forceRefreshCodexPoolToken(accountId, { rejectedGeneration, rejectedAccessToken, // Settlement rides the flight, not this await: a cancelled caller would otherwise // leave the claim to expire while the shared refresh commits, and the already // refreshed lineage would get a second attempt. onSettled: outcome => { if (outcome.kind === "resolved") { settleQuotaRecovery(accountId, claim.claimId, outcome); // A propagated alias adopted the rotated grant without spending its own claim. Fence // each committed alias generation so a later 401 on it cannot claim a second refresh // of the same underlying grant. for (const alias of outcome.propagatedAliases ?? []) { fencePropagatedQuotaRecovery(alias.id, alias.generation); } } else if (outcome.error instanceof TokenRefreshError && isTerminalRefreshError(outcome.error)) { // A revoked or expired grant does not become valid on the next poll. Releasing it // into backoff would let the following bare 401 find a non-terminal record and // report a dead credential as healthy. settleQuotaRecoveryTerminal(accountId, claim.claimId); } else { releaseQuotaRecovery(accountId, claim.claimId, QUOTA_RECOVERY_BACKOFF_MS); } }, }); } catch (e) { // A refresh that failed terminally is the one case where the credential really is gone. // Everything else is unknown, and unknown is not proof. if (e instanceof TokenRefreshError && isTerminalRefreshError(e)) { // Persist the same verdict the token guardian writes: the in-memory mark dies with // this process, and only the stored terminal failure keeps a cached listing from // calling the dead grant healthy after a restart. markCodexAccountValidationFailed(accountId, `refresh_${e.reason}`, { expectedGeneration: rejectedGeneration, terminal: true, }); markAccountNeedsReauth(accountId, captureConfigGeneration(), rejectedGeneration); return { quota: existing ?? null, needsReauth: true, reauthReason: "refresh_failed", credentialGeneration: rejectedGeneration }; } return { quota: existing ?? null, needsReauth: false, credentialGeneration: rejectedGeneration }; } // A byte-identical access token means replaying earns the same 401. Report transient // rather than burning the replay; the fence already moved to the returned generation. if (!refreshed.rotated) { return { quota: existing ?? null, needsReauth: false, credentialGeneration: refreshed.generation }; } // The flight may have moved the generation while this request was in the air. Tell the // coalescing layer where the credential actually is, or a late caller joins on a stale // generation and opens a redundant flight. ctx.onCredentialGeneration?.(refreshed.generation); const writerGeneration = captureConfigGeneration(); const poolWriter = capturePoolQuotaWriter(accountId, refreshed); const replayRead = await fetchCodexUsage<PoolQuotaResult>(`pool:${accountId}:${writerGeneration}:${refreshed.generation}`, { headers: { Authorization: `Bearer ${refreshed.accessToken}`, "ChatGPT-Account-Id": refreshed.chatgptAccountId, }, signal: AbortSignal.timeout(WHAM_REQUEST_TIMEOUT_MS), }, () => markQuotaProbeAttempted(ctx.quotaProbeEvidence, refreshed.generation), ctx.recoveryProbeNow === undefined ? { poolAccountId: accountId } : { poolAccountId: accountId, recoveryProbe: true, now: () => ctx.recoveryProbeNow! }); if (!replayRead) return { quota: existing ?? null, needsReauth: false, credentialGeneration: refreshed.generation, quotaProbeSkipped: true }; if (replayRead.kind === "joined") { if (!isCodexAccountGenerationLive(accountId, refreshed.generation) || ctx.quotaProbeEvidence.mayPublish?.() === false) { return { quota: getAccountQuota(accountId), needsReauth: false, credentialGeneration: refreshed.generation }; } const joined = replayRead.result; return joined.freshCredentialGeneration === refreshed.generation ? { ...joined, resetRefreshLineage: { fromGeneration: rejectedGeneration, toGeneration: refreshed.generation, provenance: refreshed.provenance, }, } : joined; } let usableReplay = false; const finishReplay = async (): Promise<PoolQuotaResult> => { const replay = replayRead.response; if (!replay.ok) { if (replay.status === 401 && await isTerminalPoolAuthResponse(replay)) { // The refresh already settled this claim non-terminally, so the record alone would // let the next poll call a dead credential healthy. The evidence is about the // REFRESHED credential, which is what the replay used. markAccountNeedsReauth(accountId, writerGeneration, refreshed.generation); return { quota: existing ?? null, needsReauth: true, reauthReason: "quota_unauthorized", credentialGeneration: refreshed.generation }; } return { quota: existing ?? null, needsReauth: false, credentialGeneration: refreshed.generation }; } const result = await commitPoolQuotaResponse(replay, { accountId, existing, configuredPlan, generation: refreshed.generation, writerGeneration, poolWriter, mayPublish: ctx.quotaProbeEvidence.mayPublish, }); usableReplay = result.freshQuota !== undefined; return result.freshCredentialGeneration === refreshed.generation ? { ...result, resetRefreshLineage: { fromGeneration: rejectedGeneration, toGeneration: refreshed.generation, provenance: refreshed.provenance, }, } : result; }; let replayOutcome: PoolQuotaResult | undefined; try { replayOutcome = await finishReplay(); return replayOutcome; } finally { replayRead.settle(usableReplay, replayOutcome); } } /** Backoff after a refresh failure that proved nothing about the credential. */ export const QUOTA_RECOVERY_BACKOFF_MS = 60_000; /** Same allowlist and bounded parser as the main account: it is the same endpoint. */ export async function isTerminalPoolAuthResponse(resp: Response): Promise<boolean> { // Consume the original rather than a clone. `resp.clone()` tees the body, and the // bounded parser's timeout cancels only its own reader — the unread original branch // keeps buffering. Nothing needs this response afterwards, so there is nothing to tee. const code = await readMainAuthErrorCode(resp); return typeof code === "string" && MAIN_TERMINAL_AUTH_CODES.has(code); } /** A revoked or expired grant is terminal; an unknown or transport failure is not. */ export function isTerminalRefreshError(error: TokenRefreshError): boolean { // Read the discriminator, not the message. TokenRefreshError carries `reason`, and // matching on human text would let a durable quarantine decision change the next time // somebody rewords an error string. return error.reason === "revoked" || error.reason === "expired"; } /** Parse and store a successful WHAM response. Shared by the first attempt and the replay. */ export async function commitPoolQuotaResponse( resp: Response, ctx: { accountId: string; existing: StoredAccountQuota | null; configuredPlan: string | undefined; generation: number; writerGeneration: number; poolWriter?: PoolQuotaWriter; mayPublish?: () => boolean; }, ): Promise<PoolQuotaResult> { const { accountId, existing, configuredPlan, generation, writerGeneration } = ctx; const data = (await resp.json()) as WhamUsageResponse; const observedAt = Date.now(); if (ctx.mayPublish?.() === false) { return { quota: getAccountQuota(accountId), needsReauth: false, credentialGeneration: generation }; } if (ctx.poolWriter && isCodexAccountGenerationLive(accountId, generation)) { rememberCodexCredits(accountId, ctx.poolWriter.historyIdentity, parseCodexCredits(data.credits)); } const freshPlan = nonEmptyPlan(data.plan_type) ?? undefined; const quota = parseUsageQuota({ ...data, plan_type: freshPlan ?? configuredPlan }); const freshResetCredits = quota?.resetCredits; if (!quota) { return { quota: isCodexAccountGenerationLive(accountId, generation) ? existing ?? null : getAccountQuota(accountId), needsReauth: false, credentialGeneration: generation, ...(freshPlan !== undefined ? { freshPlan, freshCredentialGeneration: generation } : {}), }; } if (!isCodexAccountGenerationLive(accountId, generation)) { return { quota: null, needsReauth: false, credentialGeneration: generation }; } const validPolicyObservation = isValidWhamHistoryObservation(data); setAccountQuotaFromParsed(accountId, quota, writerGeneration, undefined, validPolicyObservation ? quota : null, ctx.poolWriter && validPolicyObservation ? { writer: ctx.poolWriter, observedAt, source: "wham", raw: quota } : undefined, true); return { quota: getAccountQuota(accountId), needsReauth: false, credentialGeneration: generation, freshQuota: quota, freshCredentialGeneration: generation, ...(freshPlan !== undefined ? { freshPlan } : {}), ...(freshResetCredits !== undefined ? { freshResetCredits } : {}), }; } export async function fetchFreshPoolAccountQuota( accountId: string, existing: StoredAccountQuota | null, configuredPlan?: string, onCredentialGeneration?: (generation: number) => void, getValidToken: typeof getValidCodexToken = getValidCodexToken, quotaProbeEvidence: PoolQuotaProbeEvidence = {}, afterDispatchSequence?: number, recoveryProbeNow?: number, ): Promise<PoolQuotaResult> { const writerGeneration = captureConfigGeneration(); let requestCredentialGeneration = readCodexAccountRecord(accountId)?.generation; const readState: { owner?: CodexUsageOwner<PoolQuotaResult>; usable: boolean } = { usable: false }; const read = async (): Promise<PoolQuotaResult> => { try { const { accessToken, chatgptAccountId, generation } = await getValidToken(accountId); const poolWriter = capturePoolQuotaWriter(accountId, { accessToken, chatgptAccountId, generation }); requestCredentialGeneration = generation; onCredentialGeneration?.(generation); const admission = await fetchCodexUsage<PoolQuotaResult>( `pool:${accountId}:${writerGeneration}:${generation}${afterDispatchSequence === undefined ? "" : `:post-reset:${afterDispatchSequence}`}`, { headers: { Authorization: `Bearer ${accessToken}`, "ChatGPT-Account-Id": chatgptAccountId }, signal: AbortSignal.timeout(8000), }, () => markQuotaProbeAttempted(quotaProbeEvidence, generation), recoveryProbeNow === undefined ? { poolAccountId: accountId } : { poolAccountId: accountId, recoveryProbe: true, now: () => recoveryProbeNow }); if (!admission) return { quota: existing ?? null, needsReauth: false, credentialGeneration: generation, quotaProbeSkipped: true }; if (admission.kind === "joined") return isCodexAccountGenerationLive(accountId, generation) && quotaProbeEvidence.mayPublish?.() !== false ? admission.result : { quota: getAccountQuota(accountId), needsReauth: false, credentialGeneration: generation }; readState.owner = admission; const resp = admission.response; if (!resp.ok) { if (resp.status !== 401) { return withQuotaProbeEvidence( { quota: existing ?? null, needsReauth: false, credentialGeneration: generation }, quotaProbeEvidence, ); } // A bare 401 is what a stale-but-refreshable bearer produces after a plan change, so // quarantining on it tells the operator to re-authenticate an account that was fine // (#3019). Refresh once, replay once, and only then decide. const recovered = await recoverPoolQuotaFrom401({ accountId, existing, configuredPlan, rejectedAccessToken: accessToken, rejectedGeneration: generation, resp, quotaProbeEvidence, onCredentialGeneration, recoveryProbeNow, }); return withQuotaProbeEvidence(recovered, quotaProbeEvidence); } const committed = await commitPoolQuotaResponse(resp, { accountId, existing, configuredPlan, generation, writerGeneration, poolWriter, mayPublish: quotaProbeEvidence.mayPublish, }); readState.usable = committed.freshQuota !== undefined; return withQuotaProbeEvidence(committed, quotaProbeEvidence); } catch (e) { if (e instanceof CodexCredentialGenerationConflictError || e instanceof CodexCredentialRefreshLockTimeoutError || e instanceof CodexCredentialRefreshBusyError || e instanceof CodexCredentialRefreshStaleError) { return withQuotaProbeEvidence({ quota: existing ?? null, needsReauth: false, credentialGeneration: requestCredentialGeneration, quotaProbeSkipped: true, }, quotaProbeEvidence); } // Terminal means the grant itself is dead or missing; an `unknown` refresh failure (a // token-endpoint 5xx, a transport blip) may clear, so it reports transient like the // 401-recovery path instead of quarantining a healthy account (#2887). A revoked or // expired grant is also written to the record as a terminal validation failure, the same // verdict the token guardian persists: the in-memory mark dies with this process, and // the stored verdict is what keeps a cached listing from calling the dead grant healthy // after a restart. if (isTerminalCodexPoolRefreshFailure(e)) { if (e instanceof TokenRefreshError && isTerminalRefreshError(e)) { markCodexAccountValidationFailed(accountId, `refresh_${e.reason}`, { expectedGeneration: requestCredentialGeneration, terminal: true, }); } markAccountNeedsReauth(accountId, captureConfigGeneration(), requestCredentialGeneration); return withQuotaProbeEvidence( { quota: existing ?? null, needsReauth: true, reauthReason: "refresh_failed", credentialGeneration: requestCredentialGeneration }, quotaProbeEvidence, ); } return withQuotaProbeEvidence( { quota: existing ?? null, needsReauth: false, credentialGeneration: requestCredentialGeneration }, quotaProbeEvidence, ); } }; let outcome: PoolQuotaResult | undefined; try { outcome = await read(); return outcome; } finally { readState.owner?.settle(readState.usable, outcome); } } export async function fetchPoolAccountQuota( accountId: string, forceRefresh = false, configuredPlan?: string, getValidToken: typeof getValidCodexToken = getValidCodexToken, validatePending = false, afterDispatchSequence?: number, recoveryProbeNow?: number, ): Promise<PoolQuotaResult> { const existing = getAccountQuota(accountId); if (afterDispatchSequence === undefined && !forceRefresh && existing && Date.now() - existing.updatedAt < POOL_CACHE_TTL) { return { quota: existing, needsReauth: false, credentialGeneration: readCodexAccountRecord(accountId)?.generation, }; } // A token refresh may increment the generation (and rotate the refresh token) before WHAM // completes. Join a flight whose starting or resolved generation is still current, but let a // replacement credential with the same pool id start its own request. const record = readCodexAccountRecord(accountId); const flights = poolQuotaRefreshInFlight.get(accountId); const current = flights && [...flights].find(flight => { const generation = flight.state.resolvedCredentialGeneration ?? flight.state.startCredentialGeneration; return !flight.state.superseded && (afterDispatchSequence === undefined || (flight.state.dispatchSequence ?? 0) > afterDispatchSequence) && generation !== undefined && isCodexAccountGenerationLive(accountId, generation); }); if (current) { // A manual refresh joining a passive read must not lose its validation intent. current.state.validatePending ||= validatePending; return current.promise; } if (poolQuotaFlightCount() >= MAX_POOL_QUOTA_FLIGHTS) throw new PoolQuotaProbeBusyError(); // A post-reset request must not let an older same-account response overwrite its evidence. // Flags live only as long as the bounded flights; no retained per-account sequence map. if (afterDispatchSequence !== undefined) { for (const flight of flights ?? []) flight.state.superseded = true; } const state: PoolQuotaRefreshFlight["state"] = { startCredentialGeneration: record?.generation, validatePending, }; const refresh = fetchFreshPoolAccountQuota( accountId, existing, configuredPlan, generation => { state.resolvedCredentialGeneration = generation; }, getValidToken, { onDispatch: sequence => { state.dispatchSequence = sequence; }, mayPublish: () => state.superseded !== true, }, afterDispatchSequence, recoveryProbeNow, ).then(async result => { // A passive flight has consumed its validation decision. Remove it before // promise settlement queues other continuations, so a late explicit caller // starts fresh work instead of setting an intent nobody will read again. if (!state.validatePending) { releaseFlight(); return result; } // Only an explicit account-list refresh finishes deferred registration. Passive quota // polls and startup priming remain read-only with respect to inference spending. const generation = result.freshCredentialGeneration; const record = state.validatePending ? readCodexAccountRecord(accountId) : null; if (record?.codexValidationPending && record.credential && record.deletedAt == null && generation !== undefined && record.generation === generation && isCompleteCodexQuotaRecoverySnapshot(result.freshQuota ?? null, result.freshPlan ?? configuredPlan)) { try { // Quota I/O may outlive the source capture. Never validate a rotated or revoked link // using an older generation's observation. Explicit validation consent still applies. const sourceToken = record.credential.sourceAuthPath ? await getValidToken(accountId) : null; if (sourceToken && (sourceToken.generation !== generation || !isCodexAccountGenerationLive(accountId, generation))) return result; await warmCodexAccount({ accessToken: sourceToken?.accessToken ?? record.credential.accessToken, chatgptAccountId: sourceToken?.chatgptAccountId ?? record.credential.chatgptAccountId, }); markCodexAccountValidated(accountId, Date.now(), generation); clearAccountNeedsReauth(accountId, generation); } catch (error) { // Keep the durable restriction on any failed/partial inference response, even // when WHAM just reported headroom. No raw upstream text enters diagnostics. const reason = codexWarmupFailureReason(error); if (reason === "http_status:401" || reason === "http_status:403") { markCodexAccountValidationFailed(accountId, reason, { expectedGeneration: generation }); markAccountNeedsReauth(accountId, captureConfigGeneration(), generation); } } } return result; }); const flight: PoolQuotaRefreshFlight = { state, promise: refresh }; const activeFlights = flights ?? new Set<PoolQuotaRefreshFlight>(); activeFlights.add(flight); if (!flights) poolQuotaRefreshInFlight.set(accountId, activeFlights); const releaseFlight = () => { activeFlights.delete(flight); if (activeFlights.size === 0 && poolQuotaRefreshInFlight.get(accountId) === activeFlights) { poolQuotaRefreshInFlight.delete(accountId); } }; try { return await refresh; } finally { releaseFlight(); } }