@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
172 lines (156 loc) • 7.2 kB
text/typescript
/** Quota wire/storage shapes. This leaf must not import credential or config owners. */
/** Long-window default; explicit main-account hard-lock thresholds may override it. */
export const MAIN_ACCOUNT_HARD_LOCK_PERCENT = 98;
export const MAIN_ACCOUNT_HARD_LOCK_SHORT_PERCENT = 90;
export const MAIN_ACCOUNT_HARD_LOCK_MIN_PERCENT = 80;
/**
* How recently a 100% burst reading must have been observed to exclude an account when it
* carries no reset timestamp (#3425). This is deliberately far tighter than the disk-hydration
* horizon so a persisted reading cannot strand a recovered account. Routing and UI share this
* value because both must answer whether the same short-window observation is still current.
*/
export const TERMINAL_SHORT_WINDOW_FRESHNESS_MS = 5 * 60_000;
/**
* A window reading at or above this is a measured refusal, not a position on a scale.
*
* Separate from `CODEX_UNKNOWN_USAGE_SCORE` because they mean opposite things: unknown is
* "we have not observed this account", 100 is "we observed it and it is full". It lives on
* this leaf, next to the freshness window, because the dashboard has to answer the same
* question and cannot import the routing or disk-cache owners to do it.
*/
export const CODEX_EXHAUSTED_USAGE_PERCENT = 100;
/** Credits have a separate clock: ordinary usage headers do not re-observe the balance. */
export const CODEX_CREDITS_FRESHNESS_MS = 5 * 60_000;
export interface CodexSpendableCredits {
hasCredits?: boolean;
unlimited?: boolean;
balance?: number;
overageLimitReached?: boolean;
/** Credit spending control, never the included-plan rate_limit.allowed verdict. */
allowed?: boolean;
observedAt: number;
}
export function hasSpendableCodexCredits(
quota: Pick<StoredAccountQuota, "credits"> | null,
now = Date.now(),
): boolean {
const credits = quota?.credits;
if (!credits || !Number.isFinite(credits.observedAt)) return false;
const age = now - credits.observedAt;
if (age < 0 || age > CODEX_CREDITS_FRESHNESS_MS
|| credits.allowed === false || credits.overageLimitReached === true || credits.hasCredits === false) return false;
return credits.unlimited === true || (credits.hasCredits === true
&& typeof credits.balance === "number" && Number.isFinite(credits.balance) && credits.balance > 0);
}
/**
* Above this a value is already milliseconds; at or below it, it is Unix seconds.
*
* Both reach storage, so the split has to live somewhere every reader can see. It lives on this
* leaf rather than beside the merge that uses it because the dashboard reads the same stored
* value and cannot import the disk-cache owner.
*/
const RESET_AT_SECONDS_MAX = 10_000_000_000;
/** Normalize a stored reset instant to milliseconds. */
export function resetAtToMs(resetAt: number): number {
return resetAt < RESET_AT_SECONDS_MAX ? resetAt * 1000 : resetAt;
}
/** Only a valid reset at or before now proves a short-window reading has elapsed. */
export function hasElapsedShortWindow(resetAt: number | undefined, now: number): boolean {
return typeof resetAt === "number" && Number.isFinite(resetAt) && resetAt > 0 && resetAtToMs(resetAt) <= now;
}
/**
* A short-only reading that proves the account is blocked NOW.
*
* Routing and the dashboard's account-switch warning must answer this identically for the same
* snapshot, or the warning tells an operator an account is usable while the router refuses it.
* They did not: the dashboard compared a stored reset against `Date.now()` without normalizing
* units, so a seconds-form future reset looked expired there and live here, and it treated a
* fresh observation as sufficient even when an ELAPSED reset was present, where routing treats
* the reset as authoritative once it exists (#5045).
*
* Freshness is not optional in the reset-less branch. `getAccountQuota` performs no expiry
* check, partial updates carry a still-open short tuple forward, and disk hydration accepts a
* persisted reading for hours, so scoring exhausted from `shortPercent` alone would keep
* excluding an account whose burst window has since reset.
*/
export function isTerminalShortWindow(
quota: Pick<StoredAccountQuota, "shortPercent" | "shortResetAt" | "shortObservedAt">,
now: number,
): boolean {
const finite = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value);
if (!finite(quota.shortPercent) || quota.shortPercent < CODEX_EXHAUSTED_USAGE_PERCENT) return false;
const resetAt = quota.shortResetAt;
if (!finite(resetAt) || resetAt <= 0) {
const observedAt = quota.shortObservedAt;
if (!finite(observedAt)) return false;
const age = now - observedAt;
return age >= 0 && age <= TERMINAL_SHORT_WINDOW_FRESHNESS_MS;
}
return resetAtToMs(resetAt) > now;
}
export type StoredAccountQuota = {
weeklyPercent?: number;
monthlyPercent?: number;
weeklyResetAt?: number;
monthlyResetAt?: number;
/** Sub-day burst window, independent of the weekly window; duration supplies its meaning. */
shortPercent?: number;
shortResetAt?: number;
/** Local short-usage observation time; partial/credit updates do not refresh it. */
shortObservedAt?: number;
shortWindowSeconds?: number;
customWindows?: Array<{ label: string; percent: number; resetAt?: number }>;
resetCredits?: number;
/** Spendable usage credits; resetCredits are separate, manually redeemed reset tickets. */
credits?: CodexSpendableCredits | null;
/** Only with null: provider evidence was unavailable, not a proven spending veto.
* Affects retry advice only; legacy null remains conservative. */
creditObservationUnavailable?: true;
/** Monthly usage came from an explicitly monthly PRIMARY, not supplementary tertiary, window. */
monthlyIsPrimaryWindow?: boolean;
updatedAt: number;
};
export type WhamUsageWindow = {
used_percent?: number;
reset_at?: number;
limit_window_seconds?: number;
};
export type WhamAdditionalRateLimit = {
limit_name?: unknown;
metered_feature?: unknown;
rate_limit?: {
allowed?: unknown;
primary_window?: WhamUsageWindow | null;
secondary_window?: WhamUsageWindow | null;
} | null;
};
export type WhamUsageResponse = {
email?: string | null;
plan_type?: unknown;
account_id?: unknown;
user_id?: unknown;
rate_limit_upsell?: { banner_type?: unknown } | null;
rate_limit?: {
allowed?: unknown;
// WHAM sends explicit nulls for absent windows.
primary_window?: WhamUsageWindow | null;
secondary_window?: WhamUsageWindow | null;
tertiary_window?: WhamUsageWindow | null;
};
credits?: {
has_credits?: unknown;
unlimited?: unknown;
balance?: unknown;
overage_limit_reached?: unknown;
} | null;
/** Absent/null imposes no veto; present raw controls require an object with reached:false. */
spend_control?: unknown;
rate_limit_reset_credits?: { available_count: number } | null;
additional_rate_limits?: WhamAdditionalRateLimit[] | null;
};
/** Captured from the exact dispatched pool credential; never a management API field. */
export interface PoolQuotaWriter {
accountId: string;
credentialGeneration: number;
historyIdentity: string;
}