@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
80 lines (78 loc) • 4.52 kB
text/typescript
/**
* When another stored pool account can serve again, for a main-account hard-lock refusal (#7046).
*
* A pool request that fell through to the main login and met the main-account quota guard used
* to be told to come back at main's own reset, which can be days away while a sibling pool
* account recovers within hours. This module answers one question: the earliest KNOWN instant at
* which a stored pool account's every temporary hold ends. It changes no routing state, selects
* nothing, and never lifts the main guard. The client retries at that time, and ordinary selection
* decides again from fresh state; a reset timestamp is a hint, not proof of fresh quota.
*
* Conservative by construction (the policy Jun is asked to confirm in #7046):
* - An account is a candidate only when it is a selectable stored pool account that is not
* paused, plan-excluded, quarantined for sign-in, otherwise unusable, or denied for the model.
* Those are operator or credential states no clock lifts.
* - Its recovery time is the LATEST of every routing hold with a known end: quota-health cooldown,
* quota avoidance, transient soft avoidance, pool-refresh backoff, and the credits-off
* usage-limit reset. An account under a hold whose end is unknown, or under the sliding
* failure-window guard (whose end moves with every failure), is skipped rather than guessed.
* - For an account-gated model, only accounts the resolved entitlement roster admits count, and
* with no resolved roster nothing does.
* - An account with no recorded hold is skipped: nothing says when it became unavailable, so
* nothing says when it will be available again.
* - Main itself is never a candidate; its own reset stays on the refusal.
*/
import { isCodexAccountPaused } from "../account-pause";
import { codexUsageLimitResetAt } from "../account-credit-use";
import { isSelectableCodexPoolAccount } from "../account-id";
import { isAccountNeedsReauth } from "../account-runtime-state";
import { isCodexAccountUsable } from "../account-usability";
import { getCodexPoolRefreshCooldownUntil } from "../pool-refresh-backoff";
import { getAccountQuota } from "../quota";
import type { OcxConfig } from "../../types";
import { failureWindowSteersNewThreads } from "./failure-window";
import {
codexQuotaAvoidUntil, getCodexAccountSoftAvoidUntil, getCodexQuotaHealthSnapshot, type CodexQuotaScope,
} from "./health-store";
import { getPoolAccountPlanForSelection, isCodexAccountHeldAtUsageLimit, isCodexAccountPlanExcluded } from "./selection";
export function nextCodexPoolRecoveryAt(
config: OcxConfig,
now: number,
quotaScope?: CodexQuotaScope,
options: {
deniedAccountIds?: ReadonlySet<string>;
/** When set, only these accounts may serve the model (account-gated models). */
eligibleAccountIds?: ReadonlySet<string>;
} = {},
): number | undefined {
let earliest: number | undefined;
for (const account of config.codexAccounts ?? []) {
if (!isSelectableCodexPoolAccount(account)) continue;
const id = account.id;
if (options.deniedAccountIds?.has(id) || (options.eligibleAccountIds && !options.eligibleAccountIds.has(id))
|| isCodexAccountPaused(config, id)
|| isCodexAccountPlanExcluded(config, id) || isAccountNeedsReauth(id)
|| !isCodexAccountUsable(config, id) || failureWindowSteersNewThreads(config, id, now)) continue;
const holds: number[] = [];
const health = getCodexQuotaHealthSnapshot(id, quotaScope, now);
if (health) {
if (typeof health.cooldownUntil !== "number" || !Number.isFinite(health.cooldownUntil)) continue;
holds.push(health.cooldownUntil);
}
const avoidUntil = codexQuotaAvoidUntil(id, quotaScope, now);
if (avoidUntil !== null) holds.push(avoidUntil);
const softAvoidUntil = getCodexAccountSoftAvoidUntil(id, now);
if (softAvoidUntil !== null) holds.push(softAvoidUntil);
const refreshCooldownUntil = getCodexPoolRefreshCooldownUntil(id, now);
if (refreshCooldownUntil !== null) holds.push(refreshCooldownUntil);
if (isCodexAccountHeldAtUsageLimit(config, id, now)) {
const resetAt = codexUsageLimitResetAt(getAccountQuota(id), getPoolAccountPlanForSelection(config, id), now);
if (resetAt === undefined) continue;
holds.push(resetAt);
}
if (holds.length === 0) continue;
const recoveryAt = Math.max(...holds);
if (recoveryAt > now && (earliest === undefined || recoveryAt < earliest)) earliest = recoveryAt;
}
return earliest;
}