@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
197 lines (192 loc) • 11.9 kB
text/typescript
import { createHash } from "node:crypto";
import { formatErrorResponse } from "../bridge";
import { MAIN_CODEX_ACCOUNT_ID } from "../codex/account-id";
import { isolateCodexPoolClientMetadata } from "../codex/forward-transport-headers";
import { CodexInstallationIdUnavailableError } from "../codex/installation-id";
import { cancelBodyOnAbort, clearableDeadline } from "../lib/abort";
import type { AdmissionLease } from "../lib/admission";
import { captureExplicitOpenAiCallerAuth } from "../providers/openai-sidecar";
import type { OcxConfig } from "../types";
import type { AudioClient } from "./audio-client";
import { finishAudioUpstream, type AudioSocketTarget } from "./audio-dictation";
import { LIVE_AUDIO_MODEL, resolveAudioUpstream, type AudioUpstream } from "./audio-upstream";
import { registerTurn, unregisterTurn } from "./lifecycle";
import {
backendJsonBodyFromApiMultipart, buildLiveSidebandUpstreamWsUrl, forwardLiveUrl, keyedLiveUrl,
LIVE_CLIENT_PROTOCOL_HEADERS, LIVE_REQUEST_MAX_BYTES, LIVE_RESPONSE_MAX_BYTES, liveSidebandModel,
readBodyCapped,
type LiveSidebandTarget,
} from "./live";
import { LIVE_CALL_TTL_MS, LiveCallBindings, upstreamLiveCallId } from "./live-call-bindings";
import type { RequestLogContext } from "./request-log";
function protocolHeaders(client: AudioClient, relay: AudioUpstream, frameless: boolean): Headers {
const headers = new Headers();
for (const name of LIVE_CLIENT_PROTOCOL_HEADERS) {
const value = client.headers.get(name);
if (value) headers.set(name, value);
}
for (const [name, value] of Object.entries(relay.headers)) headers.set(name, value);
if (frameless && !headers.has("openai-alpha")) headers.set("openai-alpha", "quicksilver=v2");
return headers;
}
async function parseExternalOffer(req: Request, signal: AbortSignal): Promise<{ sdp: string; session?: Record<string, unknown> } | Response> {
const upload = clearableDeadline(30_000, signal);
try {
const body = await readBodyCapped(req.body, LIVE_REQUEST_MAX_BYTES, () => "Live offer too large", upload.signal);
if (body instanceof Response) return formatErrorResponse(413, "invalid_request_error", "Live offer exceeds 16 MiB");
const type = req.headers.get("content-type") ?? "";
let payload: unknown;
if (type.toLowerCase().includes("multipart/form-data")) {
const converted = await backendJsonBodyFromApiMultipart(body, type);
if (converted instanceof Response) return converted;
payload = JSON.parse(new TextDecoder().decode(converted.body));
} else if (type.toLowerCase().includes("application/json")) {
payload = JSON.parse(new TextDecoder().decode(body));
} else if (type.toLowerCase().includes("application/sdp")) {
payload = { sdp: new TextDecoder().decode(body) };
}
if (!payload || typeof payload !== "object" || !("sdp" in payload) || typeof payload.sdp !== "string" || !payload.sdp.trim()) {
return formatErrorResponse(400, "invalid_request_error", "Live call requires a nonempty SDP offer");
}
const session = "session" in payload ? payload.session : undefined;
if (session !== undefined && (!session || typeof session !== "object" || Array.isArray(session))) {
return formatErrorResponse(400, "invalid_request_error", "Live session must be an object");
}
return { sdp: payload.sdp, ...(session ? { session: session as Record<string, unknown> } : {}) };
} catch {
if (signal.aborted) throw signal.reason;
return formatErrorResponse(upload.didExpire() ? 408 : 400, "invalid_request_error", upload.didExpire() ? "Live offer upload timed out" : "Malformed live offer");
} finally { upload.clear(); }
}
export async function handleExternalLive(
req: Request, config: OcxConfig, log: RequestLogContext,
options: { client: AudioClient; lease: AdmissionLease; bindings: LiveCallBindings },
): Promise<Response> {
const controller = new AbortController();
registerTurn(controller, options.lease);
const deadline = clearableDeadline(120_000, AbortSignal.any([req.signal, controller.signal]));
let relay: AudioUpstream | undefined;
let outcome: number | "timeout" | "connect_error" | undefined;
try {
const offer = await parseExternalOffer(req, deadline.signal);
if (offer instanceof Response) return offer;
if (!options.bindings.hasCapacity()) return formatErrorResponse(503, "server_busy", "Live call capacity reached");
const frameless = new URL(req.url).pathname === "/v1/live";
let session = offer.session ? { ...offer.session } : frameless ? {
model: LIVE_AUDIO_MODEL, instructions: "", audio: { output: { voice: "cove" } }, delegation: { type: "client" },
} : undefined;
if (session?.model === "gpt-live-1") session.model = LIVE_AUDIO_MODEL;
const model = typeof session?.model === "string" ? session.model : LIVE_AUDIO_MODEL;
const resolved = await resolveAudioUpstream(options.client.headers, config, log, {
admission: options.client.admission, model, lease: options.lease, signal: deadline.signal,
});
if (!(resolved instanceof Response)) relay = resolved;
deadline.signal.throwIfAborted();
if (resolved instanceof Response) return resolved;
relay = resolved;
session = isolateCodexPoolClientMetadata(session, relay.authContext?.kind === "pool"
? relay.authContext.chatgptAccountId : undefined) as typeof session;
const headers = protocolHeaders(options.client, relay, frameless);
let body: BodyInit;
if (relay.keyed) {
const form = new FormData();
form.set("sdp", offer.sdp);
if (session) form.set("session", JSON.stringify(session));
headers.delete("content-type");
body = form;
} else {
headers.set("content-type", "application/json");
body = JSON.stringify({ sdp: offer.sdp, ...(session ? { session } : {}) });
}
const url = relay.keyed
? frameless ? forwardLiveUrl(relay.providerBaseUrl, false) : keyedLiveUrl(relay.providerBaseUrl)
: forwardLiveUrl(relay.providerBaseUrl, true);
const upstream = await fetch(url, { method: "POST", headers, body, signal: deadline.signal, redirect: "manual" });
outcome = upstream.status;
const detach = cancelBodyOnAbort(upstream.body, deadline.signal);
let responseBody: ArrayBuffer | Response;
try { responseBody = await readBodyCapped(upstream.body, LIVE_RESPONSE_MAX_BYTES, () => "Live answer too large", deadline.signal); }
finally { detach(); }
if (responseBody instanceof Response) return responseBody;
if (!upstream.ok) return formatErrorResponse(upstream.status >= 400 ? upstream.status : 502, "upstream_error", `Live upstream returned HTTP ${upstream.status}`);
const callId = upstreamLiveCallId(upstream.headers.get("location"));
if (!callId || responseBody.byteLength === 0) return formatErrorResponse(502, "upstream_error", "Live upstream returned an invalid call answer");
const context = relay.authContext;
const callerOwned = context?.kind === "main" && captureExplicitOpenAiCallerAuth(options.client.headers, config) !== null;
const alias = options.bindings.create({
owner: options.client.owner, upstreamCallId: callId,
joinStyle: frameless ? "frameless-path" : "realtime-query",
providerName: relay.providerName,
// A join carries no model of its own; this is the one the call settled on.
model,
accountId: context ? context.kind === "main" ? callerOwned ? undefined : MAIN_CODEX_ACCOUNT_ID : context.accountId : undefined,
chatgptAccountId: new Headers(relay.headers).get("chatgpt-account-id") ?? undefined,
keyedCredentialDigest: relay.keyed ? createHash("sha256").update(new Headers(relay.headers).get("authorization") ?? "").digest("hex") : undefined,
callerOwned,
sidebandBaseUrl: config.experimentalRealtimeWsBaseUrl,
});
if (!alias) return formatErrorResponse(503, "server_busy", "Live call could not be registered");
return new Response(responseBody, { status: upstream.status, headers: {
"content-type": upstream.headers.get("content-type") ?? "application/sdp",
location: `/v1/${frameless ? "live" : "realtime/calls"}/${alias}`,
} });
} catch (error) {
if (error instanceof CodexInstallationIdUnavailableError) return formatErrorResponse(503, "server_busy", error.message);
if (req.signal.aborted || controller.signal.aborted) {
outcome = undefined;
return formatErrorResponse(req.signal.aborted ? 499 : 503, "client_closed_request", "Live call canceled");
}
outcome = deadline.didExpire() ? "timeout" : "connect_error";
return formatErrorResponse(deadline.didExpire() ? 504 : 502, "upstream_error", deadline.didExpire() ? "Live call timed out" : "Live upstream connection failed");
} finally {
try { if (outcome !== undefined) relay?.recordOutcome?.(outcome); }
finally { relay?.release(); deadline.clear(); unregisterTurn(controller); }
}
}
export async function resolveExternalLiveSocket(
client: AudioClient, config: OcxConfig, log: RequestLogContext, target: LiveSidebandTarget,
options: { lease: AdmissionLease; bindings: LiveCallBindings; signal?: AbortSignal },
): Promise<AudioSocketTarget | Response> {
const binding = "callId" in target ? options.bindings.get(target.callId, client.owner) : undefined;
if ("callId" in target && !binding) return formatErrorResponse(404, "not_found", "Live call is unavailable for this key");
if (binding?.callerOwned && !captureExplicitOpenAiCallerAuth(client.headers, config)) {
return formatErrorResponse(401, "authentication_error", "Live call requires its original caller account");
}
let upstreamTarget = binding ? { style: binding.joinStyle, callId: binding.upstreamCallId } as LiveSidebandTarget : target;
const frameless = upstreamTarget.style === "frameless-path" || upstreamTarget.style === "frameless-standalone";
if (upstreamTarget.style === "frameless-standalone") {
const query = new URLSearchParams(upstreamTarget.query);
if (!query.has("model") || query.get("model") === "gpt-live-1") query.set("model", LIVE_AUDIO_MODEL);
upstreamTarget = { ...upstreamTarget, query: query.toString() };
}
// What this socket will actually run: the model a bound call settled on when
// this same key created it, or the one a standalone session forwards in its
// own query. Reading only the Frameless query left a Realtime standalone
// socket judged as the default while its query carried another model.
const model = binding?.model ?? liveSidebandModel(upstreamTarget) ?? LIVE_AUDIO_MODEL;
const relay = await resolveAudioUpstream(client.headers, config, log, {
admission: client.admission, model, lease: options.lease,
signal: options.signal,
...(binding ? { exactAccountId: binding.accountId, providerName: binding.providerName } : {}),
});
if (relay instanceof Response) return relay;
try {
if (binding && (relay.providerName !== binding.providerName
|| (new Headers(relay.headers).get("chatgpt-account-id") ?? undefined) !== binding.chatgptAccountId
|| (binding.keyedCredentialDigest !== undefined
&& createHash("sha256").update(new Headers(relay.headers).get("authorization") ?? "").digest("hex") !== binding.keyedCredentialDigest))) {
relay.release();
return formatErrorResponse(409, "authentication_error", "Live call account is no longer available");
}
return {
authContext: relay.authContext,
headers: Object.fromEntries(protocolHeaders(client, relay, frameless)),
upstreamWsUrl: buildLiveSidebandUpstreamWsUrl(upstreamTarget, binding ? binding.sidebandBaseUrl : config.experimentalRealtimeWsBaseUrl),
maxSessionMs: LIVE_CALL_TTL_MS,
finish: finishAudioUpstream(relay),
};
} catch {
relay.release();
return formatErrorResponse(400, "invalid_request_error", "Invalid live endpoint configuration");
}
}