@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
253 lines (238 loc) • 14.6 kB
text/typescript
import type { OcxConfig, OcxProviderConfig } from "../types";
import { getConfigDir } from "../config/paths";
import { isEgressTransparentExecutor, markEgressTransparentExecutor } from "../lib/provider-egress";
import { isPassiveKeyDeferred, isPassiveKeyTransparent, PASSIVE_KEY_SEND } from "../lib/passive-key-fetch-proof";
import { isKeychainReference, passiveKeychainGeneration, peekResolvedProviderKey, resolveProviderApiKeyPassively } from "./api-key-resolve";
import { passiveKeyLimits, type PassiveKeyProvider } from "./quota/passive-key-limits";
import { extractPassiveWireModel } from "./quota/passive-wire-model";
const destinations = new Map<string, PassiveKeyProvider>([
["https://api.openai.com", "openai"], ["https://api.anthropic.com", "anthropic"],
["https://api.x.ai", "xai"], ["https://api.groq.com", "groq"], ["https://api.mistral.ai", "mistral"],
]);
const paths: Record<PassiveKeyProvider, readonly string[]> = {
openai: ["/v1/chat/completions", "/v1/responses", "/v1/responses/compact"],
anthropic: ["/v1/messages"], xai: ["/v1/chat/completions", "/v1/responses"],
groq: ["/openai/v1/chat/completions"], mistral: ["/v1/chat/completions"],
};
let sequence = 0;
const seenResponses = new WeakSet<Response>();
// Account identities contain only hashes. Eviction also revokes reservations in the limit cache.
const incarnations = new Map<string, { home: string; name: string; owner: string }>();
const MAX_INCARNATIONS = 512;
/** Fields that can change the destination or account owning a passive observation. */
export function passiveProviderOwnership(provider: OcxProviderConfig | undefined): unknown {
if (!provider) return null;
return structuredClone({
adapter: provider.adapter, baseUrl: provider.baseUrl, authMode: provider.authMode ?? "key",
disabled: provider.disabled === true, apiKey: provider.apiKey,
apiKeyPool: provider.apiKeyPool?.map(({ id, key, disabled }) => ({ id, key, disabled: disabled === true }))
.sort((a, b) => a.id.localeCompare(b.id) || a.key.localeCompare(b.key)),
apiKeyTransport: provider.apiKeyTransport, headers: provider.headers,
responsesPath: provider.responsesPath, chatCompletionsPath: provider.chatCompletionsPath,
modelAdapters: provider.modelAdapters,
});
}
/**
* Invalidate both stored and in-flight observations after key-store mutation.
*
* The home is captured here rather than read per entry: rows observed under another config
* home belong to that installation and stay untouched.
*/
export function clearPassiveKeyLimits(name?: string, home: string = getConfigDir()): void {
passiveKeyLimits.clear(home, name);
for (const [scope, entry] of incarnations) {
if (entry.home === home && (name === undefined || entry.name === name)) incarnations.delete(scope);
}
}
function accountScope(home: string, name: string, id: string): string {
return new Bun.CryptoHasher("sha256").update(JSON.stringify([home, name, id])).digest("hex");
}
/** Stable opaque identifier for quota presentation, scoped to this installation and provider. */
export function passiveKeyQuotaId(name: string, id: string, home: string = getConfigDir()): string {
return accountScope(home, name, id);
}
/** Retire all models and outstanding reservations for one account incarnation. */
export function clearPassiveKeyAccount(name: string, id: string, home: string = getConfigDir()): void {
const scope = accountScope(home, name, id);
passiveKeyLimits.clear(home, name, scope);
incarnations.delete(scope);
}
function keyId(reference: string): string {
return new Bun.CryptoHasher("sha256").update(reference).digest("hex").slice(0, 8);
}
function identity(home: string, name: string, provider: OcxProviderConfig, id: string, reference: string, key: string | undefined): string | undefined {
const generation = isKeychainReference(reference) ? passiveKeychainGeneration(reference, key) : null;
if (generation === undefined) return undefined;
if (generation !== null) key = undefined;
return new Bun.CryptoHasher("sha256").update(JSON.stringify([home, name, provider.adapter, provider.baseUrl, id, reference, key, generation])).digest("hex");
}
function currentKey(reference: string): string | undefined {
return resolveProviderApiKeyPassively(reference);
}
function remember(home: string, name: string, id: string, owner: string): { home: string; name: string; owner: string } {
const scope = accountScope(home, name, id);
const previous = incarnations.get(scope);
if (previous && previous.owner !== owner) clearPassiveKeyAccount(name, id, home);
incarnations.delete(scope);
const incarnation = previous?.owner === owner ? previous : { home, name, owner };
incarnations.set(scope, incarnation);
if (incarnations.size > MAX_INCARNATIONS) {
const oldest = incarnations.keys().next().value!;
const entry = incarnations.get(oldest)!;
passiveKeyLimits.clear(entry.home, entry.name, oldest);
incarnations.delete(oldest);
}
return incarnation;
}
/** Poll only accounts already observed; a changed value revokes every model and flight. */
function currentOwner(home: string, name: string, provider: OcxProviderConfig, id: string, reference: string): string | undefined {
const existing = incarnations.get(accountScope(home, name, id));
if (!existing) return undefined;
// A cache clear suspends proof until routing rereads the account. Keep the bounded
// observation for a matching reread, but never expose it while unverified.
if (isKeychainReference(reference) && peekResolvedProviderKey(reference) === undefined) return undefined;
try {
const key = isKeychainReference(reference) ? undefined : currentKey(reference);
const owner = (key || isKeychainReference(reference)) && identity(home, name, provider, id, reference, key);
if (owner === existing.owner) return owner;
} catch { /* A malformed account cannot invalidate another account's projection. */ }
clearPassiveKeyAccount(name, id, home);
return undefined;
}
/** A selected account remains the owner after a different account becomes active. */
function stillConfigured(config: OcxConfig, name: string, snapshot: OcxProviderConfig, home: string): boolean {
const current = config.providers[name];
const selection = snapshot._apiKeyAttempt;
if (!current || current.disabled || !selection?.reference || !snapshot.apiKey
|| (current.authMode !== undefined && current.authMode !== "key")
|| current.adapter !== snapshot.adapter || current.baseUrl !== snapshot.baseUrl) return false;
const reference = selection.reference;
if (current.apiKeyPool?.length) {
const row = current.apiKeyPool.find(entry => entry.id === selection.entryId && entry.key === reference);
if (!row || row.disabled) return false;
} else if (current.apiKey !== reference) return false;
const id = selection.entryId ?? keyId(reference);
const matches = isKeychainReference(reference)
? passiveKeychainGeneration(reference, snapshot.apiKey) !== undefined
: currentKey(reference) === snapshot.apiKey;
if (!matches) {
currentOwner(home, name, current, id, reference);
return false;
}
return true;
}
/** Record only a configured key at the final destination and credential boundary. */
export function passiveKeyPhysicalFetch(
physicalFetch: typeof globalThis.fetch, config: OcxConfig, name: string, provider: OcxProviderConfig,
): typeof globalThis.fetch {
if (!isPassiveKeyTransparent(physicalFetch) || (provider.authMode !== undefined && provider.authMode !== "key") || !provider.apiKey || !provider._apiKeyAttempt?.reference) return physicalFetch;
const snapshot = { ...provider, _apiKeyAttempt: { ...provider._apiKeyAttempt } };
// The observing home is captured with the send. A later config-home change cannot migrate or
// expose these rows, and management reads resolve their own home independently.
const home = getConfigDir();
const wrapped = (async (input, init) => {
const url = input instanceof Request ? input.url : String(input);
let destination: URL;
try { destination = new URL(url); } catch { return physicalFetch(input, init); }
const vendor = destinations.get(destination.origin);
const key = snapshot.apiKey!;
let owned = false;
try {
owned = !!vendor && new URL(snapshot.baseUrl).origin === destination.origin
&& destination.protocol === "https:" && !destination.username && !destination.password
&& paths[vendor].includes(destination.pathname) && !destination.search && !destination.hash
&& (vendor !== "openai" || key.startsWith("sk-"));
} catch { /* An unprovable owner cannot receive a passive observation. */ }
if (owned) {
const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined));
const expectedAuth = vendor === "anthropic" && snapshot.apiKeyTransport !== "bearer"
? headers.get("x-api-key") === key && !headers.has("authorization")
: headers.get("authorization") === `Bearer ${key}` && !headers.has("x-api-key");
try { owned = !headers.has("api-key") && expectedAuth && stillConfigured(config, name, snapshot, home); }
catch { owned = false; /* An unprovable owner cannot receive a passive observation. */ }
}
const wireBody = init?.body;
const model = owned ? extractPassiveWireModel(wireBody) : undefined;
const delayed = isPassiveKeyDeferred(physicalFetch);
const generation = isKeychainReference(snapshot._apiKeyAttempt!.reference!) ? passiveKeychainGeneration(snapshot._apiKeyAttempt!.reference!, key) : undefined;
let reservation: ReturnType<typeof passiveKeyLimits.reserve>;
let atSend: ((wireInput: RequestInfo | URL, wireInit?: RequestInit) => void) | undefined;
try {
if (owned && vendor && model) {
const reference = snapshot._apiKeyAttempt!.reference!;
const id = snapshot._apiKeyAttempt!.entryId ?? keyId(reference);
const owner = identity(home, name, snapshot, id, reference, key);
if (owner) {
const scope = accountScope(home, name, id);
const incarnation = remember(home, name, id, owner);
atSend = (wireInput, wireInit) => {
try {
if (delayed) {
const wireUrl = wireInput instanceof Request ? wireInput.url : String(wireInput);
const headers = new Headers(wireInit?.headers ?? (wireInput instanceof Request ? wireInput.headers : undefined));
const authMatches = vendor === "anthropic" && snapshot.apiKeyTransport !== "bearer"
? headers.get("x-api-key") === key && !headers.has("authorization")
: headers.get("authorization") === `Bearer ${key}` && !headers.has("x-api-key");
if (wireUrl !== url || headers.has("api-key") || !authMatches || wireInit?.body !== wireBody) return;
}
if (incarnations.get(scope) !== incarnation || !stillConfigured(config, name, snapshot, home)
|| (isKeychainReference(reference) && (generation === undefined || generation !== passiveKeychainGeneration(reference, key)))) return;
reservation = passiveKeyLimits.reserve({ home, owner, provider: vendor, model, namespace: name, account: scope }, ++sequence);
} catch { /* Observation cannot prevent a proxied send. */ }
};
}
}
} catch { /* Reservation failure cannot prevent a proxied send. */ }
try {
if (!delayed) atSend?.(input, init);
const physicalInit = delayed && atSend ? Object.assign({}, init, { [PASSIVE_KEY_SEND]: atSend }) : init;
const response = await physicalFetch(input, physicalInit);
const reused = seenResponses.has(response);
seenResponses.add(response);
try {
if (reservation && !reused && (!isKeychainReference(snapshot._apiKeyAttempt!.reference!) || (generation !== undefined && generation === passiveKeychainGeneration(snapshot._apiKeyAttempt!.reference!, key))) && stillConfigured(config, name, snapshot, home)) {
reservation.record(response.headers, Date.now(), response.status);
}
} catch { /* Passive display evidence must not fail the proxied response. */ }
return response;
} finally { reservation?.cancel(); }
}) as typeof globalThis.fetch;
return isEgressTransparentExecutor(physicalFetch) ? markEgressTransparentExecutor(wrapped) : wrapped;
}
/** Read the current configured key only; missing or replaced keys cannot inherit observations. */
export function getPassiveKeyLimits(config: OcxConfig, name: string, model: string) {
const provider = config.providers[name];
if (!provider || (provider.authMode !== undefined && provider.authMode !== "key") || !provider.apiKey) return [];
let vendor: PassiveKeyProvider | undefined;
try { vendor = destinations.get(new URL(provider.baseUrl).origin); } catch { return []; }
if (!vendor) return [];
const id = provider.apiKeyPool?.find(entry => entry.key === provider.apiKey)?.id ?? keyId(provider.apiKey);
const home = getConfigDir();
const owner = currentOwner(home, name, provider, id, provider.apiKey);
if (!owner) return [];
return owner ? passiveKeyLimits.get({ home, owner, provider: vendor, model }, Date.now()) : [];
}
/** Cached-only projection, scoped to configured account IDs and without credential material. */
export function listPassiveKeyLimits(config: OcxConfig) {
const result: Array<{ provider: string; keyId: string; model: string; windows: ReturnType<typeof passiveKeyLimits.get> }> = [];
const home = getConfigDir();
for (const [name, provider] of Object.entries(config.providers)) {
if (provider.disabled || (provider.authMode !== undefined && provider.authMode !== "key")) continue;
let vendor: PassiveKeyProvider | undefined;
try { vendor = destinations.get(new URL(provider.baseUrl).origin); } catch { continue; }
if (!vendor) continue;
const entries = provider.apiKeyPool?.length ? provider.apiKeyPool : provider.apiKey
? [{ id: keyId(provider.apiKey), key: provider.apiKey }] : [];
for (const entry of entries) {
try {
if ("disabled" in entry && entry.disabled) continue;
const owner = currentOwner(home, name, provider, entry.id, entry.key);
if (!owner) continue;
for (const reading of passiveKeyLimits.list(home, owner, vendor, Date.now())) {
result.push({ provider: name, keyId: passiveKeyQuotaId(name, entry.id, home), ...reading });
}
} catch { /* One invalid account cannot reject the whole projection. */ }
}
}
return result;
}