@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
203 lines (188 loc) • 9.28 kB
text/typescript
import { isGenericFailoverProvider } from "./generic-account-failover";
import { parseAccountPoolStickyLimit, parseAccountPoolStrategy, parseCodexAccountPoolStrategy } from "./pool-kernel";
import type { OcxConfig, OcxProviderConfig } from "../types";
import type { AnthropicModelRoute } from "../types/config";
import { readAnthropicModelRoutes } from "./anthropic-model-routes";
/**
* Which pool-settings contract a provider speaks (#695, slice 1).
*
* `codex` and `anthropic` keep their own routes and storage untouched. `generic` is every
* other OAuth provider the generic failover module admits; its settings persist on
* `providers.<name>.oauthAccountFailover`.
*
* `strategy` and `autoSwitchThreshold` are consumed only when `pool.kernel` is on — that
* is what `inert` reports. `enabled` is NOT inert: an explicit
* `true` enables pre-dispatch exhaustion avoidance (`preferredInitialAccount`); absence is off.
* Healthy manual selections remain authoritative. What the switch can
* no longer do is refuse reactive 429 rotation, which activates on account presence and is not
* disableable.
*/
export type PoolSettingsKind = "codex" | "anthropic" | "generic";
export const GENERIC_POOL_STRATEGIES = ["quota", "round-robin", "fill-first", "least-loaded"] as const;
export type GenericPoolStrategy = typeof GENERIC_POOL_STRATEGIES[number];
export function poolSettingsCapability(name: string, provider: OcxProviderConfig | undefined): PoolSettingsKind | null {
if (name === "openai") return "codex";
if (name === "anthropic") return "anthropic";
if (!provider) return null;
return isGenericFailoverProvider(name, provider) ? "generic" : null;
}
export function parseGenericPoolStrategy(value: unknown, providerName?: string): GenericPoolStrategy | null {
// Keep the common three names in the shared parser; the fourth is Kiro-specific.
if (value === "least-loaded") return providerName === "kiro" ? value : null;
return parseAccountPoolStrategy(value);
}
export function parseKiroAccountCap(value: unknown): number | null {
return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 100 ? value : null;
}
export function parseGenericAutoSwitchThreshold(value: unknown): number | null {
return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 100 ? value : null;
}
export function parseGenericStickyLimit(value: unknown): number | null {
return parseAccountPoolStickyLimit(value);
}
/** Fields the unified pool-settings contract can carry, per kind. */
export const POOL_SETTINGS_FIELDS = [
"enabled", "strategy", "stickyLimit", "autoSwitchThreshold", "quotaWindow", "maxConcurrentPerAccount", "routes",
] as const;
export type PoolSettingsField = typeof POOL_SETTINGS_FIELDS[number];
/**
* One shape for all three pool kinds.
*
* `supported` is the reason this is a consolidation rather than a fourth contract: a field a
* kind does not honour is DECLARED unsupported instead of being omitted, so a dashboard can
* tell "this pool has no quotaWindow" from "this response forgot to send one". Every kind
* answers with the same keys.
*/
export interface PoolSettingsDto {
provider: string;
kind: PoolSettingsKind;
supported: PoolSettingsField[];
/** The STORED override. null means nothing is stored here, not "off". */
enabled: boolean | null;
/**
* What the runtime actually resolves for `enabled`, after the global default.
*
* The generic kind inherits `config.oauthAccountFailover.enabled` when it stores no override
* of its own, so `enabled: null` alone cannot distinguish a disabled pool from an inherited
* one. This resolves exactly that config question and nothing else -- deliberately NOT the
* roster quorum the dispatch predicate also applies, because a settings field that folded in
* "how many accounts are logged in" would be answering a different question than it asks.
*/
enabledEffective: boolean;
strategy: string | null;
stickyLimit: number | null;
autoSwitchThreshold: number | null;
quotaWindow: string | null;
maxConcurrentPerAccount: number | null;
routes: AnthropicModelRoute[] | null;
/** Present only when stored Anthropic routes fail validation on read. */
routesError?: string;
}
export interface GenericPoolSettingsDto {
provider: string;
kind: "generic";
enabled: boolean | null;
strategy: GenericPoolStrategy | null;
autoSwitchThreshold: number | null;
stickyLimit: number | null;
/** Present only for Kiro; other generic providers keep their original legacy shape. */
maxConcurrentPerAccount?: number | null;
/**
* Marker for `strategy`, `autoSwitchThreshold` and `stickyLimit` only: true while they are
* persisted but not consumed by the selector, false once `pool.kernel` is on and they
* actually choose an account.
*
* It deliberately does NOT describe `enabled`, which governs the pre-dispatch preference.
* Widening it to the whole DTO would tell a dashboard that `enabled` changes nothing, which
* has been false since reactive and proactive activation were split.
*
* Computed, never a literal: the flag is reversible, so a DTO that hard-codes either answer
* would be lying in one of the two states.
*/
inert: boolean;
}
export function genericPoolSettingsDto(
name: string,
provider: OcxProviderConfig,
kernelEnabled = false,
): GenericPoolSettingsDto {
const failover = provider.oauthAccountFailover ?? {};
return {
provider: name,
kind: "generic",
enabled: typeof failover.enabled === "boolean" ? failover.enabled : null,
strategy: parseGenericPoolStrategy(failover.strategy, name),
...(name === "kiro" ? { maxConcurrentPerAccount: parseKiroAccountCap(failover.maxConcurrentPerAccount) } : {}),
autoSwitchThreshold: parseGenericAutoSwitchThreshold(failover.autoSwitchThreshold),
stickyLimit: parseGenericStickyLimit(failover.stickyLimit),
inert: kernelEnabled !== true,
};
}
/** Which fields each kind actually honours. Declared, never silently omitted. */
const SUPPORTED_BY_KIND: Record<PoolSettingsKind, PoolSettingsField[]> = {
codex: ["strategy", "stickyLimit", "autoSwitchThreshold"],
anthropic: ["enabled", "strategy", "stickyLimit", "autoSwitchThreshold", "quotaWindow", "routes"],
generic: ["enabled", "strategy", "stickyLimit", "autoSwitchThreshold"],
};
/**
* The one projection behind `/api/pool/settings`.
*
* Reads each kind's own storage -- this consolidates the CONTRACT, not the persistence -- and
* answers with identical keys plus a `supported` list, so an unsupported field is a declared
* `null` rather than an absence a caller has to guess about.
*/
export function unifiedPoolSettingsDto(
config: OcxConfig,
provider: string,
kind: PoolSettingsKind,
): PoolSettingsDto {
const base = { provider, kind, supported: provider === "kiro"
? [...SUPPORTED_BY_KIND.generic, "maxConcurrentPerAccount" as const] : SUPPORTED_BY_KIND[kind] };
if (kind === "codex") {
return {
...base,
// The Codex pool has no enablement switch: it is on whenever accounts exist, so the
// honest answer is "not a field here" rather than a fabricated true.
enabled: null,
enabledEffective: true,
strategy: parseCodexAccountPoolStrategy(config.accountPoolStrategy) ?? "quota",
stickyLimit: parseGenericStickyLimit(config.accountPoolStickyLimit) ?? 1,
autoSwitchThreshold: parseGenericAutoSwitchThreshold(config.autoSwitchThreshold) ?? 80,
quotaWindow: null,
maxConcurrentPerAccount: null,
routes: null,
};
}
if (kind === "anthropic") {
const pool = config.anthropicAccountPool ?? {};
const enabled = typeof pool.enabled === "boolean" ? pool.enabled : null;
return {
...base,
enabled,
enabledEffective: enabled === true,
strategy: parseGenericPoolStrategy(pool.strategy) ?? "quota",
stickyLimit: parseGenericStickyLimit(pool.stickyLimit) ?? 1,
autoSwitchThreshold: parseGenericAutoSwitchThreshold(pool.autoSwitchThreshold) ?? 80,
quotaWindow: typeof pool.quotaWindow === "string" ? pool.quotaWindow : "five-hour",
maxConcurrentPerAccount: null,
...readAnthropicModelRoutes(pool.routes),
};
}
const failover = config.providers?.[provider]?.oauthAccountFailover ?? {};
const stored = typeof failover.enabled === "boolean" ? failover.enabled : null;
return {
...base,
enabled: stored,
// The defect this field exists to close: a generic provider with no stored override
// inherits the global, so `enabled: null` alone cannot tell a disabled pool from an
// inherited one. Config only -- the roster quorum the dispatch predicate also applies is a
// different question and stays out of a settings field.
enabledEffective: stored ?? (config.oauthAccountFailover?.enabled === true),
strategy: parseGenericPoolStrategy(failover.strategy, provider),
stickyLimit: parseGenericStickyLimit(failover.stickyLimit),
autoSwitchThreshold: parseGenericAutoSwitchThreshold(failover.autoSwitchThreshold),
quotaWindow: null,
maxConcurrentPerAccount: provider === "kiro" ? parseKiroAccountCap(failover.maxConcurrentPerAccount) : null,
routes: null,
};
}