@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
183 lines (176 loc) • 9.28 kB
text/typescript
import { formatErrorResponse } from "../bridge";
import { cancelBodyOnAbort, clearableDeadline, signalWithTimeout } from "../lib/abort";
import type { AdmissionLease } from "../lib/admission";
import { sidecarEnter } from "../lib/sidecar-tracker";
import type { OcxConfig } from "../types";
import type { DataPlaneAdmission } from "./auth-cors";
import { resolveAudioUpstream, TRANSCRIPTION_MODEL } from "./audio-upstream";
import { readBodyCapped } from "./live";
import type { RequestLogContext } from "./request-log";
import { registerTurn, unregisterTurn } from "./lifecycle";
export const AUDIO_FILE_MAX_BYTES = 25_000_000;
export const AUDIO_BODY_MAX_BYTES = 32 * 1024 * 1024;
const AUDIO_FIELD_MAX_BYTES = 16 * 1024;
const AUDIO_RESPONSE_MAX_BYTES = 2 * 1024 * 1024;
const AUDIO_TIMEOUT_MS = 120_000;
const FIELDS = new Set(["file", "model", "prompt", "language", "response_format"]);
const MODELS = new Set([TRANSCRIPTION_MODEL, "gpt-4o-mini-transcribe", "whisper-1"]);
interface TranscriptionInput {
file: File;
model: string;
prompt?: string;
language?: string;
format: "json" | "text";
}
function invalid(message: string, status = 400): Response {
return formatErrorResponse(status, "invalid_request_error", message);
}
async function parseTranscription(req: Request, operationSignal: AbortSignal): Promise<TranscriptionInput | Response> {
if (!/^multipart\/form-data\s*;/i.test(req.headers.get("content-type") ?? "")) {
return invalid("Expected multipart/form-data with file and model");
}
const encoding = req.headers.get("content-encoding")?.trim().toLowerCase();
if (encoding && encoding !== "identity") return invalid("Compressed audio request bodies are not supported");
const length = req.headers.get("content-length");
if (length && /^\d+$/.test(length) && Number(length) > AUDIO_BODY_MAX_BYTES) {
await req.body?.cancel().catch(() => {});
return invalid("Audio request exceeds 32 MiB", 413);
}
let form: FormData;
const uploadDeadline = clearableDeadline(30_000, operationSignal);
try {
const body = await readBodyCapped(req.body, AUDIO_BODY_MAX_BYTES, () => "Audio request too large", uploadDeadline.signal);
if (body instanceof Response) return invalid("Audio request exceeds 32 MiB", 413);
if (operationSignal.aborted) return formatErrorResponse(499, "client_closed_request", "Audio upload canceled");
form = await new Response(body, { headers: { "content-type": req.headers.get("content-type")! } }).formData();
} catch {
if (uploadDeadline.didExpire()) return formatErrorResponse(408, "request_timeout", "Audio upload timed out");
return operationSignal.aborted
? formatErrorResponse(499, "client_closed_request", "Audio upload canceled")
: invalid("Malformed audio multipart body");
} finally {
uploadDeadline.clear();
}
const seen = new Set<string>();
for (const [name, value] of form) {
if (!FIELDS.has(name)) return invalid(`Unsupported transcription field: ${name.slice(0, 64)}`);
if (seen.has(name)) return invalid(`Duplicate transcription field: ${name}`);
seen.add(name);
if (name !== "file" && (typeof value !== "string" || Buffer.byteLength(value) > AUDIO_FIELD_MAX_BYTES)) {
return invalid("Audio text fields must be strings no larger than 16 KiB", 413);
}
}
const file = form.get("file");
if (!(file instanceof File) || file.size === 0) return invalid("A nonempty audio file is required");
if (file.size > AUDIO_FILE_MAX_BYTES) return invalid("Audio file exceeds 25,000,000 bytes", 413);
const model = form.get("model");
if (typeof model !== "string" || !MODELS.has(model)) return invalid("Unsupported transcription model");
const format = form.get("response_format") ?? "json";
if (format !== "json" && format !== "text") return invalid("response_format must be json or text");
const prompt = form.get("prompt") as string | null;
const language = form.get("language") as string | null;
if (language !== null && !/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})?$/.test(language)) return invalid("Invalid transcription language");
return { file, model, format, ...(prompt !== null ? { prompt } : {}), ...(language !== null ? { language } : {}) };
}
async function transcribeAdmitted(
req: Request,
config: OcxConfig,
log: RequestLogContext,
admission: DataPlaneAdmission,
operation: { lease?: AdmissionLease; signal: AbortSignal; didExpire: () => boolean },
): Promise<Response> {
const input = await parseTranscription(req, operation.signal);
if (input instanceof Response) return input;
if (operation.signal.aborted) return formatErrorResponse(499, "client_closed_request", "Audio request canceled");
const relay = await resolveAudioUpstream(req.headers, config, log, { admission, model: input.model, lease: operation.lease, signal: operation.signal });
if (relay instanceof Response) return relay;
const signal = signalWithTimeout(AUDIO_TIMEOUT_MS, operation.signal);
const exit = sidecarEnter("audio-transcription");
let outcome: number | "timeout" | "connect_error" | undefined;
try {
if (!relay.keyed && input.model !== TRANSCRIPTION_MODEL) return invalid(`ChatGPT transcription supports only ${TRANSCRIPTION_MODEL}`);
const url = relay.keyed
? `${relay.providerBaseUrl}/audio/transcriptions`
: "https://chatgpt.com/backend-api/transcribe";
const headers = new Headers();
for (const name of ["authorization", "chatgpt-account-id", "user-agent", "originator", "version"]) {
const value = new Headers(relay.headers).get(name);
if (value) headers.set(name, value);
}
if (!relay.keyed) {
const nativeAgent = req.headers.get("user-agent");
headers.set("user-agent", nativeAgent && /^codex(?:[_ /-]|$)/i.test(nativeAgent)
? nativeAgent.slice(0, 2048) : "codex_cli_rs");
if (!headers.has("originator")) headers.set("originator", "codex_cli_rs");
}
const form = new FormData();
form.append("file", input.file, "audio" + (/\.[a-z0-9]{1,8}$/i.exec(input.file.name)?.[0] ?? ".webm"));
if (input.prompt !== undefined) form.append("prompt", input.prompt);
if (input.language !== undefined) form.append("language", input.language);
if (relay.keyed) {
form.append("model", input.model);
form.append("response_format", "json");
}
const upstream = await fetch(url, { method: "POST", headers, body: form, signal: signal.signal, redirect: "manual" });
outcome = upstream.status;
const detach = cancelBodyOnAbort(upstream.body, signal.signal);
let body: ArrayBuffer | Response;
try {
body = await readBodyCapped(upstream.body, AUDIO_RESPONSE_MAX_BYTES, () => "Audio upstream response too large", signal.signal);
} finally {
detach();
}
if (body instanceof Response) return body;
if (!upstream.ok) {
const status = upstream.status >= 400 && upstream.status <= 599 ? upstream.status : 502;
return formatErrorResponse(status, "upstream_error", `Audio upstream returned HTTP ${upstream.status}`);
}
let payload: unknown;
try { payload = JSON.parse(new TextDecoder().decode(body)); } catch {
return formatErrorResponse(502, "upstream_error", "Audio upstream returned invalid JSON");
}
if (!payload || typeof payload !== "object" || !("text" in payload) || typeof payload.text !== "string") {
return formatErrorResponse(502, "upstream_error", "Audio upstream response is missing text");
}
return input.format === "text"
? new Response(payload.text, { headers: { "content-type": "text/plain; charset=utf-8" } })
: Response.json({ text: payload.text });
} catch {
if (operation.signal.aborted) {
outcome = operation.didExpire() ? "timeout" : undefined;
return formatErrorResponse(499, "client_closed_request", "Audio request canceled");
}
const timedOut = signal.signal.aborted;
outcome = timedOut ? "timeout" : "connect_error";
return formatErrorResponse(timedOut ? 504 : 502, "upstream_error", timedOut ? "Audio upstream timed out" : "Audio upstream connection failed");
} finally {
try {
if (outcome !== undefined) relay.recordOutcome?.(outcome);
} finally {
relay.release();
signal.cleanup();
exit();
}
}
}
export async function handleAudioTranscriptions(
req: Request,
config: OcxConfig,
log: RequestLogContext,
admission: DataPlaneAdmission,
lease?: AdmissionLease,
): Promise<Response> {
const operation = new AbortController();
if (lease) registerTurn(operation, lease);
const deadline = clearableDeadline(AUDIO_TIMEOUT_MS, AbortSignal.any([req.signal, operation.signal]));
try {
const response = await transcribeAdmitted(req, config, log, admission, { lease, signal: deadline.signal, didExpire: deadline.didExpire });
if (req.signal.aborted) return formatErrorResponse(499, "client_closed_request", "Audio request canceled");
if (operation.signal.aborted) return formatErrorResponse(503, "server_draining", "Audio request stopped during shutdown");
if (deadline.didExpire()) return formatErrorResponse(504, "upstream_error", "Audio request timed out");
return response;
} finally {
deadline.clear();
if (lease) unregisterTurn(operation);
}
}