@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
296 lines (276 loc) • 16.2 kB
text/typescript
import { boundDecisionWindows, publishAnthropicDecisionQuota } from "../quota-decision-publication";
import { decisionQuotaSinkActive, publishDecisionAccountQuota } from "../../lib/decision-quota-sink";
import { mergeAnthropicFamilyWindows, hasAnthropicFamilyEnumeration } from "./anthropic-family-headers";
import { getCachedProviderAccountQuota, captureProviderAccountQuotaEpoch, type AccountQuotaCacheEntry } from "./account-cache";
import { anthropicModelQuotaFor } from "../../oauth/anthropic-model-quota";
import type { AnthropicInstanceId } from "../anthropic-instance-id";
import type { GenerationContext } from "../../lib/state-store-sweeper";
import { anthropicCredentialEvidenceKey, credentialGeneration, getAccountCredentialWithStatus, getAccountSet } from "../../oauth/store";
import type { ProviderQuota } from "../quota-types";
import type { AnthropicUsageProbe } from "../claude-cli-usage";
export class AnthropicQuotaProbeOwnershipError extends Error {}
export type AnthropicCooldownRecoveryProbe = Readonly<{
instance: AnthropicInstanceId;
generation: string;
credentialKey: string;
requiresFreshDispatch: boolean;
isCurrentCredential(): boolean;
isCurrentFamily(): boolean;
isCurrent(): boolean;
settle(quota: ProviderQuota): "cleared" | "retained" | "superseded";
}>;
export type AnthropicQuotaRecoveryResult = Readonly<{
instance: AnthropicInstanceId;
credentialKey: string;
/** Null only when the response retires the monthly fallback without supplying meters. */
quota: ProviderQuota | null;
/** Account cache diagnostics for a retirement-only response. */
failureFields?: Pick<AccountQuotaCacheEntry, "unavailable" | "quotaFailure" | "quotaFailureIsCurrent">;
dispatch?: number;
/** Publishes secret-free advisory evidence for the primary pool only; a no-op for Pool 2. */
publishDecisionQuota(): void;
/** Must be checked synchronously at each publication boundary. */
isCurrent(): boolean;
}>;
export type DispatchedAnthropicUsageProbe = AnthropicUsageProbe & {
dispatch: number;
isQuotaDispatchCurrent(accountId: string): boolean;
};
/** Create the cooldown-recovery probe owner for one Anthropic instance; its results are credential- and generation-bound before they may publish. */
function createAnthropicCooldownRecovery(instance: AnthropicInstanceId) {
const familyGeneration = (accountId: string) => anthropicModelQuotaFor(instance).anthropicFamilyQuotaGeneration(accountId);
/** Check live pause and bearer ownership at the last synchronous step before usage dispatch. */
function assertAnthropicQuotaSendAllowed(accountId: string, token: string): void {
const row = getAccountCredentialWithStatus(instance, accountId);
if (!row || row.paused || row.needsReauth || row.credential.access !== token) {
throw new AnthropicQuotaProbeOwnershipError(`${instance} quota account is no longer eligible`);
}
}
let cooldownGenerationByAccount: Map<string, number> | undefined;
let emptyGeneration = 0;
let nextCooldownGeneration = 1;
// Account lifetime is distinct from refusal/probe mutations; a valid refusal must not revoke itself.
let accountIncarnations: Map<string, number> | undefined;
let emptyAccountIncarnation = 0;
let nextAccountIncarnation = 1;
let afterSettlementForTests: (() => void) | undefined;
function setAnthropicQuotaAfterSettlementForTests(hook: (() => void) | undefined): void {
afterSettlementForTests = hook;
}
/** Monotonic per-account fence shared by routing mutations and quota publication. */
function anthropicCooldownGeneration(accountId: string): number {
return cooldownGenerationByAccount?.get(accountId) ?? emptyGeneration;
}
/** Keep same-state quota calls joinable while moving post-429 calls to a fresh flight. */
function anthropicCooldownFlightKey(baseKey: string, accountId: string): string {
// Flight reservation establishes an incarnation even without prior refusal evidence.
const generation = reserveCooldownGeneration(accountId);
return `${baseKey}\0${instance}-cooldown:${generation}`;
}
/** Active usage readers bind this key after token refresh; renewal keeps the legacy flight valid. */
function anthropicCredentialQuotaFlightKey(baseKey: string, accountId: string): string {
const row = getAccountSet(instance)?.accounts.find(row => row.id === accountId);
return `${anthropicCooldownFlightKey(baseKey, accountId)}\0${row ? anthropicCredentialEvidenceKey(row) : "missing"}`;
}
function reserveCooldownGeneration(accountId: string): number {
return cooldownGenerationByAccount?.get(accountId) ?? noteAnthropicCooldownMutation(accountId);
}
function noteAnthropicCooldownMutation(accountId: string): number {
const generation = nextCooldownGeneration++;
(cooldownGenerationByAccount ??= new Map()).set(accountId, generation);
return generation;
}
function anthropicAccountIncarnation(accountId: string): number {
return accountIncarnations?.get(accountId) ?? emptyAccountIncarnation;
}
function reserveAnthropicAccountIncarnation(accountId: string): number {
const existing = accountIncarnations?.get(accountId);
if (existing !== undefined) return existing;
const incarnation = nextAccountIncarnation++;
(accountIncarnations ??= new Map()).set(accountId, incarnation);
return incarnation;
}
function clearAnthropicCooldownGenerations(): void {
emptyGeneration = nextCooldownGeneration++;
cooldownGenerationByAccount = undefined;
emptyAccountIncarnation = nextAccountIncarnation++;
accountIncarnations = undefined;
}
/**
* Bind a quota probe to both the credential and cooldown generations it observed before
* dispatch. A successful response may otherwise arrive after either credential replacement
* or a newer 429 and incorrectly make unrelated state eligible.
*/
async function captureAnthropicCooldownRecoveryProbe(
accountId: string,
accessToken: string,
): Promise<AnthropicCooldownRecoveryProbe | null> {
const initialRow = getAccountSet(instance)?.accounts.find(row => row.id === accountId);
if (!initialRow || initialRow.paused || initialRow.needsReauth || initialRow.credential.access !== accessToken) return null;
const generation = credentialGeneration(initialRow.credential);
const credentialKey = anthropicCredentialEvidenceKey(initialRow);
const incarnation = reserveAnthropicAccountIncarnation(accountId);
const quotaEpoch = captureProviderAccountQuotaEpoch(instance);
const isCurrentCredential = () => {
const current = getAccountSet(instance)?.accounts.find(row => row.id === accountId);
return quotaEpoch === captureProviderAccountQuotaEpoch(instance)
&& anthropicAccountIncarnation(accountId) === incarnation
&& !!current && anthropicCredentialEvidenceKey(current) === credentialKey;
};
// Lazy because anthropic-routing reads the quota cache on normal request routing.
const { anthropicRoutingFor } = await import("../../oauth/anthropic-routing");
const routing = anthropicRoutingFor(instance);
if (!isCurrentCredential()) return null;
const cooldownGeneration = reserveCooldownGeneration(accountId);
const capturedFamilyGeneration = anthropicModelQuotaFor(instance).captureAnthropicFamilyQuotaGeneration(accountId);
const claim = routing.captureAnthropicCooldownRecovery(accountId);
return {
instance,
generation,
credentialKey,
requiresFreshDispatch: claim !== null,
isCurrentCredential,
isCurrentFamily: () => familyGeneration(accountId) === capturedFamilyGeneration,
isCurrent: () => isCurrentCredential()
&& anthropicCooldownGeneration(accountId) === cooldownGeneration,
settle: quota => !isCurrentCredential() || anthropicCooldownGeneration(accountId) !== cooldownGeneration ? "superseded"
: claim === null ? "retained" : routing.settleAnthropicCooldownRecovery(claim, quota),
};
}
/** Run one authoritative usage read and publish its recovery effect only while still owned. */
async function probeAnthropicQuotaWithRecovery(
accountId: string,
accessToken: string,
read: (requireFreshDispatch: boolean) => Promise<DispatchedAnthropicUsageProbe | ProviderQuota | null>,
mayPublish: () => boolean,
): Promise<AnthropicQuotaRecoveryResult | null> {
const probe = await captureAnthropicCooldownRecoveryProbe(accountId, accessToken);
if (!probe) throw new AnthropicQuotaProbeOwnershipError(`${instance} quota probe lost credential ownership`);
if (!probe.isCurrent() || !mayPublish()) throw new AnthropicQuotaProbeOwnershipError(`${instance} quota probe lost dispatch ownership`);
let readResult: DispatchedAnthropicUsageProbe | ProviderQuota | null;
try { readResult = await read(probe.requiresFreshDispatch); }
catch (error) {
if (!probe.isCurrent() || !mayPublish()) throw new AnthropicQuotaProbeOwnershipError(`${instance} quota probe failure is stale`);
throw error;
}
const observation = readResult && "quota" in readResult ? readResult : undefined;
let quota = readResult && "quota" in readResult ? readResult.quota : readResult;
const monthlyFallback = quota?.monthlyPercent !== undefined;
const observationCurrent = () => mayPublish() && observation?.isQuotaDispatchCurrent(accountId) !== false;
if (!probe.isCurrent() || !observationCurrent()) {
throw new AnthropicQuotaProbeOwnershipError(`${instance} quota probe result is stale`);
}
if (!quota) {
if (!observation?.retireMonthlyFallback) return null;
const isCurrent = () => probe.isCurrent() && observationCurrent();
return {
instance, credentialKey: probe.credentialKey, quota: null, dispatch: observation.dispatch, isCurrent,
failureFields: {
unavailable: true,
...(observation.failure ? { quotaFailure: observation.failure, quotaFailureIsCurrent: isCurrent } : {}),
},
publishDecisionQuota: () => {
if (instance === "anthropic" && decisionQuotaSinkActive() && isCurrent()) {
publishAnthropicDecisionQuota(accountId, probe.generation, null, true);
}
},
};
}
const settlement = probe.settle(quota);
if (settlement === "superseded") {
throw new AnthropicQuotaProbeOwnershipError(`${instance} quota probe lost cooldown ownership`);
}
// Clearing the claimed cooldown intentionally advances the fence. Adopt that exact new
// generation; any later observation/429 then invalidates publication before a cache write.
const rawQuota = quota;
const ownsFamily = probe.isCurrentFamily();
const authoritative = ownsFamily && hasAnthropicFamilyEnumeration(quota);
if (ownsFamily) anthropicModelQuotaFor(instance).observeAnthropicFamilyQuota(accountId, quota.customWindows ?? [], quota.updatedAt, authoritative);
if (!authoritative && !monthlyFallback) {
const cached = getCachedProviderAccountQuota(instance, accountId)?.customWindows;
const windows = ownsFamily ? mergeAnthropicFamilyWindows(cached, quota.customWindows)
: cached ?? [];
// A superseded family enumeration has no authority, including over absent families.
if (!ownsFamily || windows.length) quota = { ...quota, customWindows: windows };
}
const publicationGeneration = anthropicCooldownGeneration(accountId);
const publicationFamilyGeneration = familyGeneration(accountId);
/** True while the probed credential, cooldown generation and family generation are unchanged and publication is still permitted. */
const isCurrent = () => probe.isCurrentCredential()
&& anthropicCooldownGeneration(accountId) === publicationGeneration
&& familyGeneration(accountId) === publicationFamilyGeneration
&& observationCurrent();
afterSettlementForTests?.();
return {
instance,
credentialKey: probe.credentialKey,
quota,
dispatch: observation?.dispatch,
isCurrent,
publishDecisionQuota: () => {
// Activation first: ownership validation reads the auth store and must not run for signals-off installs.
if (instance !== "anthropic" || !decisionQuotaSinkActive() || !isCurrent()) return;
// An unbound probe result was parsed while inactive: unknown, never display fallback.
const windows = boundDecisionWindows(rawQuota);
if (windows) publishDecisionAccountQuota("anthropic", accountId, probe.generation,
windows.filter(row => ownsFamily || ["5h", "weekly", "monthly"].includes(row.window)), !authoritative);
},
};
}
function reconcileAnthropicCooldownGenerations(context: GenerationContext): number {
// Probe reservations include accounts with no cooldown, so every claim retires here.
for (const id of cooldownGenerationByAccount?.keys() ?? []) {
if (!context.oauthAccountKeys.has(`${instance}\0${id}`)) noteAnthropicCooldownMutation(id);
}
for (const id of accountIncarnations?.keys() ?? []) {
if (!context.oauthAccountKeys.has(`${instance}\0${id}`)) accountIncarnations!.set(id, nextAccountIncarnation++);
}
return 0; // Tombstones are retained, never reclaimed into an older generation.
}
return Object.freeze({ instance, assertAnthropicQuotaSendAllowed, setAnthropicQuotaAfterSettlementForTests,
anthropicCooldownGeneration, anthropicCooldownFlightKey, anthropicCredentialQuotaFlightKey, noteAnthropicCooldownMutation,
anthropicAccountIncarnation, reserveAnthropicAccountIncarnation,
clearAnthropicCooldownGenerations, captureAnthropicCooldownRecoveryProbe,
probeAnthropicQuotaWithRecovery, reconcileAnthropicCooldownGenerations });
}
export type AnthropicCooldownRecovery = ReturnType<typeof createAnthropicCooldownRecovery>;
const instances = new Map<AnthropicInstanceId, AnthropicCooldownRecovery>();
export function anthropicCooldownRecoveryFor(instance: AnthropicInstanceId): AnthropicCooldownRecovery {
let facade = instances.get(instance);
if (!facade) { facade = createAnthropicCooldownRecovery(instance); instances.set(instance, facade); }
return facade;
}
export function reconcileAllAnthropicCooldownGenerations(context: GenerationContext): number {
for (const facade of instances.values()) facade.reconcileAnthropicCooldownGenerations(context);
return 0;
}
export function clearAllAnthropicCooldownGenerations(): void {
for (const facade of instances.values()) facade.clearAnthropicCooldownGenerations();
}
export function assertAnthropicQuotaSendAllowed(accountId: string, token: string): void {
anthropicCooldownRecoveryFor("anthropic").assertAnthropicQuotaSendAllowed(accountId, token);
}
export function setAnthropicQuotaAfterSettlementForTests(hook: (() => void) | undefined): void {
anthropicCooldownRecoveryFor("anthropic").setAnthropicQuotaAfterSettlementForTests(hook);
}
export function anthropicCooldownGeneration(accountId: string): number {
return anthropicCooldownRecoveryFor("anthropic").anthropicCooldownGeneration(accountId);
}
export function anthropicCooldownFlightKey(baseKey: string, accountId: string): string {
return anthropicCooldownRecoveryFor("anthropic").anthropicCooldownFlightKey(baseKey, accountId);
}
export function noteAnthropicCooldownMutation(accountId: string): number {
return anthropicCooldownRecoveryFor("anthropic").noteAnthropicCooldownMutation(accountId);
}
export function clearAnthropicCooldownGenerations(): void {
anthropicCooldownRecoveryFor("anthropic").clearAnthropicCooldownGenerations();
}
export function captureAnthropicCooldownRecoveryProbe(accountId: string, accessToken: string): Promise<AnthropicCooldownRecoveryProbe | null> {
return anthropicCooldownRecoveryFor("anthropic").captureAnthropicCooldownRecoveryProbe(accountId, accessToken);
}
export function probeAnthropicQuotaWithRecovery(
accountId: string, accessToken: string,
read: (requireFreshDispatch: boolean) => Promise<ProviderQuota | null>, mayPublish: () => boolean,
): Promise<AnthropicQuotaRecoveryResult | null> {
return anthropicCooldownRecoveryFor("anthropic").probeAnthropicQuotaWithRecovery(accountId, accessToken, read, mayPublish);
}