UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

181 lines (167 loc) • 9.45 kB
import { isValidCodexAccountId } from "./account-id"; import type { PoolQuotaWriter } from "./quota-types"; export const QUOTA_HISTORY_LIMITS = { perAccount: 200, accounts: 64, samples: 4096, bytes: 2 * 1024 * 1024, ageMs: 30 * 86400_000 } as const; export interface QuotaHistoryWindow { family: "account" | "spark"; window: "short" | "weekly" | "monthly"; usedPercent: number; resetAtMs?: number; windowSeconds?: number; monthlyIsPrimaryWindow?: boolean; } export interface QuotaHistorySample { observedAt: number; source: "wham" | "response-header"; credentialGeneration: number; windows: QuotaHistoryWindow[]; } /** A stored sample handed out without a copy; the compiler, not a comment, keeps it unmodified. */ export type ReadonlyQuotaHistorySample = Readonly<Omit<QuotaHistorySample, "windows">> & { readonly windows: readonly Readonly<QuotaHistoryWindow>[] }; type Envelope = { identity: string; samples: QuotaHistorySample[] }; type Bucket = Envelope & { costs: number[]; overhead: number }; const encoder = new TextEncoder(); const byteSize = (value: unknown) => encoder.encode(JSON.stringify(value)).byteLength; const identityPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/; const record = (value: unknown): value is Record<string, unknown> => !!value && typeof value === "object" && !Array.isArray(value); const finite = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value) && value >= 0; /** Reconstruct allowlisted data at the disk boundary; malformed windows cannot be partial evidence. */ function parseSample(value: unknown, now: number): QuotaHistorySample | undefined { if (!record(value) || !finite(value.observedAt) || value.observedAt > now || value.observedAt < now - QUOTA_HISTORY_LIMITS.ageMs || !Number.isSafeInteger(value.credentialGeneration) || (value.credentialGeneration as number) < 0 || (value.source !== "wham" && value.source !== "response-header") || !Array.isArray(value.windows) || !value.windows.length || value.windows.length > 5) return undefined; const windows: QuotaHistoryWindow[] = []; const seen = new Set<string>(); for (const item of value.windows) { if (!record(item) || (item.family !== "account" && item.family !== "spark") || (item.window !== "short" && item.window !== "weekly" && item.window !== "monthly") || (item.family === "spark" && item.window === "monthly") || !finite(item.usedPercent) || item.usedPercent > 100) return undefined; const key = `${item.family}:${item.window}`; if (seen.has(key)) return undefined; seen.add(key); if ((item.resetAtMs !== undefined && !finite(item.resetAtMs)) || (item.windowSeconds !== undefined && (!finite(item.windowSeconds) || item.windowSeconds === 0)) || (item.monthlyIsPrimaryWindow !== undefined && typeof item.monthlyIsPrimaryWindow !== "boolean")) return undefined; windows.push({ family: item.family, window: item.window, usedPercent: item.usedPercent, ...(item.resetAtMs !== undefined ? { resetAtMs: item.resetAtMs as number } : {}), ...(item.windowSeconds !== undefined ? { windowSeconds: item.windowSeconds as number } : {}), ...(item.monthlyIsPrimaryWindow === true && item.family === "account" && item.window === "monthly" ? { monthlyIsPrimaryWindow: true } : {}), }); } return { observedAt: value.observedAt, source: value.source, credentialGeneration: value.credentialGeneration as number, windows }; } /** Bounded in-process observations. The quota cache owns persistence and credential admission. */ export class CodexQuotaHistory { private accounts = new Map<string, Bucket>(); private bytes = 32; private count = 0; append(writer: PoolQuotaWriter, sample: QuotaHistorySample, now = Date.now()): void { if (!isValidCodexAccountId(writer.accountId) || !identityPattern.test(writer.historyIdentity) || sample.credentialGeneration !== writer.credentialGeneration) return; const parsed = parseSample(sample, now); if (!parsed) return; let bucket = this.accounts.get(writer.accountId); if (bucket && bucket.identity !== writer.historyIdentity) { this.clear(writer.accountId); bucket = undefined; } if (!bucket) { const overhead = byteSize(writer.accountId) + byteSize({ identity: writer.historyIdentity, samples: [] }) + 8; bucket = { identity: writer.historyIdentity, samples: [], costs: [], overhead }; this.accounts.set(writer.accountId, bucket); this.bytes += overhead; } const index = bucket.samples.findIndex(row => row.observedAt > parsed.observedAt); const position = index < 0 ? bucket.samples.length : index; const cost = byteSize(parsed) + 1; bucket.samples.splice(position, 0, parsed); bucket.costs.splice(position, 0, cost); this.bytes += cost; this.count++; while (bucket.samples.length > QUOTA_HISTORY_LIMITS.perAccount) this.dropFirst(writer.accountId); this.prune(now); } read(accountId: string, identity: string | undefined, now = Date.now(), limit: number = QUOTA_HISTORY_LIMITS.perAccount): { samples: QuotaHistorySample[]; truncated: boolean } { this.prune(now); const bucket = this.accounts.get(accountId); if (!identity || !bucket) return { samples: [], truncated: false }; if (bucket.identity !== identity) { this.clear(accountId); return { samples: [], truncated: false }; } const capped = Math.max(1, Math.min(QUOTA_HISTORY_LIMITS.perAccount, Math.trunc(limit))); return { samples: structuredClone(bucket.samples.slice(-capped)), truncated: bucket.samples.length > capped }; } /** The newest sample's origin, without pruning or clearing: a passive read changes nothing. */ peekLatestSource(accountId: string, identity: string | undefined): QuotaHistorySample["source"] | undefined { const bucket = this.accounts.get(accountId); if (!identity || !bucket || bucket.identity !== identity) return undefined; return bucket.samples.at(-1)?.source; } /** * The stored samples, without pruning, clearing or cloning: a passive read changes nothing. * The type is deeply read-only so a caller cannot mutate stored history. Samples past the age * limit may still be here; a caller that cares about age filters by `observedAt` itself. */ peekSamples(accountId: string, identity: string | undefined): readonly ReadonlyQuotaHistorySample[] { const bucket = this.accounts.get(accountId); if (!identity || !bucket || bucket.identity !== identity) return []; return bucket.samples; } clear(accountId?: string): number { if (accountId === undefined) { const count = this.accounts.size; this.accounts.clear(); this.count = 0; this.bytes = 32; return count; } const bucket = this.accounts.get(accountId); if (!bucket) return 0; this.bytes -= bucket.overhead + bucket.costs.reduce((a, b) => a + b, 0); this.count -= bucket.samples.length; this.accounts.delete(accountId); return 1; } reconcile(ids: ReadonlySet<string>): number { let removed = 0; for (const id of this.accounts.keys()) if (!ids.has(id)) removed += this.clear(id); return removed; } serialize(now = Date.now()): { version: 1; accounts: Record<string, Envelope> } { this.prune(now); return { version: 1, accounts: Object.fromEntries([...this.accounts].map(([id, bucket]) => [id, { identity: bucket.identity, samples: structuredClone(bucket.samples) }])) }; } hydrate(value: unknown, now = Date.now()): void { this.clear(); if (!record(value) || value.version !== 1 || !record(value.accounts) || byteSize(value) > QUOTA_HISTORY_LIMITS.bytes) return; const entries = Object.entries(value.accounts); if (entries.length > QUOTA_HISTORY_LIMITS.accounts) return; let count = 0; for (const [id, envelope] of entries) { if (!isValidCodexAccountId(id) || !record(envelope) || typeof envelope.identity !== "string" || !identityPattern.test(envelope.identity) || !Array.isArray(envelope.samples) || envelope.samples.length > QUOTA_HISTORY_LIMITS.perAccount) return; count += envelope.samples.length; if (count > QUOTA_HISTORY_LIMITS.samples) return; } for (const [accountId, raw] of entries) { const envelope = raw as Envelope; for (const sample of envelope.samples) { const parsed = parseSample(sample, now); if (parsed) this.append({ accountId, historyIdentity: envelope.identity, credentialGeneration: parsed.credentialGeneration }, parsed, now); } } } private dropFirst(id: string): void { const bucket = this.accounts.get(id)!; this.bytes -= bucket.costs.shift()!; bucket.samples.shift(); this.count--; if (!bucket.samples.length) { this.bytes -= bucket.overhead; this.accounts.delete(id); } } private prune(now: number): void { for (const [id, bucket] of this.accounts) { while (bucket.samples.length && bucket.samples[0].observedAt < now - QUOTA_HISTORY_LIMITS.ageMs) this.dropFirst(id); } while (this.accounts.size > QUOTA_HISTORY_LIMITS.accounts || this.count > QUOTA_HISTORY_LIMITS.samples || this.bytes > QUOTA_HISTORY_LIMITS.bytes) { const first = [...this.accounts].sort(([a, x], [b, y]) => x.samples[0].observedAt - y.samples[0].observedAt || a.localeCompare(b))[0]; if (!first) break; this.dropFirst(first[0]); } } }