@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
231 lines (214 loc) • 11.8 kB
text/typescript
/**
* Per-account model denials observed from an authenticated upstream refusal.
*
* [Decision Log]
* - 목적과 의도: Keep the one piece of account-specific model evidence that is never stale --
* the upstream's own refusal -- instead of discarding it after a single retry.
* - 기존 구현 및 제약 조건: `cachedDeniedCodexAccountIdsForModel` reads authenticated `/models`
* rosters, and those entries expire five minutes after they are fetched
* (`MODEL_ROSTER_TTL_MS`). Nothing on the flagship request path refills them, because
* `resolveCodexModelEntitlements` is awaited only for `ACCOUNT_GATED_NATIVE_OPENAI_MODELS`,
* which no longer holds the flagships. So the denial set is usually absent, the #4797
* ordering rules become the identity function, and the pool picks on quota alone (#4906).
* - 검토한 주요 대안: Fetch a roster on the flagship request path, lengthen the roster TTL, or
* infer availability from the account's plan name.
* - 선택한 방식: Record the exact upstream unsupported-model refusal per (account, model) and
* let selection read it alongside the roster.
* - 다른 대안 대신 이 방식을 선택한 이유: A roster fetch on the request path puts an
* authenticated upstream call in front of the most commonly requested models in the product,
* which is what the cache-only contract exists to prevent. A longer TTL keeps a shard's
* stale absence around for longer without adding any evidence. A plan name proves nothing
* about a grant -- `available_in_plans` for `gpt-6-astra` lists `free` while free accounts
* are refused -- and #3022 is what happened the last time availability was inferred rather
* than observed.
* - 장점, 단점 및 영향: A refusal is spent once and then remembered, so the pool stops
* re-sending a model to the account that just refused it. The evidence is confirmed rather
* than inferred, it is still only an ordering preference, and it is overridden by any
* positive roster grant for the same pair.
*
* What this deliberately is NOT: an eligibility filter. Readers treat these ids exactly like
* roster denials -- `withoutModelDeniedAccounts` restores them when filtering would empty the
* candidate list, and `preferModelEntitledAccount` leaves the active account alone when no
* entitled alternative exists. No model is hidden from any catalog and no request is refused
* before dispatch, so the 2026-09-04 owner decision that the flagships fail open is untouched.
*/
/**
* Six hours, against a five-minute roster TTL.
*
* The asymmetry is the point. A roster entry is a snapshot of an answer that may simply not
* have arrived yet, so it expires quickly and absence means "unknown". A refusal is an answer:
* upstream named this model and this account and said no. It still expires, because a rollout
* can reach an account between two requests, and the two faster paths back are a positive
* roster grant (which overrides this outright) and a successful response from the same account
* for the same model (which clears the entry).
*/
const OBSERVED_DENIAL_TTL_MS = 6 * 60 * 60_000;
/** Bounded like the roster cache: pool size times flagship count, with room to spare. */
const OBSERVED_DENIAL_MAX_ENTRIES = 512;
/**
* One entry of refusal evidence.
*
* `generation` is the credential generation the refusal was observed under (#4952). Evidence
* is about a CREDENTIAL, not an account id: reauthenticating the same internal account can
* swap the subscription underneath it, so a refusal from the previous credential says nothing
* about the replacement. Carrying the generation lets a reader ignore superseded evidence and
* lets a late reply from an older generation be refused rather than applied.
*
* It is OPTIONAL because not every account that can be refused has one. A `main-pool` context
* — the stored main login taking part in rotation — carries a real `accountId` and a
* `writerGeneration`, but no pool credential generation, because its credential lives in
* `auth.json` rather than the pool store. Dropping its evidence would have silently reverted
* #4906 for that account: the pool would re-send the same model to the login that just refused
* it, on every request, forever. An entry without a generation is account-scoped, and the
* generation fences below simply do not apply to it. This is the same rule the quota writer
* already uses in `core-codex-account.ts`, where an absent credential generation skips the
* liveness check instead of discarding the write.
*/
interface ObservedDenial {
expiresAt: number;
generation?: number;
}
/** `accountId\u0000modelId` -> entry. Insertion order is the eviction order. */
const observedDenials = new Map<string, ObservedDenial>();
/** Whether `generation` is still the account's live credential. */
type GenerationLiveCheck = (accountId: string, generation: number) => boolean;
/**
* Opens one liveness check.
*
* A FACTORY rather than a bare predicate because the production implementation reads the
* credential store, and a lookup can ask about several accounts. Loading once per lookup and
* closing over that snapshot is the shape `loadCodexAccountRecordSnapshot` exists for; a bare
* predicate would reload and reparse the whole store per row, on the request path.
*
* Injected rather than imported at module scope so this stays a leaf module: `account-store`
* reads the credential file, and a unit test of this map should not have to stand one up.
*/
type GenerationLiveCheckFactory = () => GenerationLiveCheck;
let beginGenerationLiveCheck: GenerationLiveCheckFactory = () => () => true;
/** Wire the liveness predicate. Called once at startup; tests substitute their own. */
export function setObservedDenialGenerationCheck(begin: GenerationLiveCheckFactory): void {
beginGenerationLiveCheck = begin;
}
function denialKey(accountId: string, modelId: string): string {
return `${accountId}\u0000${modelId}`;
}
function accountIdOfDenialKey(key: string): string {
return key.slice(0, key.indexOf("\u0000"));
}
function modelIdOfDenialKey(key: string): string {
return key.slice(key.indexOf("\u0000") + 1);
}
/**
* Remember that `accountId` was refused `modelId` by its own authenticated upstream.
*
* Re-recording refreshes the entry rather than extending an older one, so a pair that keeps
* being refused stays remembered and one that stops being refused ages out.
*/
export function recordObservedCodexModelDenial(
accountId: string,
modelId: string,
generation: number | undefined,
now = Date.now(),
): void {
// A refusal dispatched under generation G can arrive after G+1 has been saved. Reject it
// BEFORE touching the map at all, not merely when this key already holds newer evidence:
// with no entry for this key the stale row would otherwise be inserted, and at the entry
// bound it would evict a valid row that nothing can restore (#4952).
if (generation !== undefined && !beginGenerationLiveCheck()(accountId, generation)) return;
const key = denialKey(accountId, modelId);
const existing = observedDenials.get(key);
// Second fence, for the window where the replacement credential has been dispatched but the
// store read above still answers live. Both sides must name a generation to be comparable;
// an account-scoped entry is not older or newer than a credential-scoped one.
if (existing !== undefined && existing.generation !== undefined && generation !== undefined
&& existing.generation > generation) return;
// Delete before set so the refreshed entry moves to the back of the eviction order.
observedDenials.delete(key);
observedDenials.set(key, { expiresAt: now + OBSERVED_DENIAL_TTL_MS, generation });
while (observedDenials.size > OBSERVED_DENIAL_MAX_ENTRIES) {
const oldest = observedDenials.keys().next();
if (oldest.done) break;
observedDenials.delete(oldest.value);
}
}
/**
* Forget one pair, because the account just served the model.
*
* A success is newer and stronger evidence than the refusal that preceded it: whatever the
* entitlement was when upstream refused, it is not that now.
*/
export function clearObservedCodexModelDenial(
accountId: string,
modelId: string,
generation: number | undefined,
): void {
const key = denialKey(accountId, modelId);
const existing = observedDenials.get(key);
if (!existing) return;
// The mirror of the write fence: a success dispatched under G arriving after G+1 was
// refused must not clear the replacement's evidence (#4952). Equal generations clear,
// because that is the ordinary "this account just served this model" case.
if (existing.generation !== undefined && generation !== undefined
&& existing.generation > generation) return;
observedDenials.delete(key);
}
/**
* Forget every pair for one account, because its credential changed.
*
* A reauthenticated account can be a different subscription entirely, so evidence gathered
* under the previous credential says nothing about this one -- the same reasoning
* `invalidateCodexModelEntitlementsForAccount` applies to cached rosters.
*/
export function forgetObservedCodexModelDenialsForAccount(accountId: string | null | undefined): void {
if (!accountId) return;
for (const key of [...observedDenials.keys()]) {
if (accountIdOfDenialKey(key) === accountId) observedDenials.delete(key);
}
}
/**
* Accounts refused `modelId` within the retention window.
*
* Returns `undefined` rather than an empty set when nothing is recorded, matching
* `cachedDeniedCodexAccountIdsForModel`: a caller must not be able to read "no evidence" as
* "nobody is denied".
*/
export function observedDeniedCodexAccountIdsForModel(
modelId: string | undefined,
now = Date.now(),
options: { excludeAccountIds?: ReadonlySet<string> } = {},
): ReadonlySet<string> | undefined {
if (!modelId) return undefined;
const denied = new Set<string>();
// Opened lazily and at most once: a lookup that matches no credential-scoped row must not
// read the credential store at all.
let isLive: GenerationLiveCheck | undefined;
for (const [key, entry] of [...observedDenials]) {
if (entry.expiresAt <= now) {
observedDenials.delete(key);
continue;
}
// Model and the caller's exclusion fence FIRST. The issue asks for identity validation
// after the exclusion read, and an excluded account — a draining profile switch, or a
// request-owned credential — must produce no credential-store read on its behalf.
if (modelIdOfDenialKey(key) !== modelId) continue;
const accountId = accountIdOfDenialKey(key);
if (options.excludeAccountIds?.has(accountId)) continue;
if (entry.generation !== undefined) {
isLive ??= beginGenerationLiveCheck();
// Superseded evidence stops denying the replacement. It is SKIPPED, not deleted: the
// predicate cannot tell "this account reauthenticated" from "the credential store could
// not be read", and deleting on the second would throw away valid evidence that a
// transient read failure was never entitled to touch. Skipping already delivers the
// routing outcome the issue asks for, on every read, without depending on the
// conditional account-wide forget that cannot run when no roster was ever cached.
// Superseded rows still leave by TTL, by eviction, and by the account-wide forget.
if (!isLive(accountId, entry.generation)) continue;
}
denied.add(accountId);
}
return denied.size > 0 ? denied : undefined;
}
export function resetObservedCodexModelDenialsForTests(): void {
observedDenials.clear();
beginGenerationLiveCheck = () => () => true;
}