@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
177 lines (171 loc) • 7.64 kB
text/typescript
import { formatErrorResponse } from "../bridge";
import {
CodexAccountCooldownError,
CodexMainProfileDrainingError,
codexMainProfileDrainingResponse,
cooldownErrorResponse,
isCodexAuthContextUsable,
materializeCodexUpstreamAuth,
releaseCodexAuthContextProbeLease,
resolveCodexAuthContext,
type CodexAuthContext,
} from "../codex/auth-context";
import { formatCodexProviderForLog } from "../codex/routing";
import type { AdmissionLease } from "../lib/admission";
import { captureExplicitOpenAiCallerAuth, resolveFirstUsableOpenAiSidecar, selectOpenAiImagesProvider } from "../providers/openai-sidecar";
import type { OcxConfig } from "../types";
import { admissionScopeDenial } from "./admission-model-scope";
import {
isProxyAdmissionSecret,
resolveDataPlaneAdmissionSecret,
validateForwardAdmissionCredential,
type DataPlaneAdmission,
type DataPlaneAdmissionOptions,
} from "./auth-cors";
import { codexAccountSelectionForTurn } from "./lifecycle";
import type { RequestLogContext } from "./request-log";
export const TRANSCRIPTION_MODEL = "gpt-4o-transcribe";
export const LIVE_AUDIO_MODEL = "gpt-live-1-codex";
/** Audio keys remain identifiable even on the otherwise unauthenticated local listener. */
export function resolveAudioAdmission(
headers: Headers,
config: OcxConfig,
options: DataPlaneAdmissionOptions = {},
): DataPlaneAdmission | null {
const dedicated = headers.get("x-opencodex-api-key")?.trim();
if (dedicated) return resolveDataPlaneAdmissionSecret(dedicated, config, "dedicated", options);
const authorization = headers.get("authorization")?.trim();
if (authorization) {
const token = /^Bearer\s+([^\s,]+)$/i.exec(authorization)?.[1];
return token ? resolveDataPlaneAdmissionSecret(token, config, "bearer", options) : null;
}
const key = headers.get("x-api-key")?.trim();
return key ? resolveDataPlaneAdmissionSecret(key, config, "x-api-key", options) : null;
}
export interface AudioUpstream {
providerName: string;
providerBaseUrl: string;
headers: Record<string, string>;
keyed: boolean;
authContext?: CodexAuthContext;
recordOutcome?: (status: number | "timeout" | "connect_error") => void;
release: () => void;
}
export interface AudioUpstreamOptions {
admission: DataPlaneAdmission;
model: string;
lease?: AdmissionLease;
exactAccountId?: string;
providerName?: string;
signal?: AbortSignal;
}
/** Keep client admission, account selection, and outbound credentials as separate values. */
export async function resolveAudioUpstream(
incoming: Headers,
config: OcxConfig,
log: RequestLogContext,
options: AudioUpstreamOptions,
): Promise<AudioUpstream | Response> {
const candidates = selectOpenAiImagesProvider(config);
if (options.providerName) {
candidates.forwardCandidates = candidates.forwardCandidates.filter(candidate => candidate.providerName === options.providerName);
if (candidates.keyed?.providerName !== options.providerName) delete candidates.keyed;
}
const headers = new Headers(incoming);
const bearer = headers.get("authorization")?.replace(/^Bearer\s+/i, "").trim();
if (bearer && isProxyAdmissionSecret(bearer, config)) {
headers.delete("authorization");
headers.delete("chatgpt-account-id");
}
headers.delete("x-opencodex-api-key");
headers.delete("x-api-key");
headers.delete("sec-websocket-protocol");
let context: CodexAuthContext | undefined;
try {
options.signal?.throwIfAborted();
const candidate = candidates.forwardCandidates[0];
if (candidate) {
let selected: Headers;
let recordOutcome: AudioUpstream["recordOutcome"];
const beginCodexAccountSelection = codexAccountSelectionForTurn(options.lease);
if (candidate.accountMode === "direct" && options.exactAccountId === undefined
&& !captureExplicitOpenAiCallerAuth(incoming, config)) {
context = await resolveCodexAuthContext(headers, config, "direct", {
admission: options.admission,
substituteMainCredentialForDirect: true,
beginCodexAccountSelection,
signal: options.signal,
});
options.signal?.throwIfAborted();
selected = materializeCodexUpstreamAuth(headers, context, {
config,
admission: options.admission,
substituteMainCredential: true,
});
} else {
const resolved = await resolveFirstUsableOpenAiSidecar(candidates.forwardCandidates, headers, config, {
admission: options.admission,
beginCodexAccountSelection,
signal: options.signal,
...(options.exactAccountId ? { exactAccount: { accountId: options.exactAccountId, modelId: options.model } } : {}),
});
if (!resolved) return formatErrorResponse(401, "authentication_error", "Connect a ChatGPT account to use audio");
context = resolved.authContext;
selected = resolved.headers;
recordOutcome = resolved.recordOutcome;
}
options.signal?.throwIfAborted();
if (!isCodexAuthContextUsable(context, config)) {
releaseCodexAuthContextProbeLease(context);
return formatErrorResponse(401, "authentication_error", "Selected audio account is unavailable");
}
validateForwardAdmissionCredential(selected, config);
// Every audio surface — file transcription, the dictation socket, voice
// call-create and the sideband join — resolves its upstream here, and
// `options.model` is the model that upstream will run, not a selector the
// caller can rewrite afterwards. One check therefore covers all of them.
const forwardDenial = admissionScopeDenial(config, options.admission, options.model, {
providerName: candidate.providerName,
modelId: options.model,
});
if (forwardDenial) {
releaseCodexAuthContextProbeLease(context);
return forwardDenial;
}
log.provider = formatCodexProviderForLog(candidate.providerName, context.accountId, config);
log.model = options.model;
return {
providerName: candidate.providerName,
providerBaseUrl: candidate.provider.baseUrl,
headers: Object.fromEntries(selected),
keyed: false,
authContext: context,
recordOutcome,
release: () => releaseCodexAuthContextProbeLease(context),
};
}
if (candidates.keyed && options.exactAccountId === undefined) {
const { providerName, provider, apiKey } = candidates.keyed;
const selected = new Headers(provider.headers);
selected.set("authorization", `Bearer ${apiKey}`);
validateForwardAdmissionCredential(selected, config);
const keyedDenial = admissionScopeDenial(config, options.admission, options.model, {
providerName,
modelId: options.model,
});
if (keyedDenial) return keyedDenial;
log.provider = providerName;
log.model = options.model;
return {
providerName, providerBaseUrl: provider.baseUrl, headers: Object.fromEntries(selected),
keyed: true, release: () => {},
};
}
return formatErrorResponse(400, "invalid_request_error", "Audio requires a connected ChatGPT account or OpenAI API provider");
} catch (error) {
releaseCodexAuthContextProbeLease(context);
if (error instanceof CodexAccountCooldownError) return cooldownErrorResponse(error);
if (error instanceof CodexMainProfileDrainingError) return codexMainProfileDrainingResponse();
return formatErrorResponse(401, "authentication_error", "Audio account authentication unavailable; reconnect the selected OpenAI account");
}
}