@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
482 lines (463 loc) • 27.5 kB
text/typescript
import { existsSync } from "node:fs";
import { join } from "node:path";
import { rememberCodexCredits } from "../credits";
import { fetchCodexUsage } from "../quota-query-backoff";
import type { CodexUsageOwner } from "../quota-query-backoff";
import { loadConfig } from "../../config";
import { isCanonicalOpenAiForwardProvider, OPENAI_CODEX_PROVIDER_ID } from "../../providers/openai-tiers";
import { providerCodexAccountMode } from "../../providers/registry";
import { isSelectableCodexPoolAccount } from "../account-id";
import type { OcxConfig } from "../../types";
import { isValidWhamHistoryObservation, parseMainPolicyUsageQuota, parseUsageQuota, parseWhamCredits, setAccountQuotaFromParsed } from "../quota";
import type { StoredAccountQuota, WhamUsageResponse } from "../quota";
import { reconcileMainCodexAccountRuntimeState } from "../account-lifecycle";
import { getMainChatgptAccountId, readCodexTokensResult } from "../auth-collision";
import { clearAccountNeedsReauth, markAccountNeedsReauth } from "../account-runtime-state";
import { decodeJwtPayload, extractAccountId } from "../../oauth/chatgpt";
import { getMainAccountPlan, getValidMainAccountToken, isMainAccountTokenVerifiablyLive, mainAccountTokenIsCurrent, mainAccountTokenQuotaWriter, MainAccountTokenRefreshError, MAIN_CODEX_ACCOUNT_ID, setMainAccountPlan, type MainAccountToken } from "../main-account";
import { resolveCodexHomeDir } from "../home";
import { captureConfigGeneration } from "../../lib/state-store-sweeper";
import { captureMainAccountIdentityGeneration, clearMainAccountInfoCache, getMainAccountInfoCache, getMainQuotaCredentialGeneration, isMainAccountIdentityGenerationLive, isMainQuotaWriterLive, matchesMainQuotaCredential, observeMainQuotaCredential, setMainAccountCredentialPresence, setMainAccountInfoCache } from "../main-account-cache";
import type { MainQuotaWriter, MainAccountInfo } from "../main-account-cache";
import { isCodexTerminalAuthCode } from "../quota-refresh-outcome";
import type { CodexQuotaRefreshOutcome, CodexTerminalAuthCode } from "../quota-refresh-outcome";
import { observeMainReserveRevocation } from "../reserve-availability";
import type { AdmissionLease } from "../../lib/admission";
import { nonEmptyPlan } from "./runtime-config";
import { tryAcquireNativeMainProfileClaim } from "../native-main-admission";
import { WHAM_REQUEST_TIMEOUT_MS } from "../quota-recovery-timing";
import { withNativeMainCredentialClaim, isNativeMainObservationUnavailable } from "./http";
import { readMainAuthErrorCode, currentQuotaDispatchSequence, nextQuotaDispatchSequence, isQuotaDispatchCurrent, publishQuotaDispatch } from "./pool-quota-probe";
/**
* Last reset-credit count this process parsed for the main account, tagged with the
* physical ChatGPT account it was read from.
*
* It is deliberately memory-only. The quota store is keyed by the stable `__main__`
* ALIAS, and `~/.codex/auth.json` can be swapped for another account while the proxy is
* not running — `reconcileMainCodexAccountRuntimeState` only purges alias-keyed state
* when it observes the id CHANGE, and its first observation after a restart has nothing
* to compare against. A disk-hydrated `__main__` entry can therefore belong to the
* previous login, so filling the DTO from it would show one account's tickets on
* another's card. Pool accounts have no such hole because their store key IS the account
* id. Binding the value to `requestAccountId` keeps the fill honest: after a restart the
* badge simply waits for the first usage response that carries the summary.
*/
let mainResetCreditsProvenance: { accountId: string; credits: number } | null = null;
export function rememberMainResetCredits(accountId: string | null, credits: number | undefined): void {
if (accountId === null || credits === undefined) return;
mainResetCreditsProvenance = { accountId, credits };
}
/** Forget the remembered count when the physical main identity is no longer the same. */
export function mainResetCreditsForCurrentIdentity(): number | undefined {
if (!mainResetCreditsProvenance) return undefined;
const currentAccountId = getMainChatgptAccountId();
if (currentAccountId === null) return undefined;
if (currentAccountId !== mainResetCreditsProvenance.accountId) {
mainResetCreditsProvenance = null;
return undefined;
}
return mainResetCreditsProvenance.credits;
}
export const MAIN_CACHE_TTL = 5 * 60_000;
function sharedMainQuotaPacingEnabled(config: OcxConfig): boolean {
const openai = config.providers[OPENAI_CODEX_PROVIDER_ID];
if (openai?.disabled === true || openai?.codexAccountMode === "direct") return false;
return (openai !== undefined && isCanonicalOpenAiForwardProvider(openai)
&& providerCodexAccountMode(OPENAI_CODEX_PROVIDER_ID, openai) === "pool")
|| (config.codexAccounts ?? []).some(isSelectableCodexPoolAccount);
}
/**
* A WHAM 401 is not itself proof the local credential died. Upstream edges can
* transiently reject a still-valid access token (region/anti-abuse/rotation
* races), and fail-closing on every bare 401 makes a healthy main account flip
* needs-reauth on the next GUI quota poll. Only treat the response as terminal
* when the body carries a known terminal code or the local access token is not
* verifiably live (`accessTokenLive`). Liveness must be strict: a JWT whose
* `exp` cannot be decoded is NOT live — an undecodable token that vouched for
* itself would make a real 401 permanently transient.
*/
export async function isTerminalMainAuthResponse(resp: Response, accessTokenLive: boolean): Promise<boolean> {
return (await classifyMainAuthResponse(resp, accessTokenLive)).terminal;
}
/** As `isTerminalMainAuthResponse`, also naming the provider code that made it terminal. */
async function classifyMainAuthResponse(
resp: Response,
accessTokenLive: boolean,
): Promise<{ terminal: boolean; code?: CodexTerminalAuthCode }> {
if (resp.status !== 401 && resp.status !== 403) return { terminal: false };
const code = await readMainAuthErrorCode(resp);
if (isCodexTerminalAuthCode(code)) return { terminal: true, code };
return { terminal: resp.status === 401 && !accessTokenLive };
}
export interface MainResetQuotaProof {
writer: MainQuotaWriter;
credentialGeneration: number;
}
export interface MainAccountInfoFetchResult {
info: MainAccountInfo;
/** Parsed ordinary info from a stale credential; callers must not display it as shared state. */
infoUnpublished?: true;
resetRecoveryProof?: MainResetQuotaProof & { dispatchSequence: number };
/** Ephemeral result of this attempt, omitted when no WHAM request was made. */
quotaRefresh?: CodexQuotaRefreshOutcome;
/** Internal dispatch fence for diagnostics only; never copied into a public DTO or cache. */
quotaRefreshGeneration?: number;
/** This current-credential usage response supplied terminal auth evidence; never public. */
terminalAuthFailure?: true;
/** Whether this attempt safely inspected the physical native-main credential. */
credentialChecked: boolean;
/** Meaningful only when credentialChecked is true. */
hasCredential: boolean;
/** Main identity generation captured while the native-main claim was held. */
identityGeneration?: number;
/** Freshly parsed usage from the current credential; stale ordinary return values are excluded. */
freshQuota?: Omit<StoredAccountQuota, "updatedAt">;
/** Current-credential response's `rate_limit_reset_credits.available_count`, when present. */
freshResetCredits?: number;
}
export interface MainAccountInfoSnapshot {
info: MainAccountInfo;
/** Ordinary info that was never published and must not become provider quota. */
infoUnpublished?: true;
mainIdentityGeneration: number;
quotaRefresh?: CodexQuotaRefreshOutcome;
}
export async function fetchMainAccountInfoSnapshot(forceRefresh = false, config?: OcxConfig): Promise<MainAccountInfoSnapshot> {
const result = await fetchMainAccountInfoAttempt(forceRefresh, 1, undefined, false, forceRefresh, false, config);
return {
info: result.info,
...(result.infoUnpublished ? { infoUnpublished: true as const } : {}),
...(result.quotaRefresh && result.quotaRefreshGeneration !== undefined
&& isMainAccountIdentityGenerationLive(result.quotaRefreshGeneration)
? { quotaRefresh: result.quotaRefresh } : {}),
mainIdentityGeneration: result.identityGeneration ?? captureMainAccountIdentityGeneration(),
};
}
export async function fetchMainAccountInfo(forceRefresh = false, config?: OcxConfig): Promise<MainAccountInfo> {
return (await fetchMainAccountInfoSnapshot(forceRefresh, config)).info;
}
export interface MainAccountInfoProbeOptions {
/** Metadata-only renewal never sets or clears the traffic reauth quarantine. */
passive?: boolean;
/** Exact owned result obtained before entering WHAM's shared credential claim. Never serialized. */
preparedToken?: MainAccountToken | null;
/** Always use paced usage scheduling, so failure backoff and Retry-After are recorded in every mode. */
paced?: boolean;
}
export const EMPTY_MAIN_ACCOUNT_INFO: MainAccountInfo = { email: null, plan: null, quota: null };
/** Caller holds the runtime lease, but no shared credential claim: Codex may need an exclusive claim. */
export async function prepareMainAccountInfoToken(): Promise<MainAccountToken | null | undefined> {
const home = resolveCodexHomeDir();
if (!existsSync(home) || existsSync(join(home, "auth.json"))) return undefined;
return getValidMainAccountToken({ preserveReauth: true });
}
export async function retryMainAccountInfoIfIdentityChanged(
requestAccountId: string | null,
retriesRemaining: number,
nativeMainLease: AdmissionLease,
explicitRefresh: boolean,
paced: boolean,
options: MainAccountInfoProbeOptions = {},
): Promise<MainAccountInfoFetchResult | null> {
const currentAccountId = getMainChatgptAccountId();
if (currentAccountId === null || currentAccountId === requestAccountId) return null;
reconcileMainCodexAccountRuntimeState();
return retriesRemaining > 0
? fetchMainAccountInfoWhileOwned(true, retriesRemaining - 1, nativeMainLease, explicitRefresh, false, paced, options)
: { info: EMPTY_MAIN_ACCOUNT_INFO, credentialChecked: true, hasCredential: true };
}
export async function fetchMainAccountInfoAttempt(
forceRefresh: boolean,
retriesRemaining: number,
existingNativeMainLease?: AdmissionLease,
nativeMainSharedClaimHeld = false,
explicitRefresh: boolean = forceRefresh,
postReset = false,
config?: OcxConfig,
options: MainAccountInfoProbeOptions = {},
): Promise<MainAccountInfoFetchResult> {
const nativeMainLease = existingNativeMainLease ?? tryAcquireNativeMainProfileClaim();
if (!nativeMainLease) {
return {
info: EMPTY_MAIN_ACCOUNT_INFO,
credentialChecked: false,
hasCredential: false,
identityGeneration: captureMainAccountIdentityGeneration(),
};
}
try {
let preparedToken = options.preparedToken;
if (!nativeMainSharedClaimHeld && preparedToken === undefined) {
const home = resolveCodexHomeDir();
const generation = captureMainAccountIdentityGeneration();
try { preparedToken = await prepareMainAccountInfoToken(); }
catch (error) {
const absent = error instanceof MainAccountTokenRefreshError && (error.reason === "reauth" || error.credentialObservedAbsent)
&& home === resolveCodexHomeDir() && isMainAccountIdentityGenerationLive(generation);
if (absent) setMainAccountCredentialPresence(false);
return { info: getMainAccountInfoCache() ?? EMPTY_MAIN_ACCOUNT_INFO,
credentialChecked: absent, hasCredential: false, identityGeneration: captureMainAccountIdentityGeneration() };
}
}
const probeOptions = preparedToken === undefined ? options : { ...options, preparedToken };
const paced = options.paced === true || sharedMainQuotaPacingEnabled(config ?? loadConfig());
const operation = async () => ({
...await fetchMainAccountInfoWhileOwned(forceRefresh, retriesRemaining, nativeMainLease, explicitRefresh, postReset, paced, probeOptions),
identityGeneration: captureMainAccountIdentityGeneration(),
});
if (nativeMainSharedClaimHeld) return await operation();
try {
return await withNativeMainCredentialClaim(operation);
} catch (error) {
if (isNativeMainObservationUnavailable(error)) {
return {
info: EMPTY_MAIN_ACCOUNT_INFO,
credentialChecked: false,
hasCredential: false,
identityGeneration: captureMainAccountIdentityGeneration(),
};
}
throw error;
}
} finally {
if (!existingNativeMainLease) nativeMainLease.release();
}
}
/**
* Read native-main usage while ownership is held, publishing only current credential evidence.
* A replaced same-account bearer may return its parsed ordinary info without mutating shared
* state or supplying recovery proof. Conflicting identities and stale errors return cached info.
*/
export async function fetchMainAccountInfoWhileOwned(
forceRefresh: boolean,
retriesRemaining: number,
nativeMainLease: AdmissionLease,
/**
* Whether the *caller* asked for this refresh. `forceRefresh` also means "bypass the
* cache", and `retryMainAccountInfoIfIdentityChanged` re-enters with it set purely to
* re-read after the identity changed. Keeping the two apart stops that retry from
* promoting a background poll into operator intent below.
*/
explicitRefresh: boolean = forceRefresh,
/** Reset-credit consume needs a fresh post-spend observation, not an earlier read. */
postReset = false,
paced = true,
options: MainAccountInfoProbeOptions = {},
): Promise<MainAccountInfoFetchResult> {
const writerGeneration = captureConfigGeneration();
const tokenRead = readCodexTokensResult();
if (tokenRead.status === "missing" && options.preparedToken && !mainAccountTokenIsCurrent(options.preparedToken)) {
// A stale/copy handoff proves nothing about the current login, including its presence.
return { info: getMainAccountInfoCache() ?? EMPTY_MAIN_ACCOUNT_INFO, credentialChecked: false, hasCredential: false };
}
const owned = tokenRead.status === "missing" && options.preparedToken
&& mainAccountTokenIsCurrent(options.preparedToken) ? options.preparedToken : undefined;
// The owned RPC already reconciled identity; a missing file must not erase that observation.
if (!owned) reconcileMainCodexAccountRuntimeState();
const tokens = tokenRead.status === "ok" ? tokenRead.tokens : owned
? { access_token: owned.accessToken, account_id: owned.chatgptAccountId, id_token: undefined } : null;
setMainAccountCredentialPresence(tokens !== null);
if (!tokens) {
// A local read failure is NOT proof of sign-out: a missing file can be a non-atomic rewrite
// gap, and malformed JSON can be a half-written file. Clearing the cache and marking the
// account for reauth here destroyed healthy email/plan/quota state and pinned a working
// account as unusable. Preserve what we already know and let the caller retry; request
// routing stays fail-closed through its owned credential resolver, and the account DTO
// reports hasCredential=false without either a readable file or a verified keyring handoff.
const preserved = getMainAccountInfoCache();
return { info: preserved ?? EMPTY_MAIN_ACCOUNT_INFO, credentialChecked: true, hasCredential: false };
}
const requestAccountId = extractAccountId(tokens.id_token, tokens.access_token) ?? (tokens.account_id || null);
const cached = getMainAccountInfoCache();
if (!forceRefresh && cached && Date.now() - cached.ts < MAIN_CACHE_TTL) {
return { info: cached, credentialChecked: true, hasCredential: true };
}
// Bind quota to the owned credential and the account actually selected by WHAM's header.
// A conflicting legacy token/account tuple is not evidence for the new policy.
const mainQuotaWriter = owned ? mainAccountTokenQuotaWriter(owned) : requestAccountId === tokens.account_id
? observeMainQuotaCredential(tokens.access_token, tokens.account_id)
: undefined;
const mainQuotaCredentialGeneration = getMainQuotaCredentialGeneration();
/** A disk replacement may have no second probe to advance the credential generation. */
const credentialIsCurrent = (): boolean => {
const current = readCodexTokensResult(undefined, { bounded: true });
if (owned) return current.status === "missing" && mainAccountTokenIsCurrent(owned)
&& mainQuotaCredentialGeneration === getMainQuotaCredentialGeneration();
if (current.status !== "ok") return false;
const effectiveAccountId = extractAccountId(current.tokens.id_token, current.tokens.access_token)
?? (current.tokens.account_id || null);
if (effectiveAccountId !== current.tokens.account_id || effectiveAccountId !== requestAccountId) return false;
observeMainQuotaCredential(current.tokens.access_token, current.tokens.account_id);
return mainQuotaWriter !== undefined
&& isMainQuotaWriterLive(mainQuotaWriter)
&& mainQuotaCredentialGeneration === getMainQuotaCredentialGeneration()
&& matchesMainQuotaCredential(tokens.access_token, tokens.account_id);
};
// Keep diagnostics separate from authentication and freshness policy. Never serialize errors.
const quotaSignal = AbortSignal.timeout(WHAM_REQUEST_TIMEOUT_MS);
let quotaPhase: "request" | "body" | "decode" | "publish" = "request";
let quotaRefreshGeneration = captureMainAccountIdentityGeneration();
const readState: { owner?: CodexUsageOwner<MainAccountInfoFetchResult>; usable: boolean } = { usable: false };
/** Perform one single-flight main-account usage read: classify auth failures and publish parsed quota and decision evidence only while the dispatch and credential are still current. */
const read = async (): Promise<MainAccountInfoFetchResult> => {
try {
let dispatchSequence = 0;
const baseKey = `main:${writerGeneration}:${mainQuotaCredentialGeneration}`;
const resetEpoch = postReset ? `:post-reset:${currentQuotaDispatchSequence()}` : "";
const admission = await fetchCodexUsage<MainAccountInfoFetchResult>(
`${baseKey}${resetEpoch}`, {
headers: { Authorization: `Bearer ${tokens.access_token}`, "ChatGPT-Account-Id": tokens.account_id },
signal: quotaSignal,
}, () => { dispatchSequence = nextQuotaDispatchSequence(); },
paced ? { pacingKey: baseKey } : { unpaced: true });
if (!admission) return { info: getMainAccountInfoCache() ?? EMPTY_MAIN_ACCOUNT_INFO,
credentialChecked: true, hasCredential: true };
if (admission.kind === "joined") {
const current = credentialIsCurrent() && writerGeneration === captureConfigGeneration();
if (!current) return { info: getMainAccountInfoCache() ?? EMPTY_MAIN_ACCOUNT_INFO,
credentialChecked: true, hasCredential: true };
// Single-flight shares evidence, but each caller retains its own auth behavior.
if (!options.passive && admission.result.terminalAuthFailure) {
const diagnosticStillLive = admission.result.quotaRefreshGeneration !== undefined
&& isMainAccountIdentityGenerationLive(admission.result.quotaRefreshGeneration);
clearMainAccountInfoCache();
markAccountNeedsReauth(MAIN_CODEX_ACCOUNT_ID, writerGeneration);
return { ...admission.result, ...(diagnosticStillLive
? { quotaRefreshGeneration: captureMainAccountIdentityGeneration() } : {}) };
}
if (!options.passive && explicitRefresh && (admission.result.quotaRefresh?.status === "ok"
|| admission.result.quotaRefresh?.status === "not_reported")) clearAccountNeedsReauth(MAIN_CODEX_ACCOUNT_ID);
return admission.result;
}
readState.owner = admission;
const resp = admission.response;
quotaPhase = "publish";
if (!resp.ok) {
const ownedExpiry = owned ? decodeJwtPayload(owned.accessToken)?.exp : undefined;
const authFailure = await classifyMainAuthResponse(resp, owned
? typeof ownedExpiry === "number" && ownedExpiry * 1000 > Date.now()
: isMainAccountTokenVerifiablyLive());
const terminalAuthFailure = authFailure.terminal;
const retried = await retryMainAccountInfoIfIdentityChanged(requestAccountId, retriesRemaining, nativeMainLease, explicitRefresh, paced, options);
if (retried) return retried;
if (!isQuotaDispatchCurrent(dispatchSequence) || !credentialIsCurrent()) {
return { info: getMainAccountInfoCache() ?? EMPTY_MAIN_ACCOUNT_INFO,
credentialChecked: true, hasCredential: true };
}
if (terminalAuthFailure && !options.passive) {
// Account for this attempt's own synchronous invalidation, never prior external drift.
const diagnosticStillLive = isMainAccountIdentityGenerationLive(quotaRefreshGeneration);
clearMainAccountInfoCache();
if (diagnosticStillLive) quotaRefreshGeneration = captureMainAccountIdentityGeneration();
markAccountNeedsReauth(MAIN_CODEX_ACCOUNT_ID, writerGeneration);
}
// Keep the last-known plan visible: after a plan change revokes the session, the plan the
// account HAD is what tells the operator why it stopped working.
return {
info: { ...EMPTY_MAIN_ACCOUNT_INFO, plan: nonEmptyPlan(cached?.plan) ?? nonEmptyPlan(getMainAccountPlan()) },
credentialChecked: true, hasCredential: true,
quotaRefresh: { status: "http_error", httpStatus: resp.status,
...(authFailure.code ? { code: authFailure.code } : {}) },
quotaRefreshGeneration,
...(terminalAuthFailure ? { terminalAuthFailure: true as const } : {}),
};
}
quotaPhase = "body";
const data = (await resp.json()) as WhamUsageResponse;
quotaPhase = "publish";
const retried = await retryMainAccountInfoIfIdentityChanged(requestAccountId, retriesRemaining, nativeMainLease, explicitRefresh, paced, options);
if (retried) return retried;
quotaPhase = "decode";
if (data === null || typeof data !== "object" || Array.isArray(data)) {
throw new Error("Invalid WHAM usage object");
}
// A newer published response wins over this attempt, including its returned display info.
if (!isQuotaDispatchCurrent(dispatchSequence)) {
return { info: getMainAccountInfoCache() ?? EMPTY_MAIN_ACCOUNT_INFO,
credentialChecked: true, hasCredential: true };
}
quotaPhase = "publish";
// A delayed response from a replaced bearer cannot revoke a newer Reserve grant,
// even in the same workspace or after an A→B→A credential transition.
if (credentialIsCurrent()) {
observeMainReserveRevocation(data, mainQuotaWriter);
}
quotaPhase = "decode";
const plan = nonEmptyPlan(data.plan_type) ?? nonEmptyPlan(cached?.plan) ?? nonEmptyPlan(getMainAccountPlan());
const usage = { ...data, ...(plan ? { plan_type: plan } : {}) };
const quota = parseUsageQuota(usage);
const policyQuota = parseMainPolicyUsageQuota(usage);
quotaPhase = "publish";
const result = {
email: data.email ?? null,
plan,
quota,
ts: Date.now(),
};
if (!credentialIsCurrent()) {
// Preserve same-identity ordinary info, but never publish stale evidence or state.
if (mainQuotaWriter && isMainQuotaWriterLive(mainQuotaWriter)) {
return { info: result, infoUnpublished: true, credentialChecked: true, hasCredential: true };
}
return { info: getMainAccountInfoCache() ?? EMPTY_MAIN_ACCOUNT_INFO,
credentialChecked: true, hasCredential: true };
}
const freshResetCredits = quota?.resetCredits;
// Tag the count with the identity it was read from, so a later response that omits the
// summary can restore the badge without ever crossing an account boundary.
rememberMainResetCredits(requestAccountId, freshResetCredits);
if (requestAccountId !== null) rememberCodexCredits(MAIN_CODEX_ACCOUNT_ID, requestAccountId, parseWhamCredits(usage));
setMainAccountInfoCache(result);
// Only an explicit refresh may retract a reauth quarantine. A 200 from
// /wham/usage proves the token authenticates to the usage endpoint; it does not
// prove the account can serve Responses traffic, which is a different backend path
// and still answers 403 for a workspace the token may no longer select (#327).
// Letting the background poll clear the flag put such an account straight back into
// rotation: the next request failed the same way and re-marked it, so needsReauth
// never settled and the dashboard kept showing nothing — the symptom #327 reported.
// An explicit refresh is an operator asking to re-evaluate, normally right after
// signing in again, so it stays authoritative.
if (explicitRefresh && !options.passive) clearAccountNeedsReauth(MAIN_CODEX_ACCOUNT_ID);
// Mirror main quota + plan into the shared stores so the rotation engine can
// score and auto-switch the main account exactly like a pool account (Option A).
setMainAccountPlan(result.plan);
if (result.quota) {
setAccountQuotaFromParsed(MAIN_CODEX_ACCOUNT_ID, result.quota, writerGeneration, mainQuotaWriter, policyQuota, undefined, false, false, isValidWhamHistoryObservation(usage) ? quota : null);
}
publishQuotaDispatch(dispatchSequence);
readState.usable = quota !== null;
return {
info: result,
quotaRefresh: { status: quota ? "ok" : "not_reported" },
quotaRefreshGeneration,
credentialChecked: true,
hasCredential: true,
...(quota ? { freshQuota: quota } : {}),
...(quota && mainQuotaWriter && credentialIsCurrent()
? { resetRecoveryProof: { writer: mainQuotaWriter, credentialGeneration: mainQuotaCredentialGeneration, dispatchSequence } }
: {}),
...(freshResetCredits !== undefined ? { freshResetCredits } : {}),
};
} catch (error) {
const retried = await retryMainAccountInfoIfIdentityChanged(requestAccountId, retriesRemaining, nativeMainLease, explicitRefresh, paced, options);
if (retried) return retried;
if (!credentialIsCurrent()) {
return { info: getMainAccountInfoCache() ?? EMPTY_MAIN_ACCOUNT_INFO,
credentialChecked: true, hasCredential: true };
}
let status: CodexQuotaRefreshOutcome["status"] = "internal_error";
if ((quotaPhase === "request" || quotaPhase === "body") && quotaSignal.aborted) status = "timeout";
else if (quotaPhase === "request") status = "network_error";
else if (quotaPhase === "body") status = error instanceof SyntaxError ? "invalid_response" : "network_error";
else if (quotaPhase === "decode") status = "invalid_response";
return {
info: EMPTY_MAIN_ACCOUNT_INFO, credentialChecked: true, hasCredential: true,
quotaRefresh: { status },
quotaRefreshGeneration,
};
}
};
let outcome: MainAccountInfoFetchResult | undefined;
try { outcome = await read(); return outcome; }
finally { readState.owner?.settle(readState.usable, outcome); }
}