@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
160 lines (150 loc) • 7.08 kB
text/typescript
import type { OcxConfig } from "../types";
import { configuredAnthropicInstance } from "../providers/anthropic-instance";
/**
* Quota-aware policy scoring (RI-07).
*
* Evidence reuses the existing privacy-safe quota sources: the Codex pool
* account quota cache (usage percents only - no emails, tokens, or raw
* responses) and the provider per-account quota cache (Anthropic). Unknown
* quota stays unknown; no raw quota response ever reaches a trace.
*
* Boundary: policy profiles select provider/model TARGETS. Exact account
* selectors and Codex pool strategies remain authoritative inside their
* existing scope; account-level quota evidence is consumed when a candidate
* carries an account reference (dry-run/evaluate), never invented.
*/
import {
codexQuotaWindowForPlan,
getAccountQuota,
isCodexQuotaExhausted,
listAccountQuotas,
} from "../codex/quota";
import { getCachedProviderAccountQuota } from "../providers/quota";
import type { RouteQuotaEvidence } from "./trace";
export interface QuotaEvidenceInput {
provider: string;
model: string;
accountRef?: string;
codexAccountId?: string;
codexAccountPlan?: string;
}
export interface CodexPoolQuotaAccount {
accountId: string;
plan?: string;
}
function codexAccountQuotaEvidence(accountId: string, plan?: string): RouteQuotaEvidence {
const quota = getAccountQuota(accountId);
if (!quota) return { known: false };
const monthly = codexQuotaWindowForPlan(plan) === "monthly";
const percents = [
...(monthly ? [] : [quota.weeklyPercent]),
quota.monthlyPercent,
// The burst window is upstream-enforced independently of the governing window, so an
// account at 97% here has 3% headroom whatever its weekly figure says. This was invisible
// while the header parser misfiled 5h readings into weeklyPercent - routing saw the burst
// by accident. Once that is fixed, omitting it here reports 88% headroom for an account
// that is one request away from a 429. computeCodexUsageScore already folds it in.
quota.shortPercent,
].filter((value): value is number => typeof value === "number" && Number.isFinite(value));
const maxPercent = percents.length > 0 ? Math.max(...percents) : undefined;
// Credits-only snapshots prove neither usage nor exhaustion. Unknown must not
// become healthy capacity merely because a cache row exists.
if (maxPercent === undefined) return { known: false };
const resets = [
...(monthly ? [] : [quota.weeklyResetAt]),
quota.monthlyResetAt,
// Pair the reset with the window that can actually gate the next request: a burst-limited
// account recovers in hours, and reporting a distant weekly reset would defer a retry that
// is already safe.
quota.shortResetAt,
].filter((value): value is number => typeof value === "number" && Number.isFinite(value))
.filter(value => value > Date.now());
return {
known: true,
headroom: Math.max(0, Math.min(1, 1 - maxPercent / 100)),
exhausted: isCodexQuotaExhausted(quota, plan),
...(resets.length > 0 ? { resetAtMs: Math.min(...resets) } : {}),
source: "codex-pool",
};
}
export function codexPoolQuotaEvidence(accounts: readonly CodexPoolQuotaAccount[]): RouteQuotaEvidence {
if (accounts.length === 0) return { known: false };
const evidence = accounts.map(account => codexAccountQuotaEvidence(account.accountId, account.plan));
const known = evidence.filter(item => item.known);
if (known.length === 0) return { known: false };
const usable = known.filter(item => item.exhausted !== true);
if (usable.length > 0) {
const headrooms = usable.map(item => item.headroom)
.filter((value): value is number => typeof value === "number" && Number.isFinite(value));
return {
known: true,
exhausted: false,
...(headrooms.length > 0 ? { headroom: Math.max(...headrooms) } : {}),
source: "codex-pool",
};
}
if (known.length < evidence.length) return { known: false };
const resets = known.map(item => item.resetAtMs)
.filter((value): value is number => typeof value === "number" && Number.isFinite(value));
return {
known: true,
exhausted: true,
headroom: 0,
...(resets.length > 0 ? { resetAtMs: Math.min(...resets) } : {}),
source: "codex-pool",
};
}
export function quotaEvidenceForCandidate(input: QuotaEvidenceInput, config?: Pick<OcxConfig, "providers">): RouteQuotaEvidence {
if (input.provider === "openai" && input.codexAccountId) {
// listAccountQuotas() is the reconciled quota snapshot: config-generation
// reconciliation prunes removed accounts. Other eligibility dimensions
// (pause/reauth/cooldown/soft-avoid) remain health/pool-selector concerns.
if (input.codexAccountPlan !== undefined) {
const pool = [...listAccountQuotas()].map(([accountId]) => ({
accountId,
...(accountId === input.codexAccountId ? { plan: input.codexAccountPlan } : {}),
}));
if (pool.length > 1) return codexPoolQuotaEvidence(pool);
}
return codexAccountQuotaEvidence(input.codexAccountId, input.codexAccountPlan);
}
const instance = config ? configuredAnthropicInstance(config, input.provider)
: input.provider === "anthropic" ? "anthropic" : undefined;
if (instance && input.accountRef) {
const quota = getCachedProviderAccountQuota(instance, input.accountRef);
if (quota) {
const family = anthropicFamilyWindow(input.model, quota.customWindows ?? []);
const percents = [quota.fiveHourPercent, quota.weeklyPercent, quota.monthlyPercent, family?.percent]
.filter((value): value is number => typeof value === "number" && Number.isFinite(value));
const maxPercent = percents.length > 0 ? Math.max(...percents) : undefined;
const resets = [quota.fiveHourResetAt, quota.weeklyResetAt, quota.monthlyResetAt, family?.resetAt]
.filter((value): value is number => typeof value === "number" && Number.isFinite(value))
.filter(value => value > Date.now());
return {
known: true,
...(maxPercent !== undefined ? { headroom: Math.max(0, Math.min(1, 1 - maxPercent / 100)) } : {}),
exhausted: maxPercent !== undefined && maxPercent >= 100,
...(resets.length > 0 ? { resetAtMs: Math.min(...resets) } : {}),
source: "provider-report",
};
}
}
return { known: false };
}
function anthropicFamilyWindow(
model: string,
windows: Array<{ label: string; percent?: number; resetAt?: number }>,
): { percent?: number; resetAt?: number } | undefined {
const normalized = model.toLowerCase();
for (const window of windows) {
const family = window.label.trim().toLowerCase();
if (family && normalized.includes(family)) return window;
}
return undefined;
}
export function quotaScore(evidence: RouteQuotaEvidence | undefined): number | null {
if (!evidence || !evidence.known) return null;
if (evidence.exhausted === true) return 0;
if (typeof evidence.headroom === "number") return Math.max(0, Math.min(1, evidence.headroom));
return null;
}