@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
201 lines (185 loc) • 8.19 kB
text/typescript
import type { OcxConfig } from "../../types";
import { isWildcardHostname } from "../../codex/loopback-target";
import { localCredentialDestinationHostname, localInferenceDestination } from "../../lib/local-destinations";
import { isCanonicalOpenAiForwardProvider, OPENAI_API_PROVIDER_ID, OPENAI_CODEX_PROVIDER_ID } from "../../providers/openai-tiers-destination";
import { LIVE_AUDIO_MODEL, TRANSCRIPTION_MODEL } from "../audio-upstream";
import { resolveApiSurfaceSettings, resolveGeminiApiSurface, type ApiSurfaceSetting, type ApiSurfaceSettings } from "../../protocols/settings";
export interface AudioApiAccess {
transcriptionEndpoint: string;
dictationStreamEndpoint: string;
liveEndpoint: string;
realtimeCallsEndpoint: string;
transcriptionModel: string;
liveModel: string;
/** Configuration only, not account health, entitlement or observed connectivity. */
transcriptionConfigured: boolean;
dictationConfigured: boolean;
liveConfigured: boolean;
}
export interface ApiAccessEndpoints {
baseUrl: string;
responsesEndpoint: string;
chatCompletionsEndpoint: string;
messagesEndpoint: string;
modelsEndpoint: string;
geminiModelsEndpoint: string;
/** Which public APIs are served and who decided it, from `resolveApiSurfaceSettings`. */
surfaces: ApiSurfaceSettings & { gemini: ApiSurfaceSetting };
/**
* Back-compat for dashboards that predate `surfaces`: they hide the Messages endpoint when
* this is false. It mirrors `surfaces.messages.enabled`, not `claudeCode.enabled`, so an
* older dashboard never advertises a closed endpoint or hides an open one.
*/
claudeCodeEnabled: boolean;
audio: AudioApiAccess;
/** Back-compat alias for older GUI clients. */
endpoint: string;
}
export type BuildApiAccessEndpointsOptions = {
/** Full request URL (preferred when the bind host is a wildcard). */
requestUrl?: string | URL | null;
/** Raw `Host` header from the inbound request. */
requestHost?: string | null;
/** Raw `Origin` header from the inbound request. */
requestOrigin?: string | null;
};
/**
* Wildcard bind scope, shared with `probeHostname` and the loopback-companion gate rather than
* re-spelled here: a third list of three spellings is how `0.0.0.0.` and `::0` ended up treated
* as specific bind addresses on one side and wildcards on the other.
*/
function isWildcardBindHost(hostname: string | undefined): boolean {
const trimmed = (hostname ?? "").trim();
return !trimmed || isWildcardHostname(trimmed);
}
/** Bracket bare IPv6 literals for URL authority composition. */
export function formatAuthorityHost(hostname: string): string {
const trimmed = hostname.trim();
if (!trimmed) return "127.0.0.1";
if (trimmed.startsWith("[") && trimmed.endsWith("]")) return trimmed;
return trimmed.includes(":") ? `[${trimmed}]` : trimmed;
}
function hostnameFromAuthority(authority: string): string | null {
const raw = authority.trim();
if (!raw) return null;
if (raw.startsWith("[")) {
const end = raw.indexOf("]");
if (end > 0) return raw.slice(1, end) || null;
return null;
}
// Host headers for IPv6 are bracketed; treat multi-colon values as unusable.
if (raw.includes(":") && raw.split(":").length > 2) return null;
const colon = raw.lastIndexOf(":");
if (colon > 0 && /^\d+$/.test(raw.slice(colon + 1))) {
return raw.slice(0, colon) || null;
}
return raw;
}
function originBaseUrl(raw: string): string | null {
try {
const url = new URL(raw);
if (!url.hostname || isWildcardBindHost(url.hostname)) return null;
return `${url.protocol}//${url.host}/v1`;
} catch {
return null;
}
}
/**
* Prefer the client's request host/origin when the proxy is bound to a wildcard.
* Falls back to loopback only when no usable request context is available.
*/
export function resolveApiAccessBaseUrl(
config: Pick<OcxConfig, "hostname" | "port" | "unauthenticatedLoopbackListener">,
opts: BuildApiAccessEndpointsOptions = {},
): string {
const port = config.port ?? 10100;
if (!isWildcardBindHost(config.hostname)) {
return `http://${localCredentialDestinationHostname(config.hostname)}:${port}/v1`;
}
const fromOrigin = opts.requestOrigin ? originBaseUrl(opts.requestOrigin) : null;
if (fromOrigin) return fromOrigin;
if (opts.requestUrl) {
try {
const url = typeof opts.requestUrl === "string" ? new URL(opts.requestUrl) : opts.requestUrl;
if (url.hostname && !isWildcardBindHost(url.hostname)) {
return `${url.protocol}//${url.host}/v1`;
}
} catch {
/* ignore malformed request URL */
}
}
const hostHeader = opts.requestHost?.trim();
if (hostHeader) {
const hostname = hostnameFromAuthority(hostHeader);
if (hostname && !isWildcardBindHost(hostname)) {
// Preserve an explicit port from the Host header; otherwise use the bind port.
const hasPort = hostHeader.startsWith("[")
? /\]:\d+$/.test(hostHeader)
: /:\d+$/.test(hostHeader) && hostHeader.split(":").length === 2;
const authority = hasPort
? (hostHeader.startsWith("[") ? hostHeader : hostHeader)
: `${formatAuthorityHost(hostname)}:${port}`;
return `http://${authority}/v1`;
}
}
// Last resort: a wildcard bind with no usable request context, so the only address we can
// name is loopback — and on that address the unauthenticated loopback listener, when one is
// enabled, is the port a local caller should use (#4236). The branches above are unchanged:
// a specific bind or a real request host still describes the address the CLIENT reached.
return `${localInferenceDestination(config, port).origin}/v1`;
}
/** @deprecated Prefer resolveApiAccessBaseUrl; retained for focused host-format tests. */
export function resolveApiAccessDisplayHost(
configHostname: string | undefined,
opts: BuildApiAccessEndpointsOptions = {},
): string {
if (!isWildcardBindHost(configHostname)) {
return localCredentialDestinationHostname(configHostname);
}
try {
return new URL(resolveApiAccessBaseUrl({ hostname: configHostname, port: 10100 }, opts)).hostname
|| "127.0.0.1";
} catch {
return "127.0.0.1";
}
}
export function buildApiAccessEndpoints(
config: OcxConfig,
opts: BuildApiAccessEndpointsOptions = {},
): ApiAccessEndpoints {
const baseUrl = resolveApiAccessBaseUrl(config, opts);
const responsesEndpoint = `${baseUrl}/responses`;
const socketBase = new URL(baseUrl);
socketBase.protocol = socketBase.protocol === "https:" ? "wss:" : "ws:";
const forward = config.providers?.[OPENAI_CODEX_PROVIDER_ID];
const chatgptConfigured = !!forward && forward.disabled !== true
&& isCanonicalOpenAiForwardProvider({ ...forward, authMode: forward.authMode ?? "forward" });
const keyed = config.providers?.[OPENAI_API_PROVIDER_ID];
// Do not resolve key references or inspect accounts on a management metadata read.
const apiConfigured = !!keyed && keyed.disabled !== true && keyed.adapter === "openai-responses"
&& keyed.authMode !== "forward" && keyed.baseUrl.replace(/\/+$/, "") === "https://api.openai.com/v1"
&& typeof keyed.apiKey === "string" && !!keyed.apiKey.trim();
const surfaces = resolveApiSurfaceSettings(config);
return {
baseUrl,
responsesEndpoint,
chatCompletionsEndpoint: `${baseUrl}/chat/completions`,
messagesEndpoint: `${baseUrl}/messages`,
modelsEndpoint: `${baseUrl}/models`,
geminiModelsEndpoint: baseUrl.replace(/\/v1$/, "/v1beta/models"),
surfaces: { ...surfaces, gemini: resolveGeminiApiSurface(config) },
claudeCodeEnabled: surfaces.messages.enabled,
audio: {
transcriptionEndpoint: `${baseUrl}/audio/transcriptions`,
dictationStreamEndpoint: `${socketBase.href}/audio/transcriptions/stream`,
liveEndpoint: `${socketBase.href}/live`,
realtimeCallsEndpoint: `${baseUrl}/realtime/calls`,
transcriptionModel: TRANSCRIPTION_MODEL,
liveModel: LIVE_AUDIO_MODEL,
transcriptionConfigured: chatgptConfigured || apiConfigured,
dictationConfigured: chatgptConfigured,
liveConfigured: chatgptConfigured,
},
endpoint: responsesEndpoint,
};
}