@bitkyc08/opencodex 2.52.0 → 2.53.0-preview.20260913

package/src/router.ts

@@ -413,6 +413,13 @@ export function routedProviderConfig(providerName: string, provider: OcxProvider
     ...(provider.preserveResponsesReasoningContent === undefined && registryEntry.preserveResponsesReasoningContent !== undefined
       ? { preserveResponsesReasoningContent: registryEntry.preserveResponsesReasoningContent }
       : {}),
+    // The request path resolves through routedProviderConfig() and never calls
+    // enrichProviderFromRegistry(), so a saved provider row written before the
+    // registry learned this flag must be backfilled here or route.provider never
+    // carries it and the showThinkingSummary opt-in stays dead.
+    ...(provider.showThinkingSummary === undefined && registryEntry.showThinkingSummary !== undefined
+      ? { showThinkingSummary: registryEntry.showThinkingSummary }
+      : {}),
     // Registry-only client-facing repair policy (#938): fill only when the
     // saved provider has no explicit policy; clone so runtime never aliases
     // the registry constant.

package/src/routing/compatibility/behavior.ts

@@ -14,7 +14,6 @@ export function upstreamProtocolForAdapter(adapter: string): string {
     case "openai-chat":
     case "command-code":
     case "cursor":
-    case "devin-cli":
     case "devin":
     case "azure":
     case "azure-openai":

package/src/server/audio-client.ts

@@ -0,0 +1,64 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+import { formatErrorResponse } from "../bridge";
+import type { OcxConfig } from "../types";
+import { captureExplicitOpenAiCallerAuth, selectOpenAiImagesProvider } from "../providers/openai-sidecar";
+import { isProxyAdmissionSecret, type DataPlaneAdmission } from "./auth-cors";
+import { resolveAudioAdmission } from "./audio-upstream";
+
+export const AUDIO_WEBSOCKET_PROTOCOL = "opencodex-audio";
+const KEY_PROTOCOL_PREFIX = "opencodex-key.";
+
+export interface AudioClient {
+  admission: DataPlaneAdmission;
+  headers: Headers;
+  owner: string;
+  protocol?: string;
+}
+
+/** Browser protocols are an audio-only credential carrier; only the public marker is echoed. */
+export function resolveAudioClient(req: Request, config: OcxConfig, required = false): AudioClient | Response | null {
+  const headers = new Headers(req.headers);
+  let protocol: string | undefined;
+  let carrier = false;
+  if (headers.get("upgrade")?.toLowerCase() === "websocket") {
+    const raw = headers.get("sec-websocket-protocol") ?? "";
+    if (raw.length > 8192) return formatErrorResponse(400, "invalid_request_error", "Audio protocol header too large");
+    const protocols = raw.split(",").map(value => value.trim()).filter(Boolean);
+    const keys = protocols.filter(value => value.startsWith(KEY_PROTOCOL_PREFIX));
+    const markers = protocols.filter(value => value === AUDIO_WEBSOCKET_PROTOCOL);
+    carrier = keys.length > 0 || markers.length > 0;
+    if (carrier) {
+      if (keys.length !== 1 || markers.length !== 1 || protocols.length !== 2) {
+        return formatErrorResponse(400, "invalid_request_error", "Expected one audio protocol and one encoded client key");
+      }
+      const encoded = keys[0]!.slice(KEY_PROTOCOL_PREFIX.length);
+      const bytes = Buffer.from(encoded, "base64url");
+      const key = bytes.toString("utf8");
+      if (!encoded || bytes.toString("base64url") !== encoded || Buffer.from(key).toString("base64url") !== encoded || !key.trim()) {
+        return formatErrorResponse(400, "invalid_request_error", "Invalid audio client key encoding");
+      }
+      protocol = AUDIO_WEBSOCKET_PROTOCOL;
+      if (!["authorization", "x-opencodex-api-key", "x-api-key"].some(name => headers.has(name))) {
+        headers.set("x-opencodex-api-key", key);
+      }
+    }
+  }
+  const admission = resolveAudioAdmission(headers, config);
+  if (!admission) {
+    const bearer = /^Bearer\s+([^\s,]+)$/i.exec(headers.get("authorization") ?? "")?.[1];
+    const platformKey = selectOpenAiImagesProvider(config).keyed?.apiKey;
+    const knownPlatformBearer = !!bearer && !!platformKey && !isProxyAdmissionSecret(bearer, config)
+      && timingSafeEqual(createHash("sha256").update(bearer).digest(), createHash("sha256").update(platformKey).digest());
+    const explicit = headers.has("x-opencodex-api-key") || headers.has("x-api-key")
+      || (headers.has("authorization") && !knownPlatformBearer && !captureExplicitOpenAiCallerAuth(headers, config));
+    return required || carrier || explicit
+      ? formatErrorResponse(401, "authentication_error", "opencodex API key required")
+      : null;
+  }
+  const credential = admission.source === "dedicated" ? headers.get("x-opencodex-api-key")
+    : admission.source === "x-api-key" ? headers.get("x-api-key") : headers.get("authorization")?.replace(/^Bearer\s+/i, "");
+  const owner = admission.kind === "configured"
+    ? JSON.stringify(["configured", admission.keyId])
+    : JSON.stringify(["environment", createHash("sha256").update(credential?.trim() ?? "").digest("hex")]);
+  return { admission, headers, owner, ...(protocol ? { protocol } : {}) };
+}

package/src/server/audio-dictation.ts

@@ -0,0 +1,91 @@
+import { formatErrorResponse } from "../bridge";
+import type { AdmissionLease } from "../lib/admission";
+import type { OcxConfig } from "../types";
+import type { AudioClient } from "./audio-client";
+import { resolveAudioUpstream, TRANSCRIPTION_MODEL, type AudioUpstream } from "./audio-upstream";
+import type { RequestLogContext } from "./request-log";
+
+export const DICTATION_SESSION_MAX_MS = 300_000;
+const DICTATION_FRAME_MAX_BYTES = 64 * 1024;
+type JsonObject = Record<string, unknown>;
+function object(value: unknown): value is JsonObject { return !!value && typeof value === "object" && !Array.isArray(value); }
+function integer(value: unknown, min: number, max: number): boolean {
+  return typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
+}
+
+export function createDictationFrameValidator(): (frame: string | Buffer) => boolean {
+  let started = false;
+  let closed = false;
+  return frame => {
+    if (closed || typeof frame !== "string" || Buffer.byteLength(frame) > DICTATION_FRAME_MAX_BYTES) return false;
+    let event: unknown;
+    try { event = JSON.parse(frame); } catch { return false; }
+    if (!object(event)) return false;
+    if (event.type === "session.start" && !started) {
+      const config = event.config;
+      if (!object(config) || Object.keys(event).some(key => key !== "type" && key !== "config")) return false;
+      const fields = new Set(["input_audio_format", "sample_rate_hz", "num_channels", "max_buffer_size_bytes", "max_utterance_duration_ms", "session_ttl_ms", "provider_mode", "transcript_delivery_mode", "vad"]);
+      if (Object.keys(config).some(key => !fields.has(key)) || config.input_audio_format !== "pcm16" || config.num_channels !== 1
+        || !integer(config.sample_rate_hz, 8000, 192000) || !integer(config.max_buffer_size_bytes, 1, 4 * 1024 * 1024)
+        || !integer(config.max_utterance_duration_ms, 1, 30000) || !integer(config.session_ttl_ms, 1, DICTATION_SESSION_MAX_MS)
+        || !["buffered", "streaming_sse"].includes(String(config.provider_mode))
+        || !["final_only", "segment", "delta"].includes(String(config.transcript_delivery_mode))) return false;
+      const vad = config.vad;
+      if (!object(vad) || Object.keys(vad).some(key => !["type", "threshold", "prefix_padding_ms", "silence_duration_ms"].includes(key))
+        || vad.type !== "server_vad" || typeof vad.threshold !== "number" || !Number.isFinite(vad.threshold) || vad.threshold < 0 || vad.threshold > 1
+        || !integer(vad.prefix_padding_ms, 0, 1000) || !integer(vad.silence_duration_ms, 0, 5000)) return false;
+      started = true;
+      return true;
+    }
+    if (!started) return false;
+    if (event.type === "session.close" && Object.keys(event).length === 1) { closed = true; return true; }
+    if (event.type !== "audio.append" || Object.keys(event).some(key => key !== "type" && key !== "audio") || typeof event.audio !== "string" || !event.audio) return false;
+    const bytes = Buffer.from(event.audio, "base64");
+    return bytes.length > 0 && bytes.length % 2 === 0 && bytes.toString("base64") === event.audio;
+  };
+}
+
+export interface AudioSocketTarget {
+  headers: Record<string, string>;
+  upstreamWsUrl: string;
+  protocols?: string[];
+  validateFrame?: (frame: string | Buffer) => boolean;
+  maxSessionMs: number;
+  finish: (outcome?: number | "timeout" | "connect_error") => void;
+}
+
+export function finishAudioUpstream(relay: AudioUpstream): AudioSocketTarget["finish"] {
+  let finished = false;
+  return outcome => {
+    if (finished) return;
+    finished = true;
+    try { if (outcome !== undefined) relay.recordOutcome?.(outcome); }
+    finally { relay.release(); }
+  };
+}
+
+export async function resolveDictationSocket(
+  client: AudioClient, config: OcxConfig, log: RequestLogContext, lease: AdmissionLease, signal?: AbortSignal,
+): Promise<AudioSocketTarget | Response> {
+  const relay = await resolveAudioUpstream(client.headers, config, log, { admission: client.admission, model: TRANSCRIPTION_MODEL, lease, signal });
+  if (relay instanceof Response) return relay;
+  if (relay.keyed) {
+    relay.release();
+    return formatErrorResponse(400, "invalid_request_error", "Streaming dictation requires a connected ChatGPT account");
+  }
+  const headers = new Headers(relay.headers);
+  const token = headers.get("authorization")?.replace(/^Bearer\s+/i, "").trim();
+  if (!token || /[\s,]/.test(token)) {
+    relay.release();
+    return formatErrorResponse(401, "authentication_error", "Dictation account authentication unavailable");
+  }
+  headers.delete("authorization");
+  return {
+    upstreamWsUrl: "wss://chatgpt.com/backend-api/dictation/stream",
+    headers: Object.fromEntries(headers),
+    protocols: ["chatgpt-dictation", `openai-bearer.${token}`, "codex-desktop"],
+    validateFrame: createDictationFrameValidator(),
+    maxSessionMs: DICTATION_SESSION_MAX_MS,
+    finish: finishAudioUpstream(relay),
+  };
+}

package/src/server/audio-live.ts

@@ -0,0 +1,185 @@
+import { createHash } from "node:crypto";
+import { formatErrorResponse } from "../bridge";
+import { MAIN_CODEX_ACCOUNT_ID } from "../codex/account-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, 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";
+    const 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;
+    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.ok ? 502 : 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,
+      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");
+    outcome = upstream.status;
+    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 {
+    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";
+  let model = LIVE_AUDIO_MODEL;
+  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);
+    model = query.get("model") ?? LIVE_AUDIO_MODEL;
+    upstreamTarget = { ...upstreamTarget, query: query.toString() };
+  }
+  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 {
+      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");
+  }
+}

package/src/server/audio-transcriptions.ts

@@ -0,0 +1,183 @@
+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.ok ? 502 : 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");
+    }
+    outcome = upstream.status;
+    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);
+  }
+}