@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
663 lines (639 loc) • 33.9 kB
text/typescript
import { markProxyError } from "../../lib/client-error-body";
import { applyClaudeBridgePoolSession } from "../claude-bridge-pool-session";
import type { OcxProviderConfig, OcxConfig } from "../../types";
import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers";
import type { CodexAuthContext } from "../../codex/auth-context";
import type { RouteResult } from "../../router";
import { routeConcreteModel } from "../../router";
import type { HandleResponsesOptions } from "./core-options";
import {
hasForwardableCodexBearer,
validateForwardAdmissionCredential,
isProxyAdmissionSecret,
ForwardAdmissionCredentialError,
} from "../auth-cors";
import {
providerConsumesCallerAuthorization,
captureCallerDirectAuth,
} from "../../providers/caller-authorization";
import { inspectChatGptDomainClaim } from "../../oauth/chatgpt";
import {
resolveCodexAuthContext,
CodexMainProfileDrainingError,
materializeCodexUpstreamAuthAsync,
headersForCodexAuthContext,
isCodexAuthContextUsable,
releaseCodexAuthContextProbeLease,
CodexAuthContextError,
applyCodexAuthContextToProvider,
stripCodexRuntimeProviderFields,
mainAccountHardLockCallerProof,
} from "../../codex/auth-context";
import { codexAccountSelectionForTurn, tryClaimNativeMainProfileForTurn } from "../lifecycle";
import { isNativeMainTrafficBlocked } from "../../codex/native-profile-startup";
import { formatErrorResponse } from "../../bridge";
import { clientCancelledResponse } from "./core-errors";
import { formatCodexProviderForLog, handOffThreadAffinityGeneration } from "../../codex/routing";
import { mapCodexAuthContextErrorToResponse, nativeMainRefreshFailureResponse } from "./codex-auth-error";
import {
isTerminalCodexPoolRefreshFailure,
forceRefreshCodexPoolToken,
capturePoolQuotaWriter,
} from "../../codex/account-store";
import type { RequestLogContext } from "../request-log";
import { markLocalRequestLogRefusal } from "../request-log";
import { CODEX_POOL_REFRESH_INCOMPLETE_LOG_REASON } from "../../codex/pool-refresh-backoff";
import { codexAuthContextLogLabel } from "../../codex/account-label";
import { forceRefreshMainAccountToken, mainAccountTokenQuotaWriter } from "../../codex/main-account";
import { rebindPoolCreditPolicy } from "../../codex/pool-credit-policy";
import { safeCallerSessionId } from "../caller-session-identity";
import { copyResponsesClientMetadata } from "../../adapters/openai-responses/transport";
import { AgentAssertionUnsupportedError, agentAssertionUnsupportedResponse, authorizationCredential, carryAgentAssertionForCallerBearer, hasAgentAssertionAuthorization } from "../../lib/authorization-scheme";
/** Normalize caller aliases only on native egress; preserve ingress and fallback identity. */
export function withClaudeNativeSession(headers: Headers, provider: OcxProviderConfig, sessionId?: string): Headers {
// Empty values count as absent, matching materializeCodexUpstreamAuth, so first attempts and
// retries rebuilt from caller headers pick the same identity.
if (!isCanonicalOpenAiForwardProvider(provider) || headers.get("session_id")) return headers;
const alias = ["session-id", "thread-id"].find(name => headers.get(name));
const nativeSession = alias ? safeCallerSessionId(headers.get(alias)) : sessionId;
// A non-empty invalid alias suppresses weaker metadata identity.
if (!nativeSession) return headers;
const forwarded = new Headers(headers);
forwarded.set("session_id", nativeSession);
return forwarded;
}
export type ResponsesAuthResolution =
| { ok: true; authCtx: CodexAuthContext; headers: Headers; callerAuthHeaders: Headers; substituteMainCredential: boolean }
| { ok: false; response: Response };
export type CodexCredentialOwnershipOptions = Pick<HandleResponsesOptions,
"admission" | "callerDirectAuth" | "stripClaudeMainAuthForNoncanonicalForward" | "trustedClaudeMainAuth">;
/**
* Restore the provider's permitted caller metadata onto a header set rebuilt from a credential
* allowlist. Every physical send of one Responses turn goes through this rule: the first send,
* the 401 refresh replay and the alternate-account retry. The copier fills only names the target
* does not already carry, so a selected Pool installation identity and configured provider
* headers keep precedence over the caller's values.
*/
export function restoreResponsesClientMetadata(
headers: Headers,
incoming: Headers,
provider: OcxProviderConfig,
compactionRecoveryKind?: HandleResponsesOptions["compactionRecoveryKind"],
): void {
if (provider.adapter === "openai-responses" || compactionRecoveryKind === "compaction-v1") {
copyResponsesClientMetadata(headers, incoming, provider);
}
}
/**
* The caller credential the final Codex auth resolution will be given, as far as the ROUTE
* decides it: a route change that may cross a credential domain drops the raw caller credential,
* and a trusted Claude-main handoff replaces it.
*
* Shared with the lineage preview in `handleResponsesInner`, which has to read a conversation's
* family under the same authenticated scope the resolution will record it under -- that scope is
* an HMAC of exactly this Authorization header. Two copies of this rule would put preview and
* final auth in different scopes the first time one of them changed.
*/
/**
* The stored native-main credential this process injected itself, when it is the bearer the
* resolution will see.
*
* `handleClaudeMessages` reads `~/.codex/auth.json` and attaches it so OpenAI-backed sidecars stay
* reachable on a translated turn. It is OUR credential, not the caller's -- the ingress says so
* where it sets `nativeCallerAuth` and `callerDirectAuth` to null for exactly this reason -- and
* every reader of the resolution's input headers has to agree about that, or one of them conclud
* the request owns a credential that in fact belongs to the Pool.
*/
export function injectedClaudeMainBearer(
route: Pick<RouteResult, "provider">,
options: CodexCredentialOwnershipOptions,
): { authorization: string; chatgptAccountId?: string } | undefined {
return options.stripClaudeMainAuthForNoncanonicalForward === true
&& isCanonicalOpenAiForwardProvider(route.provider)
? options.trustedClaudeMainAuth : undefined;
}
function validatedCallerDirectHeaders(
config: OcxConfig,
route: Pick<RouteResult, "provider">,
options: CodexCredentialOwnershipOptions,
): Headers | undefined {
if (!options.callerDirectAuth || !isCanonicalOpenAiForwardProvider(route.provider)) return undefined;
const headers = new Headers({ authorization: options.callerDirectAuth.authorization });
if (options.callerDirectAuth.chatgptAccountId) headers.set("chatgpt-account-id", options.callerDirectAuth.chatgptAccountId);
return captureCallerDirectAuth(headers, config) ? headers : undefined;
}
function codexRouteCredentialDomainHeadersFor(
req: Request,
route: RouteResult,
options: HandleResponsesOptions,
credentialDomainWasRewritten: boolean,
config: OcxConfig,
): Headers {
const callerDirect = validatedCallerDirectHeaders(config, route, options);
if (callerDirect) {
const headers = new Headers(req.headers);
headers.set("authorization", callerDirect.get("authorization")!);
const accountId = callerDirect.get("chatgpt-account-id");
if (accountId) headers.set("chatgpt-account-id", accountId);
else headers.delete("chatgpt-account-id");
return headers;
}
const trustedClaudeMainForFinalRoute = injectedClaudeMainBearer(route, options);
if (trustedClaudeMainForFinalRoute) {
const claudeMainHeaders = new Headers(req.headers);
claudeMainHeaders.set("authorization", trustedClaudeMainForFinalRoute.authorization);
if (trustedClaudeMainForFinalRoute.chatgptAccountId) {
claudeMainHeaders.set("chatgpt-account-id", trustedClaudeMainForFinalRoute.chatgptAccountId);
} else {
claudeMainHeaders.delete("chatgpt-account-id");
}
return claudeMainHeaders;
}
// Route-changing recursion retains typed admission, never an unscoped raw
// caller credential. Bearer admission is substituted or stripped below.
const routeMayChangeCredentialDomain = options.comboAttempt === true
// A JEV decision-model turn is a new credential domain even though it starts headerless.
|| options.internalDecisionCall === true
|| route.routeKind === "policy"
|| route.credentialDomainRewrite === true
|| credentialDomainWasRewritten;
if (routeMayChangeCredentialDomain && options.admission?.source !== "bearer") {
const scoped = new Headers(req.headers);
scoped.delete("authorization");
scoped.delete("chatgpt-account-id");
return scoped;
}
return req.headers;
}
/**
* Credential-domain headers for Codex account SELECTION (previews, recovery, final resolution).
* A Claude bridge pool identity is completed here only; upstream headers are always materialized
* from the uncompleted form, so the synthesized pair never reaches the wire.
*/
export function codexRouteCredentialDomainHeaders(
req: Request, route: RouteResult, options: HandleResponsesOptions,
credentialDomainWasRewritten: boolean, config: OcxConfig,
): Headers {
return applyClaudeBridgePoolSession(
codexRouteCredentialDomainHeadersFor(req, route, options, credentialDomainWasRewritten, config), route, options,
);
}
/**
* Does this route substitute OUR stored main credential, and does the caller own the credential
* this request will authenticate with?
*
* Both answers are needed twice: by the resolution below, and by the lineage preview, which must
* not follow a Pool family binding for a request whose credential never enters Pool state. One
* implementation, because two copies of this predicate disagreeing is the divergence the preview
* gate exists to prevent. The reasoning behind the substitution test itself is at its use site
* below (#1686, #2132).
*/
export function codexRouteCredentialOwnership(
authInputHeaders: Headers,
config: OcxConfig,
route: Pick<RouteResult, "provider" | "codexAccountMode">,
options: CodexCredentialOwnershipOptions,
): { substituteMainCredential: boolean; requestScopedMainCredential: boolean } {
const substituteMainCredential = options.admission?.source === "bearer"
&& (route.codexAccountMode !== undefined || isCanonicalOpenAiForwardProvider(route.provider));
return {
substituteMainCredential,
// A request-scoped main credential is one the CALLER owns: it exists for this request only,
// owns no Pool state, and must never be quarantined or refreshed on the Pool's behalf. The
// stored credential this process injected is the opposite of that in every respect, and
// `hasForwardableCodexBearer` cannot tell them apart -- it sees a Codex JWT with an account
// id either way. Counting ours as the caller's made the native main slot caller-owned on
// every translated Claude turn: `main` instead of `main-pool`, so an upstream 401 on a
// revoked session recorded no outcome, refreshed nothing, and retired nothing, and the next
// request sent the same dead token again.
requestScopedMainCredential: route.codexAccountMode !== undefined
&& !substituteMainCredential
&& (validatedCallerDirectHeaders(config, route, options) !== undefined
|| injectedClaudeMainBearer(route, options) === undefined)
&& hasForwardableCodexBearer(authInputHeaders, config),
};
}
/**
* Resolve Codex auth for a route. On unusable contexts, releases any probe lease
* before returning the 401 (nothing reaches upstream).
*/
export async function resolveResponsesCodexAuth(
req: Request,
config: OcxConfig,
route: RouteResult,
options: HandleResponsesOptions,
credentialDomainWasRewritten = false,
retainAccountForUploadedFiles = false,
): Promise<ResponsesAuthResolution> {
let authCtx: CodexAuthContext | undefined;
// Ingress already refuses assertion_only; a later internal hop must not reach a pool or
// routed credential with it either, because that would be a silent credential swap.
if (hasAgentAssertionAuthorization(req.headers)) return { ok: false, response: markProxyError(agentAssertionUnsupportedResponse()) };
try {
let authInputHeaders = codexRouteCredentialDomainHeadersFor(
req,
route,
options,
credentialDomainWasRewritten,
config,
);
// A caller-auth transport that is not canonical OpenAI (keyless Cursor) consumes the
// caller's Authorization as its own upstream token. Keep that contract only for a clean
// single bearer with NO ChatGPT-domain marker. A bearer marked for the ChatGPT domain —
// whether its marker is valid or malformed/conflicting — a combined/malformed value, or
// the captured explicit OpenAI pair is never a Cursor token; a foreign JWT carrying only
// a generic organizations claim is not ChatGPT-marked and keeps the legacy contract.
// chatgpt-account-id has no meaning outside the ChatGPT domain.
if (!isCanonicalOpenAiForwardProvider(route.provider)
&& providerConsumesCallerAuthorization(route.provider)) {
const rawAuth = authInputHeaders.get("authorization")?.trim();
const singleBearer = /^Bearer[\t ]+([^\s,]+)$/i.exec(rawAuth ?? "")?.[1];
const domainClaim = singleBearer ? inspectChatGptDomainClaim(singleBearer) : { kind: "absent" as const };
const dropBearer = options.nativeCallerAuth != null || domainClaim.kind !== "absent"
|| (rawAuth !== undefined && singleBearer === undefined);
if (dropBearer || authInputHeaders.has("chatgpt-account-id")) {
const scoped = new Headers(authInputHeaders);
if (dropBearer) scoped.delete("authorization");
scoped.delete("chatgpt-account-id");
authInputHeaders = scoped;
}
}
// #1686: a caller that proved admission with a BEARER presented one of our own secrets.
// Refusing it here is what made the codex-cli `env_key` contract unusable against Direct.
// Admitting it is only safe because the stored main credential is substituted below, so
// the admission secret still never leaves this process.
//
// #2132: substitution answers "does THIS ROUTE need our stored ChatGPT credential", not
// "how did the caller authenticate". Only a native Codex route reaches the ChatGPT backend
// and can consume that credential; a key-authenticated routed provider carries its own and
// never touches it. Keying on the caller alone made an install that deliberately never
// logged into ChatGPT fail every routed request with "No usable Codex main credential".
//
// But ask that question the way the ADAPTER asks it. `codexAccountMode` is derived from the
// provider NAME (`providerCodexAccountMode`), while the passthrough adapter decides whether
// to forward caller credentials from the TRANSPORT — adapter, auth mode, and base URL
// (`isCanonicalOpenAiForwardProvider`). A row the operator named anything other than
// `openai`, pointed at the canonical ChatGPT backend with `authMode: "forward"`, satisfies
// the adapter's test and fails this one, so substitution was skipped and the adapter then
// forwarded our own admission secret upstream. Two predicates answering one question is the
// bug; the transport is the authority, because the transport is what actually carries the
// header. A key-authenticated routed provider is still not canonical-forward, so #2132's
// no-ChatGPT-login install keeps working.
const { substituteMainCredential, requestScopedMainCredential } = codexRouteCredentialOwnership(
authInputHeaders,
config,
route,
options,
);
const stripAuthorization = options.admission?.source === "bearer" && !substituteMainCredential;
if (route.codexAccountMode === "direct" && !substituteMainCredential) {
validateForwardAdmissionCredential(authInputHeaders, config);
}
if (route.codexAccountMode) {
// Only selection sees the Claude bridge pool identity; materialization below keeps the
// uncompleted headers, so the wire matches the original request.
authCtx = await resolveCodexAuthContext(applyClaudeBridgePoolSession(authInputHeaders, route, options), config, route.codexAccountMode, {
admission: options.admission,
codexAuthPolicy: options.codexAuthPolicy,
accountId: route.codexAccountId,
modelId: route.modelId,
substituteMainCredentialForDirect: substituteMainCredential,
requestScopedMainCredential,
beginCodexAccountSelection: codexAccountSelectionForTurn(options.turnAdmissionLease),
resolveCodexModelEntitlements: options.resolveCodexModelEntitlements,
signal: options.abortSignal,
nativeMainRefreshDependencies: options.nativeMainRefreshDependencies,
retainAccountForUploadedFiles,
});
options.onCodexAuthContextResolved?.(authCtx);
} else {
// A custom-named canonical-forward provider has no Codex account mode, but an
// admission bearer still substitutes the stored main credential below. Claim the
// same physical profile before synthesizing the main context so transport-based
// substitution cannot bypass a switch drain.
if (
substituteMainCredential
&& (
isNativeMainTrafficBlocked()
|| !tryClaimNativeMainProfileForTurn(options.turnAdmissionLease)
|| isNativeMainTrafficBlocked()
)
) {
throw new CodexMainProfileDrainingError();
}
authCtx = { kind: "main", accountId: null };
options.onCodexAuthContextResolved?.(undefined);
}
// This resolver also builds a synthetic main context for unrelated keyed routes. Only
// the actual Codex-forward transport consumes main quota; provider names are not proof
// (custom-named canonical-forward providers must retain the same protection).
const mainPolicyConfig = isCanonicalOpenAiForwardProvider(route.provider)
? options.codexAuthPolicy ?? config : undefined;
const headers = await materializeCodexUpstreamAuthAsync(authInputHeaders, authCtx, {
admission: options.admission,
config: mainPolicyConfig,
modelId: route.modelId,
beginCodexAccountSelection: codexAccountSelectionForTurn(options.turnAdmissionLease),
substituteMainCredential,
signal: options.abortSignal,
nativeMainRefreshDependencies: options.nativeMainRefreshDependencies,
});
// Awaiting even a cached materialization yields. Preserve the policy error if the live
// quota/config changed during that yield, before usability could mislabel it as reauth.
headersForCodexAuthContext(headers, authCtx, mainPolicyConfig, route.modelId, options.admission);
if (!isCodexAuthContextUsable(authCtx, config)) {
releaseCodexAuthContextProbeLease(authCtx);
return {
ok: false,
response: markProxyError(formatErrorResponse(401, "authentication_error", "Selected Codex account needs reauthentication")),
};
}
if (stripAuthorization) {
headers.delete("authorization");
headers.delete("chatgpt-account-id");
}
if (providerConsumesCallerAuthorization(route.provider) && options.admission?.source !== undefined
&& options.admission.source !== "loopback") {
validateForwardAdmissionCredential(headers, config);
} else {
// Even adapters that ignore caller auth must not retain a proxy secret for
// a later internal hop or a future transport change.
const bearer = authorizationCredential(headers);
if (bearer && isProxyAdmissionSecret(bearer, config)) {
headers.delete("authorization");
headers.delete("chatgpt-account-id");
}
}
// Auth materialization keeps only its credential allowlist. Responses turns and compact
// handoffs also need the provider's permitted metadata, without replacing selected identity.
restoreResponsesClientMetadata(headers, authInputHeaders, route.provider, options.compactionRecoveryKind);
// dual_header: the assertion is first-party only and travels only beside the caller's own
// unchanged Bearer, compared with the ORIGINAL request (injected credentials do not count).
if (isCanonicalOpenAiForwardProvider(route.provider) && authCtx?.kind === "main" && !substituteMainCredential) {
carryAgentAssertionForCallerBearer(headers, req.headers);
}
return {
ok: true,
authCtx,
headers,
callerAuthHeaders: new Headers(authInputHeaders),
substituteMainCredential,
};
} catch (err) {
releaseCodexAuthContextProbeLease(authCtx);
if (options.abortSignal?.aborted || req.signal.aborted) {
return { ok: false, response: clientCancelledResponse() };
}
if (err instanceof CodexAuthContextError) {
const safeAccountLabel = route.codexAccountNamespace
? `${route.providerName}-${route.codexAccountNamespace}`
: formatCodexProviderForLog(route.providerName, err.accountId, config);
console.error(`[codex-auth] Pool account ${safeAccountLabel} token failed; reauthentication required`);
}
if (err instanceof ForwardAdmissionCredentialError) {
return { ok: false, response: markProxyError(formatErrorResponse(401, "authentication_error", err.message)) };
}
if (err instanceof AgentAssertionUnsupportedError) return { ok: false, response: markProxyError(agentAssertionUnsupportedResponse()) };
const response = mapCodexAuthContextErrorToResponse(err, {
accountSelector: route.codexAccountNamespace,
now: Date.now(),
});
if (response) return { ok: false, response };
throw err;
}
}
/**
* Terminal means the grant itself is dead and no retry can help. Everything else —
* an untyped network failure, a token-endpoint 5xx surfacing as `unknown`, an abort,
* refresh capacity, lock contention, a superseded flight — is transient, and treating
* it as terminal would quarantine a healthy account on an upstream blip, which is the
* defect this path exists to fix (#2887).
*/
export function isTerminalPoolRefreshFailure(error: unknown): boolean {
// Delegated so "terminal" has ONE definition. A missing record or a missing refresh-grant
// fingerprint is permanent -- retrying cannot conjure a credential -- and used to be a bare
// Error, which fell through to the retryable 503 and told the operator to keep retrying a
// request that could never succeed.
return isTerminalCodexPoolRefreshFailure(error);
}
/**
* The refusal an operator meets when a stored pool credential's forced refresh does not complete.
*
* A bare "retry this request" reads as a transient fault in the proxy, which is how #4212's
* reporter spent an afternoon concluding OpenCodex had broken while one of their own accounts was
* the thing that needed them. It stays a retryable 503 and stays non-quarantining, because the
* refresh genuinely may succeed and a token-endpoint 5xx must not retire a healthy account
* (#2887). What it adds is the account and the exit: when retrying stops helping, that account
* has to be signed in again.
*
* The label is a public account selector when the request carried one, otherwise the durable
* `p`-prefixed log label — never the raw pool id and never the email. Those are the identifiers
* `responses-compaction-routing.test.ts` and `codex-auth-context.test.ts` already assert must not
* reach an operator-facing surface, and an error body travels further than a log line, not less.
* When neither is resolvable the sentence degrades to "the selected Codex pool account" rather
* than naming something opaque, because a wrong name is worse than no name.
*
* The wording says "sign in to that account again" and deliberately does NOT say
* "reauthentication". `classifyError` runs `isAuthenticationMessage` before it reaches the
* `status === 503` arm, and that check is status-blind on the bare substring "authentication",
* which "reauthentication" contains. A body carrying that word is reclassified to
* `authentication_error` / `invalid_api_key` even though the HTTP status stays 503 — and Codex
* applies retry-after backoff only for `server_is_overloaded`, so the friendlier sentence would
* have quietly disabled the retry this refusal exists to ask for. `options.code` cannot buy the
* classification back; only the wording can.
*/
export function poolCredentialRefreshIncompleteResponse(args: {
authCtx: CodexAuthContext;
config: Pick<OcxConfig, "codexAccounts">;
accountSelector?: string;
logCtx?: RequestLogContext;
}): Response {
// The wire contract below is unchanged on purpose, so the record has to carry the origin
// instead. Without it an operator reads this sentence under a field named "Upstream reason"
// and goes looking at the provider's status page for a refusal that never left this process.
if (args.logCtx) markLocalRequestLogRefusal(args.logCtx, CODEX_POOL_REFRESH_INCOMPLETE_LOG_REASON);
const label = args.accountSelector ?? codexAuthContextLogLabel(args.authCtx, args.config);
const account = label ? `Codex pool account ${label}` : "the selected Codex pool account";
const response = markProxyError(formatErrorResponse(
503,
"server_busy",
`Codex credential refresh did not complete for ${account}; retry this request. `
+ "If it keeps failing, sign in to that account again.",
));
const headers = new Headers(response.headers);
headers.set("Retry-After", "1");
return markProxyError(new Response(response.body, { status: response.status, headers }), "pool_refresh");
}
/**
* One forced refresh and one same-account rebuild for a stored pool credential that
* upstream rejected with a pre-stream 401. `quarantine` distinguishes a dead grant,
* which must retire the account, from a transient failure, which must not.
*/
export async function refreshPoolForwardAuth(args: {
logCtx?: RequestLogContext;
req: Request;
config: OcxConfig;
route: RouteResult;
authCtx: CodexAuthContext & { kind: "pool" };
substituteMainCredential: boolean;
options: HandleResponsesOptions;
}): Promise<
| { ok: true; authCtx: CodexAuthContext; provider: OcxProviderConfig; headers: Headers }
| { ok: false; response: Response; quarantine: boolean; quarantineGeneration?: number }
> {
const { req, config, route, authCtx, substituteMainCredential, options } = args;
try {
const refreshed = await forceRefreshCodexPoolToken(authCtx.accountId, {
rejectedGeneration: authCtx.generation,
rejectedAccessToken: authCtx.accessToken,
signal: options.abortSignal,
});
if (!refreshed.rotated) {
// The store resolved to the same bearer upstream just rejected. Replaying it
// would spend another upstream call to earn the identical 401. Upstream can do
// this on a SUCCESSFUL response by rotating only the refresh grant, so the
// credential generation may already have moved — quarantine has to be fenced on
// where the credential actually is, not on the generation we started from.
return {
ok: false,
quarantine: true,
quarantineGeneration: refreshed.generation,
response: markProxyError(formatErrorResponse(401, "authentication_error", "Selected Codex account needs reauthentication")),
};
}
// Only a CAS this request performed itself proves the new credential descends from
// the rejected one. Somebody else's replacement may be a different identity, and
// its affinity must be retired rather than inherited.
if (refreshed.selfRefreshed) {
handOffThreadAffinityGeneration(authCtx.accountId, authCtx.generation, refreshed.generation);
}
const refreshedAuthCtx: CodexAuthContext = {
...authCtx,
accessToken: refreshed.accessToken,
chatgptAccountId: refreshed.chatgptAccountId,
generation: refreshed.generation,
poolQuotaWriter: capturePoolQuotaWriter(authCtx.accountId, refreshed),
};
// The spread dropped the WeakMap-bound credit policy: without the live binding a hold or
// opt-out landing during the refresh await would go unchecked on every no-override path.
rebindPoolCreditPolicy(authCtx, refreshedAuthCtx);
const provider = applyCodexAuthContextToProvider(
stripCodexRuntimeProviderFields(route.provider),
refreshedAuthCtx,
route.codexAccountMode,
);
const headers = await materializeCodexUpstreamAuthAsync(req.headers, refreshedAuthCtx, {
admission: options.admission,
config: options.codexAuthPolicy ?? config,
modelId: route.modelId,
substituteMainCredential,
signal: options.abortSignal,
nativeMainRefreshDependencies: options.nativeMainRefreshDependencies,
});
// The replay is a second physical send of the same turn: it keeps the caller metadata the
// first send carried instead of reverting to the credential-only allowlist.
restoreResponsesClientMetadata(headers, req.headers, provider, options.compactionRecoveryKind);
return { ok: true, authCtx: refreshedAuthCtx, provider, headers };
} catch (error) {
if (isTerminalPoolRefreshFailure(error)) {
return {
ok: false,
quarantine: true,
response: markProxyError(formatErrorResponse(401, "authentication_error", "Selected Codex account needs reauthentication")),
};
}
if (options.abortSignal?.aborted || req.signal.aborted) {
return { ok: false, quarantine: false, response: clientCancelledResponse() };
}
// The credential itself refreshed; a policy refusal raised afterwards (a credit hold or an
// opt-out that landed during the await) is not a refresh failure. Map it the same way the
// admission path does — a reset-bound 429, never a 503 telling the caller to sign in — and
// never quarantine a valid account for a policy refusal.
const policyResponse = mapCodexAuthContextErrorToResponse(error, {
accountSelector: route.codexAccountNamespace,
now: Date.now(),
});
if (policyResponse) return { ok: false, quarantine: false, response: policyResponse };
return {
ok: false,
quarantine: false,
response: poolCredentialRefreshIncompleteResponse({
authCtx,
config,
accountSelector: route.codexAccountNamespace,
logCtx: args.logCtx,
}),
};
}
}
export async function refreshNativeMainForwardAuth(args: {
req: Request;
config: OcxConfig;
route: RouteResult;
authCtx: CodexAuthContext;
substituteMainCredential: boolean;
options: HandleResponsesOptions;
}): Promise<
| { ok: true; authCtx: CodexAuthContext; provider: OcxProviderConfig; headers: Headers }
| { ok: false; response: Response }
> {
const { req, config, route, authCtx, substituteMainCredential, options } = args;
if (authCtx.kind !== "main-pool") {
return { ok: false, response: markProxyError(formatErrorResponse(401, "authentication_error", "No native main credential to refresh")) };
}
try {
const refreshed = await forceRefreshMainAccountToken(authCtx.accessToken, {
signal: options.abortSignal,
...(options.nativeMainRefreshDependencies ?? {}),
});
if (!refreshed) {
return { ok: false, response: markProxyError(formatErrorResponse(401, "authentication_error", "Codex main account needs reauthentication")) };
}
const refreshedAuthCtx: CodexAuthContext = {
...authCtx,
accessToken: refreshed.accessToken,
chatgptAccountId: refreshed.chatgptAccountId,
mainQuotaWriter: mainAccountTokenQuotaWriter(refreshed) ?? authCtx.mainQuotaWriter,
};
const provider = applyCodexAuthContextToProvider(
stripCodexRuntimeProviderFields(route.provider),
refreshedAuthCtx,
route.codexAccountMode,
);
const headers = await materializeCodexUpstreamAuthAsync(req.headers, refreshedAuthCtx, {
admission: options.admission,
config: options.codexAuthPolicy ?? config,
modelId: route.modelId,
substituteMainCredential,
signal: options.abortSignal,
nativeMainRefreshDependencies: options.nativeMainRefreshDependencies,
});
// Same rule as the stored Pool refresh: the replay keeps permitted caller metadata.
restoreResponsesClientMetadata(headers, req.headers, provider, options.compactionRecoveryKind);
return { ok: true, authCtx: refreshedAuthCtx, provider, headers };
} catch (error) {
if (options.abortSignal?.aborted || req.signal.aborted) {
return { ok: false, response: clientCancelledResponse() };
}
return { ok: false, response: mapCodexAuthContextErrorToResponse(error, {
now: Date.now(), accountSelector: route.codexAccountNamespace,
}) ?? nativeMainRefreshFailureResponse(error) };
}
}
/** Inspect the original credential domain, before fallback changes the route or drops headers. */
export function mainHardLockFallbackCallerCheck(
req: Request, config: OcxConfig, options: HandleResponsesOptions,
): (sourceModel: string) => Promise<(() => boolean) | null> {
return async sourceModel => {
let sourceRoute: ReturnType<typeof routeConcreteModel>;
try { sourceRoute = routeConcreteModel(config, sourceModel); }
// This preview cannot replace the normal routing phase's existing error response.
catch { return null; }
const headers = codexRouteCredentialDomainHeaders(req, sourceRoute, options, false, config);
const { substituteMainCredential } = codexRouteCredentialOwnership(headers, config, sourceRoute, options);
return mainAccountHardLockCallerProof(headers, options.codexAuthPolicy ?? config, {
substituteMainCredentialForDirect: substituteMainCredential,
signal: options.abortSignal ?? req.signal,
});
};
}