@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
232 lines (209 loc) • 8.94 kB
text/typescript
import { readBoundedResponseBody } from "../lib/bounded-body";
import { markEgressTransparentExecutor, providerEgressSendInit } from "../lib/provider-egress";
import { configuredOutboundFetch } from "../lib/proxy-env";
import { withUpstreamHttpVersion } from "../lib/upstream-http-version";
import type { OcxProviderConfig } from "../types";
/**
* Per-key project discovery for Vertex express-mode API keys (`provider.project: "auto"`).
*
* An express-mode key belongs to one Google Cloud project, and Google's projectless endpoint
* echoes `projects/<number>/locations/<region>/...` in its 404 body for a nonexistent model
* (observed 2026-10-18 across five express-mode keys on `aiplatform.googleapis.com`). That is an
* undocumented upstream error shape rather than a stable discovery API, so `"auto"` is strictly
* opt-in and any non-404, truncated, oversized, invalid-UTF-8 or non-matching body falls back to
* the projectless express endpoint without caching.
*/
export const VERTEX_PROJECT_AUTO = "auto";
const PROBE_URL = "https://aiplatform.googleapis.com/v1/publishers/google/models/ocx-project-probe:countTokens";
const PROBE_TIMEOUT_MS = 10_000;
/** Google's 404 JSON for a missing publisher model is ~320 bytes; 4 KiB bounds untrusted bodies. */
export const VERTEX_PROBE_MAX_BYTES = 4096;
const PROJECT_NUMBER = /\bprojects\/(\d{1,20})\/locations\//;
/** Pool sizes are small; the cap only bounds a pathological rotation of distinct keys. */
const CACHE_LIMIT = 64;
/** Keyed by a SHA-256 digest so the cache never retains raw key material. Insertion-order LRU. */
const resolved = new Map<string, string>();
interface ProbeWaiter {
signal?: AbortSignal;
resolve: (project: string | undefined) => void;
reject: (reason: unknown) => void;
onAbort?: () => void;
}
interface InflightProbe {
controller: AbortController;
waiters: Set<ProbeWaiter>;
}
const inflight = new Map<string, InflightProbe>();
/** Computes the non-reversible SHA-256 cache key for an API key. */
function cacheKey(apiKey: string): string {
return new Bun.CryptoHasher("sha256").update(apiKey).digest("base64url");
}
/** Records a resolved project number in the bounded insertion-order LRU cache. */
function remember(key: string, project: string): void {
resolved.delete(key);
resolved.set(key, project);
while (resolved.size > CACHE_LIMIT) resolved.delete(resolved.keys().next().value!);
}
/** Extracts the project number from Google's projectless NOT_FOUND body; exported for tests. */
export function parseVertexProbeProjectNumber(body: string): string | undefined {
return PROJECT_NUMBER.exec(body)?.[1];
}
export interface VertexKeyProjectOptions {
fetch?: typeof fetch;
signal?: AbortSignal;
provider?: OcxProviderConfig;
providerName?: string;
beforeSend?: () => void;
/** Test seam for the bounded-body and request deadline. */
timeoutMs?: number;
}
const defaultOutboundFetch = markEgressTransparentExecutor(
((input: Parameters<typeof fetch>[0], init?: RequestInit) => configuredOutboundFetch(input, init)) as typeof fetch,
);
/** Builds the side-effect-free outbound transport honoring provider egress and HTTP version. */
function selectProbeFetch(options: VertexKeyProjectOptions): typeof fetch {
if (options.fetch) return options.fetch;
const provider = options.provider;
const customFetch = (provider as (OcxProviderConfig & { fetch?: typeof fetch }) | undefined)?.fetch;
if (!provider) return customFetch ?? globalThis.fetch;
const base = customFetch ?? defaultOutboundFetch;
const providerName = options.providerName ?? "google-vertex";
return ((input: Parameters<typeof fetch>[0], init?: RequestInit) => {
const egressInit = providerEgressSendInit({ providerName, provider }, base, input);
const versioned = withUpstreamHttpVersion(input, init, provider);
return base(input, { ...versioned, ...egressInit });
}) as typeof fetch;
}
/** Sends one bounded countTokens probe to Google and extracts the project number from a 404 body. */
async function probe(
apiKey: string,
fetchImpl: typeof fetch,
signal: AbortSignal,
timeoutMs: number,
beforeSend?: () => void,
): Promise<string | undefined> {
const probeSignal = AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]);
beforeSend?.();
try {
const res = await fetchImpl(PROBE_URL, {
method: "POST",
redirect: "manual",
headers: { "content-type": "application/json", "x-goog-api-key": apiKey },
body: JSON.stringify({ contents: [{ role: "user", parts: [{ text: "x" }] }] }),
signal: probeSignal,
});
// Only Google's model NOT_FOUND names the key's project; 401/403/429 and redirects do not.
if (res.status !== 404) {
void res.body?.cancel().catch(() => {});
return undefined;
}
const body = await readBoundedResponseBody(res, {
maxBytes: VERTEX_PROBE_MAX_BYTES,
totalTimeoutMs: timeoutMs,
inactivityTimeoutMs: timeoutMs,
firstByteTimeoutMs: timeoutMs,
signal: probeSignal,
reportUtf8Validity: true,
});
if (body.truncated || body.oversized || body.timedOut || !body.displaySafe || body.utf8Valid === false) {
return undefined;
}
return parseVertexProbeProjectNumber(body.text);
} catch {
return undefined;
}
}
/** Detaches the abort listener registered for a coalesced probe waiter. */
function cleanupWaiter(waiter: ProbeWaiter): void {
if (waiter.signal && waiter.onAbort) {
waiter.signal.removeEventListener("abort", waiter.onAbort);
}
}
/** Starts a shared in-flight probe and fans the result out to all active waiters. */
function startInflight(
key: string,
apiKey: string,
fetchImpl: typeof fetch,
timeoutMs: number,
beforeSend?: () => void,
): InflightProbe {
const controller = new AbortController();
const waiters = new Set<ProbeWaiter>();
const entry: InflightProbe = { controller, waiters };
inflight.set(key, entry);
void (async () => {
let project: string | undefined;
let failure: unknown;
try {
project = await probe(apiKey, fetchImpl, controller.signal, timeoutMs, beforeSend);
} catch (error) {
failure = error;
} finally {
if (inflight.get(key) === entry) inflight.delete(key);
}
if (project && !controller.signal.aborted) remember(key, project);
for (const waiter of Array.from(waiters)) {
cleanupWaiter(waiter);
if (waiter.signal?.aborted) waiter.reject(waiter.signal.reason);
else if (failure !== undefined) waiter.reject(failure);
else waiter.resolve(project);
}
})();
return entry;
}
/**
* Resolves the project number that owns `apiKey`, or undefined when Google does not reveal it.
* Successful lookups are cached per key; failures are not, so a transient error retries next time.
* Concurrent callers for the same uncached key share one probe; an aborted caller detaches
* immediately without cancelling the shared probe unless every waiter has aborted.
*/
export async function resolveVertexApiKeyProject(
apiKey: string,
options: VertexKeyProjectOptions | typeof fetch = {},
): Promise<string | undefined> {
const opts: VertexKeyProjectOptions = typeof options === "function" ? { fetch: options } : options;
const signal = opts.signal;
signal?.throwIfAborted();
const key = cacheKey(apiKey);
const cached = resolved.get(key);
if (cached) {
remember(key, cached);
return cached;
}
// Synchronous egress validation (for example an opaque custom fetch combined with an explicit
// provider.proxy) must reject the caller rather than being swallowed into an express fallback.
const fetchImpl = selectProbeFetch(opts);
const timeoutMs = opts.timeoutMs ?? PROBE_TIMEOUT_MS;
const entry = inflight.get(key) ?? startInflight(key, apiKey, fetchImpl, timeoutMs, opts.beforeSend);
return new Promise<string | undefined>((resolve, reject) => {
if (signal?.aborted) {
if (entry.waiters.size === 0) {
if (inflight.get(key) === entry) inflight.delete(key);
entry.controller.abort(signal.reason);
}
reject(signal.reason);
return;
}
const waiter: ProbeWaiter = { signal, resolve, reject };
if (signal) {
const onAbort = () => {
signal.removeEventListener("abort", onAbort);
entry.waiters.delete(waiter);
reject(signal.reason);
if (entry.waiters.size === 0) {
if (inflight.get(key) === entry) inflight.delete(key);
entry.controller.abort(signal.reason);
}
};
waiter.onAbort = onAbort;
signal.addEventListener("abort", onAbort, { once: true });
}
entry.waiters.add(waiter);
});
}
/** Clears the resolved project cache and aborts any in-flight probes for tests. */
export function __resetVertexApiKeyProjectCache(): void {
resolved.clear();
for (const entry of inflight.values()) entry.controller.abort();
inflight.clear();
}