@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
498 lines (466 loc) • 24.4 kB
text/typescript
import { createHash } from "node:crypto";
import { getValidAccessTokenForAccount } from "../../oauth";
import { getAccountCredential, getAccountCredentialWithStatus, getAccountSet } from "../../oauth/store";
import type { GenerationContext } from "../../lib/state-store-sweeper";
import { ACCOUNT_QUOTA_TTL_MS, toFiniteNumber } from "../quota-wire";
import { clearKiroAccountUsageState, hydrateKiroUsageVerdict, kiroPersistableVerdicts, reconcileKiroAccountUsageState } from "../kiro-usage";
import { kiroEvidenceIdentity, sanitizeKiroQuota, type KiroPersistedQuota } from "../kiro-account-state-disk";
import { cancelPendingAccountQuotaPersist, readPersistedAccountQuotas, readPersistedKiroVerdicts, schedulePersistAccountQuotas } from "../account-quota-disk";
import type { ProviderAccount } from "../../oauth/types";
import { replaceCachedProviderQuotas } from "../quota-routing-cache";
import { getProviderRegistryEntry } from "../registry";
import { getProviderQuotaReportCache, hasQuotaRows, routingEvidence, setProviderQuotaReportCache } from "./report-cache";
import { isCanonicalCommandCodeBaseUrl, isCanonicalKimiCodeBaseUrl } from "./vendor-probes-key";
import type { AccountQuotaMode, ProviderQuota, ProviderQuotaWindow, QuotaFailureCode } from "../quota-types";
import type { OcxConfig, OcxProviderConfig } from "../../types";
/** Match oauth/index REFRESH_SKEW_MS — use stored access without refresh when still fresh. */
const ACCOUNT_TOKEN_SKEW_MS = 60_000;
/**
* Anthropic and Kiro both report usage per CREDENTIAL, so every logged-in account can be
* probed with its own bearer token — the active-account selection and the local usage log
* are irrelevant here. Mirrors the Codex pool behaviour
* (codex/auth-api.ts:fetchPoolAccountQuota), including a per-account TTL so N accounts cost
* at most N upstream calls per window. `ACCOUNT_QUOTA_TTL_MS` lives in `quota-wire.ts`
* because the Kiro exhaustion reader applies the same staleness bound.
*/
export type AccountQuotaCacheEntry = {
ts: number;
quota: ProviderQuota | null;
/** Last probe failed (429 / network / expired login); still may hold last-good quota. */
unavailable?: true;
quotaFailure?: QuotaFailureCode;
quotaFailureIsCurrent?: () => boolean;
/** Private new-reader identity; never persisted or serialized. */
identity?: string;
isCurrent?: () => boolean;
};
/** Expired measurements become unknown; missing reset evidence never implies a fresh allowance. */
export function normalizeAnthropicQuota(quota: ProviderQuota | null | undefined, now: number): ProviderQuota | null {
if (!quota) return null;
const validReset = (resetAt: unknown): resetAt is number => typeof resetAt === "number"
&& Number.isFinite(resetAt) && resetAt > 0 && Number.isFinite(new Date(resetAt).getTime());
let result = quota;
for (const [percent, reset] of [
["fiveHourPercent", "fiveHourResetAt"],
["weeklyPercent", "weeklyResetAt"],
["monthlyPercent", "monthlyResetAt"],
] as const) {
const resetAt = quota[reset];
if (resetAt === undefined) continue;
const valid = validReset(resetAt);
if (valid && resetAt > now) continue;
if (result === quota) result = { ...quota };
if (valid) delete result[percent];
delete result[reset];
}
// Persisted rows validate only the outer quota object, so custom data may be malformed.
if (quota.customWindows !== undefined) {
const windows = Array.isArray(quota.customWindows) ? quota.customWindows : [];
const retained: ProviderQuotaWindow[] = [];
let changed = !Array.isArray(quota.customWindows);
for (const window of windows) {
if (!window || typeof window !== "object" || typeof window.label !== "string" || !window.label.trim()
|| typeof window.percent !== "number" || !Number.isFinite(window.percent)
|| window.percent < 0 || window.percent > 100) {
changed = true;
continue;
}
if (validReset(window.resetAt) && window.resetAt <= now) {
changed = true;
continue;
}
if (window.resetAt !== undefined && !validReset(window.resetAt)) {
const normalized = { ...window };
delete normalized.resetAt;
retained.push(normalized);
changed = true;
} else {
retained.push(window);
}
}
if (changed) {
if (result === quota) result = { ...quota };
if (retained.length) result.customWindows = retained;
else delete result.customWindows;
}
}
return hasQuotaRows(result) ? result : null;
}
export const accountQuotaCache = new Map<string, AccountQuotaCacheEntry>();
export let explicitAccountEpoch = 0;
/**
* Seed the cache from the last run, once.
*
* Without this a restart forgets every measurement, so the pool opens its next turn with
* no idea which account has room — the exact blindness pre-dispatch selection exists to
* remove. A hydrated row is still subject to the ordinary TTL, so it orders the first
* request and is replaced by a live probe immediately after.
*/
let diskHydrated = false;
export function hydrateAccountQuotaCache(): void {
if (diskHydrated) return;
diskHydrated = true;
const now = Date.now();
const liveKiro = new Map<string, ProviderAccount>(getAccountSet("kiro")?.accounts.map(account =>
[accountCacheKey("kiro", account.id), account]) ?? []);
for (const [key, quota] of readPersistedAccountQuotas(now)) {
if (key.startsWith("kiro\0")) {
const account = liveKiro.get(key);
if (!account || (quota as KiroPersistedQuota).identity !== kiroEvidenceIdentity(account)
|| typeof quota.monthlyPercent !== "number" || !Number.isFinite(quota.monthlyPercent)
|| quota.monthlyPercent < 0 || quota.monthlyPercent > 100
|| now - quota.updatedAt >= ACCOUNT_QUOTA_TTL_MS
|| (quota.monthlyResetAt !== undefined && (typeof quota.monthlyResetAt !== "number"
|| !Number.isFinite(quota.monthlyResetAt) || quota.monthlyResetAt <= now
|| !Number.isFinite(new Date(quota.monthlyResetAt).getTime())))) continue;
}
// Disk stores observation time, not the Anthropic usage probe's clock.
if (!accountQuotaCache.has(key)) {
const anthropic = key.startsWith("anthropic\u0000");
accountQuotaCache.set(key, {
ts: anthropic ? 0 : quota.updatedAt,
quota: anthropic ? normalizeAnthropicQuota(quota, now)
: key.startsWith("kiro\0") ? sanitizeKiroQuota(quota) : quota,
...(key.startsWith("kiro\0") ? { identity: (quota as KiroPersistedQuota).identity } : {}),
});
}
}
for (const [key, verdict] of readPersistedKiroVerdicts(now)) {
const account = liveKiro.get(key);
if (account && verdict.identity === kiroEvidenceIdentity(account)) hydrateKiroUsageVerdict(key, verdict, account);
}
}
export function persistAccountQuotaCache(): void {
schedulePersistAccountQuotas(function* () {
const now = Date.now();
const liveKiro = new Map<string, ProviderAccount>(getAccountSet("kiro")?.accounts.map(account =>
[accountCacheKey("kiro", account.id), account]) ?? []);
for (const [key, entry] of accountQuotaCache) {
const quota = key.startsWith("anthropic\u0000") ? normalizeAnthropicQuota(entry.quota, now) : entry.quota;
if (quota && key.startsWith("kiro\0")) {
const account = liveKiro.get(key);
if (account && entry.identity === kiroEvidenceIdentity(account))
yield [key, { ...sanitizeKiroQuota(quota), identity: entry.identity } as KiroPersistedQuota] as [string, KiroPersistedQuota];
} else if (quota) yield [key, quota] as [string, ProviderQuota];
}
}, () => kiroPersistableVerdicts());
}
export const accountQuotaInflight = new Map<string, Promise<AccountQuotaCacheEntry>>();
let lastReconciledGeneration = 0;
let liveAccountQuotaKeys = new Set<string>();
let liveProviderQuotaKeys = new Set<string>();
export function mayCommitAccountQuotaKey(key: string, writerGeneration: number): boolean {
return writerGeneration >= lastReconciledGeneration || liveAccountQuotaKeys.has(key);
}
export function mayCommitProviderQuotaKey(key: string, writerGeneration: number): boolean {
return writerGeneration >= lastReconciledGeneration || liveProviderQuotaKeys.has(key);
}
export interface ProviderAccountQuota {
accountId: string;
quota: ProviderQuota | null;
/** Set when the probe could not reach upstream (expired login, 429, network). */
unavailable?: true;
quotaFailure?: QuotaFailureCode;
quotaFailureIsCurrent?: () => boolean;
isCurrent?: () => boolean;
}
/** Providers whose per-account quota can be probed. Extend as other OAuth APIs are covered. */
export function supportsPerAccountQuota(provider: string): boolean {
return provider === "anthropic" || provider === "kiro" || provider === "google-antigravity"
|| explicitAccountReader(provider);
}
export function explicitAccountReader(provider: string): boolean {
return provider === "xai" || provider === "cursor" || provider === "kimi" || provider === "command-code"
|| provider === "devin";
}
export function providerOAuthAccountQuotaMode(provider: string): AccountQuotaMode {
return hasPassiveAccountQuota(provider) ? "passive" : supportsPerAccountQuota(provider) ? "probe" : "unsupported";
}
export function accountCacheKey(provider: string, accountId: string): string {
return `${provider}\u0000${accountId}`;
}
/**
* Synchronous last-good per-account quota read for routing. Never probes the network.
* Returns null when nothing is cached (or the cached row has no bars).
*/
export function getCachedProviderAccountQuota(provider: string, accountId: string): ProviderQuota | null {
const entry = accountQuotaCache.get(accountCacheKey(provider, accountId));
if (provider === "kiro") {
const account = getAccountSet("kiro")?.accounts.find(row => row.id === accountId);
if (!account || entry?.identity !== kiroEvidenceIdentity(account)) return null;
}
if (entry?.isCurrent && !entry.isCurrent()) return null;
return provider === "anthropic" ? normalizeAnthropicQuota(entry?.quota, Date.now()) : entry?.quota ?? null;
}
/** Test-only: seed or clear the per-account quota cache without probing upstream. */
export function setCachedProviderAccountQuotaForTests(
provider: string,
accountId: string,
quota: ProviderQuota | null,
): void {
const key = accountCacheKey(provider, accountId);
if (quota === null) {
accountQuotaCache.delete(key);
return;
}
const account = provider === "kiro" ? getAccountSet("kiro")?.accounts.find(row => row.id === accountId) : undefined;
accountQuotaCache.set(key, { ts: Date.now(), quota,
...(account ? { identity: kiroEvidenceIdentity(account) } : {}) });
}
/** Unified headers report utilization fractions and epoch-second reset times. */
function anthropicHeaderResetAt(value: string | null): number | undefined {
const seconds = toFiniteNumber(value);
if (seconds === undefined || seconds <= 0) return undefined;
const timestamp = seconds * 1000;
return Number.isFinite(new Date(timestamp).getTime()) ? timestamp : undefined;
}
export function parseAnthropicRateLimitHeaders(headers: Headers): ProviderQuota | null {
const fiveHourPercent = normalizeUtilizationFraction(headers.get("anthropic-ratelimit-unified-5h-utilization"));
const weeklyPercent = normalizeUtilizationFraction(headers.get("anthropic-ratelimit-unified-7d-utilization"));
if (fiveHourPercent === undefined && weeklyPercent === undefined) return null;
const fiveHourResetAt = anthropicHeaderResetAt(headers.get("anthropic-ratelimit-unified-5h-reset"));
const weeklyResetAt = anthropicHeaderResetAt(headers.get("anthropic-ratelimit-unified-7d-reset"));
return {
...(fiveHourPercent !== undefined ? { fiveHourPercent } : {}),
...(fiveHourPercent !== undefined && fiveHourResetAt !== undefined ? { fiveHourResetAt } : {}),
...(weeklyPercent !== undefined ? { weeklyPercent } : {}),
...(weeklyPercent !== undefined && weeklyResetAt !== undefined ? { weeklyResetAt } : {}),
updatedAt: Date.now(),
};
}
/** Reject unknown scales; round fraction conversion for persisted/displayed percentages. */
function normalizeUtilizationFraction(value: string | null): number | undefined {
const numeric = toFiniteNumber(value);
if (numeric === undefined || numeric < 0 || numeric > 1) return undefined;
return Math.round(numeric * 10_000) / 100;
}
/**
* Merge serving-account observations without advancing the usage probe's clock or
* erasing model-specific windows. The caller owns credential attribution; this guard
* prevents a retired account key from being revived by an older config generation.
*/
export function recordAnthropicAccountQuotaFromHeaders(
accountId: string,
headers: Headers,
writerGeneration: number,
): void {
if (!accountId) return;
const observed = parseAnthropicRateLimitHeaders(headers);
if (!observed) return;
const key = accountCacheKey("anthropic", accountId);
if (!mayCommitAccountQuotaKey(key, writerGeneration)) return;
// Hydrate before writing, for the same reason `recordPassiveAccountQuota` does: this write
// arrives unprompted from the request path, and `persistAccountQuotaCache` serializes the
// whole map. Landing before any reader has hydrated would persist this single row and erase
// every other provider's saved row.
hydrateAccountQuotaCache();
const candidate = accountQuotaCache.get(key);
const previous = candidate?.isCurrent?.() === false ? undefined : candidate;
accountQuotaCache.set(key, {
...previous,
// Headers do not prove that the last usage probe succeeded.
ts: previous?.ts ?? 0,
quota: normalizeAnthropicQuota({
...normalizeAnthropicQuota(previous?.quota, observed.updatedAt), ...observed,
}, observed.updatedAt),
});
persistAccountQuotaCache();
}
/**
* Providers whose per-account quota is OBSERVED in-band, never probed.
*
* Deliberately separate from `supportsPerAccountQuota` rather than folded into it. That
* predicate gates explicit upstream readers. Meta publishes no quota endpoint, so it
* remains a cache-only observation even when every probe reader is account-scoped.
*/
export function hasPassiveAccountQuota(provider: string): boolean {
return provider === "meta-muse";
}
/**
* Record a quota observed in-band on a streaming turn.
*
* The CALLER captures `writerGeneration` when it resolves the serving credential, not
* this function at write time. A streaming turn is a long await, and a generation
* captured immediately before the write cannot see a config or account change that
* happened EARLIER in the same turn — which is exactly the case the fence exists for.
*/
export function recordPassiveAccountQuota(
provider: string,
accountId: string,
quota: ProviderQuota,
writerGeneration: number,
): void {
if (!hasPassiveAccountQuota(provider) || !accountId) return;
const key = accountCacheKey(provider, accountId);
if (!mayCommitAccountQuotaKey(key, writerGeneration)) return;
// Hydrate BEFORE writing, not only on the read path. `persistAccountQuotaCache`
// serializes the whole in-memory map, so a passive write that lands before anything
// has read the cache would persist this one row and erase every other provider's
// saved row -- and `diskHydrated` would then stop any later reader from recovering
// them. A probe writer cannot hit this because its own read hydrates first; an
// observation arrives unprompted, so it must hydrate itself.
hydrateAccountQuotaCache();
accountQuotaCache.set(key, { ts: Date.now(), quota });
// Persisted so a restart keeps the last observation: with no probe to re-establish it,
// a forgotten row stays forgotten until the user happens to run another streaming turn.
persistAccountQuotaCache();
// sweepExpiredOnWrite is deliberately NOT called. Existing probe writers call it
// because they run on a poll; this runs on the request path, where a state sweep does
// not belong. Passive rows are still reclaimed by generation reconciliation
// (reconcileProviderAccountQuotaRows) and by the disk reader's age bound.
}
/**
* Cache-only per-account rows for a passive provider. Never probes, never refreshes.
*
* An account with no observation is OMITTED rather than returned with `quota: null` and
* `unavailable`: that pair means "a probe was attempted and failed", and no probe was
* ever attempted here. A user who has not yet run a streaming turn simply has no
* measurement, which is not an error state.
*/
export function readPassiveProviderAccountQuotas(provider: string): ProviderAccountQuota[] {
if (!hasPassiveAccountQuota(provider)) return [];
// Idempotent, and otherwise only reached from probe paths a passive provider never
// enters — without it a restart shows nothing until the next streaming turn, even
// though the row is sitting on disk.
hydrateAccountQuotaCache();
const set = getAccountSet(provider);
if (!set) return [];
const rows: ProviderAccountQuota[] = [];
for (const account of set.accounts) {
const entry = accountQuotaCache.get(accountCacheKey(provider, account.id));
if (entry?.quota) rows.push({ accountId: account.id, quota: entry.quota });
}
return rows;
}
export function sweepExpiredProviderAccountQuotaRows(now = Date.now()): number {
let removed = 0;
for (const [key, entry] of accountQuotaCache) {
// Anthropic observations extend retention, never the usage probe's eligibility clock.
const retainedAt = key.startsWith("anthropic\u0000")
? Math.max(entry.ts, entry.quota?.updatedAt ?? 0)
: entry.ts;
if (retainedAt + ACCOUNT_QUOTA_TTL_MS > now) continue;
accountQuotaCache.delete(key);
removed += 1;
}
return removed;
}
export function reconcileProviderAccountQuotaRows(context: GenerationContext): number {
if (context.generation <= lastReconciledGeneration) return 0;
hydrateAccountQuotaCache();
let removed = 0;
for (const key of accountQuotaCache.keys()) {
if (context.oauthAccountKeys.has(key)) continue;
accountQuotaCache.delete(key);
removed += 1;
}
// Kiro exhaustion rows are keyed identically, so they retire with their quota row; a
// verdict outliving its account would hand the replacement a cooldown it never earned.
removed += reconcileKiroAccountUsageState(context.oauthAccountKeys);
const cachedReports = getProviderQuotaReportCache();
if (cachedReports) {
const reports = cachedReports.response.reports.filter(report => context.providerNames.has(report.provider));
removed += cachedReports.response.reports.length - reports.length;
setProviderQuotaReportCache({ ...cachedReports, response: { ...cachedReports.response, reports } });
replaceCachedProviderQuotas(reports, routingEvidence);
}
liveAccountQuotaKeys = new Set(context.oauthAccountKeys);
liveProviderQuotaKeys = new Set(context.providerNames);
lastReconciledGeneration = context.generation;
if (removed > 0) persistAccountQuotaCache();
return removed;
}
/** Test-only reset so a direct reconcile call in one file cannot leak across files. */
export function resetProviderQuotaReconcileStateForTests(): void {
lastReconciledGeneration = 0;
liveAccountQuotaKeys = new Set();
liveProviderQuotaKeys = new Set();
}
/** Drop cached per-account rows (all, or just one provider's). */
export function clearAccountQuotaCache(provider?: string): void {
explicitAccountEpoch += 1;
if (!provider) {
accountQuotaCache.clear();
accountQuotaInflight.clear();
clearKiroAccountUsageState();
// A cleared cache must not be re-seeded from the file it was just cleared of, and any
// pending write of the old rows is abandoned.
diskHydrated = false;
cancelPendingAccountQuotaPersist();
return;
}
hydrateAccountQuotaCache();
const prefix = `${provider}\u0000`;
for (const key of [...accountQuotaCache.keys()]) {
if (key.startsWith(prefix)) accountQuotaCache.delete(key);
}
clearKiroAccountUsageState(prefix);
// Drop in-flight probes too so a late resolve cannot repopulate after logout/remove.
for (const key of [...accountQuotaInflight.keys()]) {
if (key.startsWith(prefix)) accountQuotaInflight.delete(key);
}
persistAccountQuotaCache();
}
/**
* Resolve a bearer for quota probing without silently adopting a newer global
* Claude CLI credential into a background multiauth slot.
*
* - Fresh stored access → use as-is (no refresh).
* - Active account with expired access → normal refresh path.
* - Background `local-cli` with expired access → fail closed (unavailable):
* `getValidAccessTokenForAccount` can persist a mismatched Claude CLI identity.
* - Background ordinary OAuth (`source !== "local-cli"`) → safe to refresh;
* Anthropic's lock only adopts disk credentials for `local-cli` rows.
*/
export async function getTokenForAccountQuotaProbe(provider: string, accountId: string): Promise<string> {
const row = getAccountCredentialWithStatus(provider, accountId);
if (!row) throw new Error("account credential missing");
// An operator-paused account is excluded from every automatic upstream use, quota reads included.
if (row.paused) throw new Error("account is paused; quota probe skipped");
const stored = row.credential;
if (stored.expires > Date.now() + ACCOUNT_TOKEN_SKEW_MS) return stored.access;
const activeId = getAccountSet(provider)?.activeAccountId;
if (activeId !== accountId && stored.source === "local-cli") {
throw new Error("background local-cli token expired; skip CLI-adopting refresh for quota probe");
}
return getValidAccessTokenForAccount(provider, accountId);
}
/**
* Rows that must not be probed: an unsupported provider reads as unavailable, and a paused
* account returns its last reading unchanged (its `ts` shows the age) or an unavailable row,
* without writing the cache. Undefined means "probe normally".
*/
export function accountQuotaProbeSkip(provider: string, accountId: string): AccountQuotaCacheEntry | undefined {
if (!supportsPerAccountQuota(provider)) return { ts: Date.now(), quota: null, unavailable: true };
if (getAccountCredentialWithStatus(provider, accountId)?.paused !== true) return undefined;
return accountQuotaCache.get(accountCacheKey(provider, accountId)) ?? { ts: Date.now(), quota: null, unavailable: true };
}
export function explicitQuotaConfig(provider: string, configured?: OcxProviderConfig): OcxProviderConfig | undefined {
if (configured) return configured;
const entry = getProviderRegistryEntry(provider);
return entry ? { adapter: entry.adapter, baseUrl: entry.baseUrl, authMode: "oauth" } : undefined;
}
export function explicitQuotaIdentity(provider: string, accountId: string, configured?: OcxProviderConfig): string | undefined {
const credential = getAccountCredential(provider, accountId);
const target = explicitQuotaConfig(provider, configured);
if (!credential || !target) return undefined;
return quotaCredentialIdentity(provider, accountId, credential, target);
}
export function quotaCredentialIdentity(provider: string, accountId: string, credential: NonNullable<ReturnType<typeof getAccountCredential>>, target: OcxProviderConfig): string {
return createHash("sha256").update(JSON.stringify([
provider, accountId, credential.access, credential.refresh, credential.expires,
credential.accountId, credential.projectId, credential.source,
target.adapter, target.baseUrl, target.authMode, target.disabled === true,
// Only credentials that carry their own endpoint (Devin tenants) extend the identity, so
// every other provider's existing cache keys stay valid.
...(provider === "devin" && credential.apiBaseUrl ? [credential.apiBaseUrl] : []),
])).digest("hex");
}
export function explicitQuotaDestination(provider: string, config: OcxProviderConfig): boolean {
if (config.disabled === true || config.authMode !== "oauth") return false;
if (provider === "kimi") return isCanonicalKimiCodeBaseUrl(config.baseUrl);
if (provider === "command-code") return isCanonicalCommandCodeBaseUrl(config.baseUrl);
// These readers use fixed canonical billing origins, never config.baseUrl. Devin reads
// the credential's own allowlisted api-server host instead (fetchDevinQuota revalidates it).
return provider === "xai" || provider === "cursor" || provider === "devin";
}