@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
204 lines (193 loc) • 8.89 kB
text/typescript
/** Isolated, process-local API-key quota rows. Never publishes provider/routing caches. */
import { createHash } from "node:crypto";
import type { OcxConfig, OcxProviderConfig } from "../types";
import { apiKeyPoolEntryId } from "./api-keys";
import { resolveProviderApiKey } from "./key-store";
import type { ProviderQuota } from "./quota-types";
import { ACCOUNT_QUOTA_TTL_MS } from "./quota-wire";
const MAX_ENTRIES = 256;
const LAST_GOOD_MS = 30 * 60_000;
/** `unread` marks a synthesized row: no read happened, so `ts` is not a read time. */
type Entry = { ts: number; quota: ProviderQuota | null; unavailable?: true; unread?: true };
export type KeyQuotaProbeOutcome =
| { kind: "quota"; quota: ProviderQuota }
| { kind: "empty" | "terminal" | "unavailable" };
export interface ProviderApiKeyQuota {
keyId: string;
quota: ProviderQuota | null;
unavailable?: true;
/** When this key's quota was last read, success or failure; absent when no read happened. */
readAt?: number;
/** Server-only, non-enumerable; call immediately before the safe DTO join. */
isCurrent: () => boolean;
}
const cache = new Map<string, Entry>();
const flights = new Map<string, Promise<Entry>>();
let epoch = 0;
export function clearProviderApiKeyQuotaCache(): void {
epoch += 1;
cache.clear();
flights.clear();
}
/**
* Cached-only, synchronous per-key quota. Never probes, never awaits, never schedules a read.
*
* The selector that calls this sits on the first-attempt path, where a network read would be a
* worse defect than the one it is there to fix. A miss is simply "no evidence".
*
* An `unavailable` row is a miss too, and that is the whole point of the check. `readEntry`
* keeps a last-good quota attached for up to LAST_GOOD_MS after a probe starts failing, so
* returning `entry.quota` on any hit would rank on a number up to half an hour stale -- and
* rank it ABOVE a key with no row at all. Last-good is a display value, not a selection input.
*
* A SUCCESSFUL row expires too, on exactly `readEntry`'s freshness predicate. Checking only
* `unavailable` was not enough: nothing on the selection path probes or sweeps, so once a
* dashboard or CLI read had populated the cache, a row could outlive ACCOUNT_QUOTA_TTL_MS and
* keep a "roomy" ten-minute-old measurement ranked above a key with no evidence at all --
* until some unrelated write happened to sweep it. Expired is no evidence, same as absent.
*/
export function cachedApiKeyQuota(
name: string,
provider: OcxProviderConfig,
keyId: string,
key: string,
): ProviderQuota | null {
let resolved: string | undefined;
// resolveProviderApiKey swallows its own failures; the catch is belt-and-braces because this
// runs on the dispatch path and must not throw there under any future change.
try { resolved = resolveProviderApiKey(key)?.trim(); } catch { return null; }
if (!resolved) return null;
const entry = cache.get(identity(name, provider, keyId, resolved));
if (!entry || entry.unavailable || !entry.quota) return null;
const now = Date.now();
if (now - entry.ts >= ACCOUNT_QUOTA_TTL_MS) return null;
if (now - entry.quota.updatedAt >= LAST_GOOD_MS) return null;
return entry.quota;
}
/** Test seam: keyed on identity(), so it takes the raw key rather than an account id. */
export function setCachedProviderApiKeyQuotaForTests(
name: string,
provider: OcxProviderConfig,
keyId: string,
key: string,
quota: ProviderQuota | null,
unavailable?: true,
): void {
const resolved = resolveProviderApiKey(key)?.trim();
if (!resolved) return;
remember(identity(name, provider, keyId, resolved), { ts: Date.now(), quota, ...(unavailable ? { unavailable } : {}) });
}
/** Four workers per roster, not a process-wide network limit. */
export async function mapQuotaRoster<T, R>(rows: readonly T[], read: (row: T) => Promise<R>): Promise<R[]> {
const out = new Array<R>(rows.length);
let cursor = 0;
await Promise.all(Array.from({ length: Math.min(4, rows.length) }, async () => {
while (cursor < rows.length) {
const index = cursor++;
out[index] = await read(rows[index]!);
}
}));
return out;
}
function roster(provider: OcxProviderConfig) {
return provider.apiKeyPool?.length ? provider.apiKeyPool
: provider.apiKey ? [{ id: apiKeyPoolEntryId(provider.apiKey), key: provider.apiKey }] : [];
}
function identity(name: string, provider: OcxProviderConfig, id: string, key: string): string {
return createHash("sha256").update(JSON.stringify([
"quota-key", name, provider.adapter, provider.baseUrl, provider.authMode ?? "key",
provider.disabled === true, id, key,
])).digest("hex");
}
function remember(key: string, entry: Entry): void {
cache.delete(key);
for (const [id, row] of cache) if (Date.now() - row.ts >= LAST_GOOD_MS) cache.delete(id);
while (cache.size >= MAX_ENTRIES) cache.delete(cache.keys().next().value!);
cache.set(key, entry);
}
async function readEntry(
key: string,
force: boolean,
isCurrent: () => boolean,
probe: () => Promise<KeyQuotaProbeOutcome>,
): Promise<Entry> {
const previous = cache.get(key);
if (!force && previous && Date.now() - previous.ts < ACCOUNT_QUOTA_TTL_MS
&& (!previous.quota || Date.now() - previous.quota.updatedAt < LAST_GOOD_MS)) {
cache.delete(key);
cache.set(key, previous);
return previous;
}
const running = flights.get(key);
if (running) return running;
const lastGood = previous?.quota && Date.now() - previous.quota.updatedAt < LAST_GOOD_MS
? previous.quota : null;
if (flights.size >= MAX_ENTRIES) return { ts: Date.now(), quota: lastGood, unavailable: true, unread: true };
const flight = (async (): Promise<Entry> => {
let result: KeyQuotaProbeOutcome;
try { result = await probe(); } catch { result = { kind: "unavailable" }; }
const entry: Entry = result.kind === "quota"
? { ts: Date.now(), quota: result.quota }
: result.kind === "empty"
? { ts: Date.now(), quota: null }
: {
ts: Date.now(),
quota: result.kind !== "terminal" && lastGood && Date.now() - lastGood.updatedAt < LAST_GOOD_MS ? lastGood : null,
unavailable: true,
};
if (isCurrent()) remember(key, entry);
return entry;
})().finally(() => { if (flights.get(key) === flight) flights.delete(key); });
flights.set(key, flight);
return flight;
}
export async function readProviderApiKeyQuotas(
config: OcxConfig,
name: string,
force: boolean,
probe: (provider: OcxProviderConfig, config: OcxConfig) => Promise<KeyQuotaProbeOutcome>,
): Promise<ProviderApiKeyQuota[]> {
const liveProvider = config.providers[name];
if (!liveProvider) return [];
const providerSnapshot = { ...liveProvider };
const rows = roster(liveProvider).map(row => ({ ...row }));
const generation = epoch;
return mapQuotaRoster(rows, async row => {
let resolved: string | undefined;
try { resolved = resolveProviderApiKey(row.key)?.trim(); } catch { /* unavailable */ }
const key = resolved ? identity(name, providerSnapshot, row.id, resolved) : null;
const isCurrent = () => {
if (epoch !== generation || !key) return false;
const current = config.providers[name];
if (!current) return false;
const entry = roster(current).find(candidate => candidate.id === row.id);
if (!entry) return false;
try {
const currentKey = resolveProviderApiKey(entry.key)?.trim();
return !!currentKey && identity(name, current, row.id, currentKey) === key;
} catch { return false; }
};
const isPaused = () => row.disabled === true
|| roster(config.providers[name] ?? providerSnapshot).find(candidate => candidate.id === row.id)?.disabled === true;
const cached = key ? cache.get(key) : undefined;
const entry = key && resolved && isCurrent()
? isPaused()
? (cached && (!cached.quota || Date.now() - cached.quota.updatedAt < LAST_GOOD_MS)
? cached
: { ts: Date.now(), quota: null, unavailable: true as const, unread: true as const })
: await readEntry(key, force, isCurrent, () => {
const isolatedProvider = { ...providerSnapshot, apiKey: resolved, apiKeyPool: undefined };
const isolatedConfig = { ...config, providers: { [name]: isolatedProvider } };
return probe(isolatedProvider, isolatedConfig);
})
: { ts: Date.now(), quota: null, unavailable: true as const, unread: true as const };
const current = isCurrent();
const result = {
keyId: row.id,
quota: current ? entry.quota : null,
...(!current || entry.unavailable ? { unavailable: true as const } : {}),
...(current && !entry.unread ? { readAt: entry.ts } : {}),
};
return Object.defineProperty(result, "isCurrent", { value: isCurrent }) as ProviderApiKeyQuota;
});
}