UNPKG

@bitkyc08/opencodex

Version:

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

354 lines (325 loc) • 15.9 kB
/** * Runtime registry for user-configured provider cost overlays * (`providers.<name>.modelCosts` in config.json — per-model prices in ocx's * flat `modelXxx` convention, mirroring opencode's per-model pricing). * * The usage cost estimator stays pure: it receives overlays as parameters and * defaults to this registry, which is refreshed at the config chokepoints * (loadConfig and every persist path). A refresh that actually changes the * rows replaces the active array with a NEW identity and bumps a version * counter, so the estimator's memo and the /api/usage summary cache skip stale * rows without cross-module invalidation. Refreshes with byte-identical rows * are no-ops: config is reloaded at many chokepoints and an unchanged reload * must not churn the version (see refreshUserCostOverlays). The configured * provider-name set is part of the change identity: adding or removing a * provider changes which names may collapse to a label base in the resolver, * so it bumps the version even when no overlay row changed. Exact selectable * Codex IDs and effective log labels also participate in that identity. * * Display-time estimation only — these rows never affect billing. */ import type { OcxConfig, OcxProviderConfig, ProviderCostOverlay, PromptLengthPricing } from "../types"; import type { ExpectedPriceOverlay } from "./expected-prices"; import { validCost4 } from "./user-cost-validation"; import { isValidCreditPriceBound as isValidCreditPriceUsd } from "./credit-billing"; export { COST4_RATE_KEYS, isValidCost4Rate, validCost4, isValidPromptLengthPricing } from "./user-cost-validation"; import { redactSecretString } from "../lib/redact"; import { isSelectableCodexPoolAccount, MAIN_CODEX_ACCOUNT_ID } from "../codex/account-id"; import { codexAccountLogLabel } from "../codex/account-label"; const EMPTY: readonly ExpectedPriceOverlay[] = []; let active: readonly ExpectedPriceOverlay[] = EMPTY; let activeSignature = ""; let activeConfigured = new Set<string>(); let activeAccountProviders = codexAccountProviders([]); let version = 0; let creditPriceByProvider: ReadonlyMap<string, number> = new Map(); let preservedDiskOnlyProviders: Record<string, OcxProviderConfig> | null = null; /** * Preservation owner metadata rides through the shallow config projections in * config.ts via an enumerable SYMBOL key. JSON.stringify ignores symbol keys, * so the tag is process-local only and can never reach config.json or a DTO. */ const PRESERVATION_OWNER_STATE = Symbol("opencodex.user-cost-overlay-preservation-owner"); const PERSISTED_PROVIDER_DELETIONS = Symbol("opencodex.persisted-provider-deletions"); type PreservationOwnerState = { refs: number; config: OcxConfig; ownedProviders: Set<string>; }; type PreservationTaggedConfig = OcxConfig & { [PRESERVATION_OWNER_STATE]?: PreservationOwnerState; [PERSISTED_PROVIDER_DELETIONS]?: readonly string[]; }; const preservationOwnerStates = new Set<PreservationOwnerState>(); function providerNames(config: OcxConfig): Set<string> { return new Set(Object.keys(config.providers ?? {})); } /** Exact config-owned identities only; aliases and generic OAuth stores are not authority. */ function codexAccountProviders(accounts: OcxConfig["codexAccounts"]): Map<string, string> { const identities = new Set(["main", MAIN_CODEX_ACCOUNT_ID]); for (const account of accounts ?? []) { if (!isSelectableCodexPoolAccount(account)) continue; identities.add(account.id); identities.add(codexAccountLogLabel(account)); } const mapping = new Map<string, string>(); for (const identity of identities) { mapping.set(identity, "openai"); for (const provider of ["openai", "chatgpt", "openai-multi"]) { mapping.set(`${provider}-${identity}`, "openai"); } } return mapping; } /** Register one active live-config owner. Multiple server leases may share one config object. */ export function registerPreservedProviderOwner(config: OcxConfig): void { const tagged = config as PreservationTaggedConfig; const existing = tagged[PRESERVATION_OWNER_STATE]; if (existing && preservationOwnerStates.has(existing)) { existing.refs += 1; existing.ownedProviders = providerNames(config); return; } const state: PreservationOwnerState = { refs: 1, config, ownedProviders: providerNames(config), }; // Enumerable is deliberate: projectCustomModelCatalogMigration and the live // binding guard use object spread, which must carry this process-local tag to // the serialization view. Symbol keys are still omitted by JSON.stringify. Object.defineProperty(tagged, PRESERVATION_OWNER_STATE, { value: state, enumerable: true, configurable: true, }); preservationOwnerStates.add(state); } /** * Refresh a registered owner's provider snapshot from a successful disk read. * * A provider still present on disk remains owned even if the live object * temporarily omits it: management DELETE has an async-import gap between * mutating the live config and committing the write, and a reconciler tick in * that gap must not erase the deletion authority. Conversely, providers that * disappeared from disk are no longer considered owned, and newly present * providers are adopted only when this live config actually has the row. */ export function refreshPreservedProviderOwner(config: OcxConfig, disk: OcxConfig): void { const state = (config as PreservationTaggedConfig)[PRESERVATION_OWNER_STATE]; if (!state || !preservationOwnerStates.has(state)) return; const diskNames = providerNames(disk); for (const name of [...state.ownedProviders]) { if (!diskNames.has(name)) state.ownedProviders.delete(name); } for (const name of Object.keys(config.providers ?? {})) { if (diskNames.has(name)) state.ownedProviders.add(name); } } /** Release one active live-config owner lease. */ export function unregisterPreservedProviderOwner(config: OcxConfig): void { const tagged = config as PreservationTaggedConfig; const state = tagged[PRESERVATION_OWNER_STATE]; if (!state || !preservationOwnerStates.has(state)) return; state.refs -= 1; if (state.refs > 0) return; preservationOwnerStates.delete(state); if (tagged[PRESERVATION_OWNER_STATE] === state) { delete tagged[PRESERVATION_OWNER_STATE]; } } /** * Remember provider rows that exist on disk but are intentionally absent from * the live routing config (added by an external editor after the proxy booted). * They are merged back at the config serialization boundary so an unrelated * in-process save cannot erase the external provider and its overlay. */ export function setPreservedDiskOnlyProviders( providers: Record<string, OcxProviderConfig> | null, ): void { preservedDiskOnlyProviders = providers; } /** * Commit an explicit provider deletion only after the persisted serialization * view has been accepted by the config write path. This clears the stale * preservation row and removes the provider from every active live projection, * so a second owner cannot resurrect it on a later unrelated save. */ function commitPersistedProviderDeletions(config: OcxConfig): void { const tagged = config as PreservationTaggedConfig; const deletions = tagged[PERSISTED_PROVIDER_DELETIONS]; if (!deletions || deletions.length === 0) return; const deleted = new Set(deletions); if (preservedDiskOnlyProviders) { const next = { ...preservedDiskOnlyProviders }; for (const name of deleted) delete next[name]; preservedDiskOnlyProviders = Object.keys(next).length > 0 ? next : null; } for (const state of preservationOwnerStates) { for (const name of deleted) { state.ownedProviders.delete(name); if (state.config.providers) delete state.config.providers[name]; } } delete tagged[PERSISTED_PROVIDER_DELETIONS]; } /** * A serialization view of `config` that keeps externally added providers on * disk without adding them to live routing state. Live providers win when a * name exists in both maps. * * A registered owner also carries the provider names it previously owned. If * that owner now omits one of those providers, the omission is an intentional * in-process deletion rather than an old projection that never knew the row. * Suppress only those names from preservation for this write. The suppression * is committed globally only after refreshUserCostOverlays receives the * successfully persisted view, so a failed atomic write cannot destroy the * preservation safety net. */ export function withPreservedDiskOnlyProviders(config: OcxConfig): OcxConfig { const tagged = config as PreservationTaggedConfig; const owner = tagged[PRESERVATION_OWNER_STATE]; const deletedProviders = owner && preservationOwnerStates.has(owner) ? [...owner.ownedProviders].filter(name => !Object.hasOwn(config.providers ?? {}, name)) : []; const deletedSet = new Set(deletedProviders); let preserved: Record<string, OcxProviderConfig> | null = null; if (preservedDiskOnlyProviders) { const filtered = Object.entries(preservedDiskOnlyProviders) .filter(([name]) => !deletedSet.has(name)); if (filtered.length > 0) preserved = Object.fromEntries(filtered); } let persisted: OcxConfig; if (preserved && Object.keys(preserved).length > 0) { persisted = { ...config, providers: { ...preserved, ...config.providers, }, }; } else if (deletedProviders.length > 0) { // Return a distinct object so the persisted-deletion marker remains scoped // to this serialization attempt rather than the long-lived live config. persisted = { ...config }; } else { return config; } if (deletedProviders.length > 0) { Object.defineProperty(persisted as PreservationTaggedConfig, PERSISTED_PROVIDER_DELETIONS, { value: deletedProviders, enumerable: false, configurable: true, }); } return persisted; } /** Test-only reset for the preserved disk-only provider registry. */ export function resetPreservedDiskOnlyProvidersForTests(): void { preservedDiskOnlyProviders = null; preservationOwnerStates.clear(); } /** Copy a validated override; automatic is represented by absence. */ export function copyPromptLengthPricing(policy: PromptLengthPricing): PromptLengthPricing | undefined { if (policy.mode === "automatic") return undefined; if (policy.mode !== "custom") return { mode: policy.mode }; const { input, output, cacheRead, cacheWrite } = policy.rates; return { mode: "custom", thresholdTokens: policy.thresholdTokens, comparison: policy.comparison, rates: { input, output, cacheRead, cacheWrite } }; } /** * Rebuild the active user-overlay rows from the current config. Malformed rows * are skipped (config validation reports them separately); a provider with no * overlay contributes nothing. */ export function refreshUserCostOverlays(config: OcxConfig): void { // Only persisted serialization views carry PERSISTED_PROVIDER_DELETIONS. // Committing here means changed writes update owner state only after the // atomic write succeeds, while byte-identical successful saves also converge. commitPersistedProviderDeletions(config); const rows: ExpectedPriceOverlay[] = []; const creditPrices = new Map<string, number>(); const providers = config.providers; if (providers) { for (const [providerName, provider] of Object.entries(providers)) { const creditPrice = provider?.creditPriceUsd; if (isValidCreditPriceUsd(creditPrice)) creditPrices.set(providerName, creditPrice); const costs = provider?.modelCosts; if (!costs || typeof costs !== "object" || Array.isArray(costs)) continue; for (const [modelId, cost4] of Object.entries(costs)) { if (!modelId.trim() || !validCost4(cost4)) continue; const policy = cost4.promptLengthPricing && copyPromptLengthPricing(cost4.promptLengthPricing); rows.push({ provider: providerName, modelId, // Copy only validated rates and policy: a hand-edited row may // carry extra properties (e.g. a misplaced apiKey) that must never // reach display estimates or /api/logs through the registry. cost4: { input: cost4.input, output: cost4.output, cacheRead: cost4.cacheRead, cacheWrite: cost4.cacheWrite, }, ...(policy ? { promptLengthPricing: policy } : {}), // Display provenance only: redact token-shaped provider/model ids so // the source string can never echo a pasted key. Matching still uses // the raw fields, and the change-detection signature below MUST keep // them raw — distinct ids would otherwise collapse to "[REDACTED]" // and skip the version bump. source: `config:providers.${redactSecretString(providerName)}.modelCosts[${redactSecretString(modelId)}]`, verifiedAt: "user-configured", status: "verified", }); } } } // Config is re-loaded at many chokepoints (server start, migrations, persist // paths). Bumping the version on every load — even when nothing changed — // would invalidate the /api/usage summary cache on unrelated reloads and // churn the cost memo. Only a real overlay change bumps the version, so the // cache survives reloads of an unchanged config. // The signature MUST compare the raw matching fields: two different // secret-shaped ids would both redact to "[REDACTED]" and falsely look // unchanged, skipping the version bump and serving stale estimates. The // signature is process-local state and is never serialized to a response; // only the display `source` above is redacted. // The configured provider-name set is part of the identity too: adding or // removing a provider (even one without an overlay) changes which names are // allowed to collapse to a label base, so the resolver memo and the // /api/usage summary cache must be invalidated on that change as well. // Sort effective account identities so account order, aliases and plan // metadata do not churn caches; add/remove/label changes still invalidate. const configuredNames = Object.keys(providers ?? {}).sort(); const accountProviders = codexAccountProviders(config.codexAccounts); const accountEntries = [...accountProviders].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0); const creditEntries = [...creditPrices].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0); const signature = `${JSON.stringify(configuredNames)}\u0000${JSON.stringify(rows)}\u0000${JSON.stringify(accountEntries)}\u0000${JSON.stringify(creditEntries)}`; if (signature === activeSignature) return; activeSignature = signature; active = rows; creditPriceByProvider = new Map(creditEntries); activeConfigured = new Set(configuredNames); activeAccountProviders = accountProviders; version++; } /** USD per provider credit, by configured provider name (`providers.<name>.creditPriceUsd`). */ export function activeCreditPrices(): ReadonlyMap<string, number> { return creditPriceByProvider; } /** Active user-configured overlay rows (stable identity until the next refresh). */ export function activeUserCostOverlays(): readonly ExpectedPriceOverlay[] { return active; } /** Monotonic version bumped on pricing-identity changes; used by the estimator memo key. */ export function userCostOverlayVersion(): number { return version; } /** Configured provider names from the last refresh (pricing-namespace identity). */ export function activeConfiguredProviders(): ReadonlySet<string> { return activeConfigured; } /** Account pricing identities built at refresh, without reading credential stores. */ export function activeAccountPricingProviders(): ReadonlyMap<string, string> { return activeAccountProviders; }