@opengeni/codex 6.8.0 → 6.9.1-canary.41937124785001

package/dist/index.js

@@ -3234,7 +3234,9 @@ function boundedErrorMessage(body) {
 // src/realtime.ts
 var MAX_REALTIME_SDP_BYTES = 1024 * 1024;
 var MAX_REALTIME_PROVIDER_VALUE_LENGTH = 128;
+var MAX_REALTIME_ERROR_BODY_BYTES = 16 * 1024;
 var REALTIME_PROVIDER_VALUE = /^[a-z0-9][a-z0-9._-]*$/i;
+var REALTIME_PROVIDER_ERROR_TOKEN = /^[A-Za-z0-9][A-Za-z0-9 _.:-]{0,63}$/;
 var REALTIME_CALL_ID = /^(?:rtc_.+|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
 var CODEX_REALTIME_VOICES = [
   "juniper",
@@ -3248,17 +3250,19 @@ var CODEX_REALTIME_VOICES = [
   "cove"
 ];
 var CodexRealtimeError = class extends Error {
-  constructor(code, message, providerStatus = null) {
+  constructor(code, message, providerStatus = null, diagnostics = { stage: "request" }) {
     super(message);
     this.code = code;
     this.providerStatus = providerStatus;
+    this.diagnostics = diagnostics;
     this.name = "CodexRealtimeError";
   }
 };
 var FALLBACK_REALTIME_PROVIDER_CONFIG = {
   architecture: CODEX_REALTIME_PROVIDER_ARCHITECTURE_FALLBACK,
   model: CODEX_REALTIME_PROVIDER_MODEL_FALLBACK,
-  version: CODEX_REALTIME_VERSION
+  version: CODEX_REALTIME_VERSION,
+  source: "fallback"
 };
 async function fetchCodexRealtimeProviderConfig(auth, fetchImpl = fetch, options = {}) {
   if (options.signal?.aborted) {
@@ -3294,7 +3298,8 @@ async function fetchCodexRealtimeProviderConfig(auth, fetchImpl = fetch, options
       throw new CodexRealtimeError(
         "authentication",
         "Codex subscription rejected authentication",
-        response.status
+        response.status,
+        { stage: "config" }
       );
     }
     if (!response.ok) {
@@ -3307,18 +3312,26 @@ async function fetchCodexRealtimeProviderConfig(auth, fetchImpl = fetch, options
     const value = payload.dynamic_configs?.[CODEX_REALTIME_CONFIG_ID]?.value;
     const version = value?.version;
     if (version !== void 0 && version !== CODEX_REALTIME_VERSION) {
-      throw new CodexRealtimeError(
-        "incompatible",
-        `Codex realtime remote configuration requires ${String(version)}`
-      );
+      return {
+        ...FALLBACK_REALTIME_PROVIDER_CONFIG,
+        ...validProviderValue(version) ? { advertisedVersion: version } : {}
+      };
     }
     const architecture = validProviderValue(value?.architecture) ? value.architecture : FALLBACK_REALTIME_PROVIDER_CONFIG.architecture;
     const model = validProviderValue(value?.model) ? value.model : FALLBACK_REALTIME_PROVIDER_CONFIG.model;
-    return { architecture, model, version: CODEX_REALTIME_VERSION };
+    return {
+      architecture,
+      model,
+      version: CODEX_REALTIME_VERSION,
+      source: value ? "remote" : "fallback",
+      ...version === void 0 ? {} : { advertisedVersion: CODEX_REALTIME_VERSION }
+    };
   } catch (error) {
     if (error instanceof CodexRealtimeError) throw error;
     if (options.signal?.aborted) {
-      throw new CodexRealtimeError("cancelled", "Codex realtime request cancelled");
+      throw new CodexRealtimeError("cancelled", "Codex realtime request cancelled", null, {
+        stage: "config"
+      });
     }
     return FALLBACK_REALTIME_PROVIDER_CONFIG;
   } finally {
@@ -3330,6 +3343,13 @@ async function createCodexRealtimeCall(auth, input, fetchImpl = fetch, options =
   validateRealtimeInput(input);
   const timeoutMs = options.timeoutMs ?? CODEX_REALTIME_CALL_TIMEOUT_MS;
   const providerConfig = options.providerConfig ?? FALLBACK_REALTIME_PROVIDER_CONFIG;
+  const callDiagnostics = {
+    stage: "call",
+    configSource: providerConfig.source,
+    advertisedVersion: validProviderValue(providerConfig.advertisedVersion) ? providerConfig.advertisedVersion : void 0,
+    providerModel: validProviderValue(providerConfig.model) ? providerConfig.model : void 0,
+    providerArchitecture: validProviderValue(providerConfig.architecture) ? providerConfig.architecture : void 0
+  };
   if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
     throw new CodexRealtimeError("invalid_request", "Codex realtime timeout must be positive");
   }
@@ -3357,14 +3377,28 @@ async function createCodexRealtimeCall(auth, input, fetchImpl = fetch, options =
   });
   const onAbort = () => {
     controller.abort(options.signal?.reason);
-    rejectCancellation?.(new CodexRealtimeError("cancelled", "Codex realtime request cancelled"));
+    rejectCancellation?.(
+      new CodexRealtimeError(
+        "cancelled",
+        "Codex realtime request cancelled",
+        null,
+        callDiagnostics
+      )
+    );
   };
   options.signal?.addEventListener("abort", onAbort, { once: true });
   const deadline = new Promise((_resolve, reject) => {
     timeout = setTimeout(() => {
       timedOut = true;
       controller.abort();
-      reject(new CodexRealtimeError("timeout", "Codex realtime request timed out"));
+      reject(
+        new CodexRealtimeError(
+          "timeout",
+          "Codex realtime request timed out",
+          null,
+          callDiagnostics
+        )
+      );
     }, timeoutMs);
   });
   const request = (async () => {
@@ -3406,8 +3440,8 @@ async function createCodexRealtimeCall(auth, input, fetchImpl = fetch, options =
       }
     );
     if (!response.ok) {
-      await response.body?.cancel().catch(() => void 0);
-      throw providerHttpError(response.status);
+      const providerError = await readProviderErrorFields(response);
+      throw providerHttpError(response.status, { ...callDiagnostics, ...providerError });
     }
     const location = response.headers.get("location");
     if (!location || !validRealtimeLocation(location)) {
@@ -3415,15 +3449,17 @@ async function createCodexRealtimeCall(auth, input, fetchImpl = fetch, options =
       throw new CodexRealtimeError(
         "invalid_response",
         "Codex realtime response did not identify a compatible call",
-        response.status
+        response.status,
+        callDiagnostics
       );
     }
-    const sdp = await readBoundedSdp(response);
+    const sdp = await readBoundedSdp(response, callDiagnostics);
     if (!isAudioSdp(sdp)) {
       throw new CodexRealtimeError(
         "invalid_response",
         "Codex realtime response was not an audio SDP answer",
-        response.status
+        response.status,
+        callDiagnostics
       );
     }
     return {
@@ -3437,12 +3473,27 @@ async function createCodexRealtimeCall(auth, input, fetchImpl = fetch, options =
   } catch (error) {
     if (error instanceof CodexRealtimeError) throw error;
     if (options.signal?.aborted) {
-      throw new CodexRealtimeError("cancelled", "Codex realtime request cancelled");
+      throw new CodexRealtimeError(
+        "cancelled",
+        "Codex realtime request cancelled",
+        null,
+        callDiagnostics
+      );
     }
     if (timedOut || controller.signal.aborted) {
-      throw new CodexRealtimeError("timeout", "Codex realtime request timed out");
+      throw new CodexRealtimeError(
+        "timeout",
+        "Codex realtime request timed out",
+        null,
+        callDiagnostics
+      );
     }
-    throw new CodexRealtimeError("network", "Codex realtime provider request failed");
+    throw new CodexRealtimeError(
+      "network",
+      "Codex realtime provider request failed",
+      null,
+      callDiagnostics
+    );
   } finally {
     if (timeout) clearTimeout(timeout);
     options.signal?.removeEventListener("abort", onAbort);
@@ -3501,32 +3552,92 @@ function validateRealtimeInput(input) {
     throw new CodexRealtimeError("invalid_request", "Codex realtime history is too large");
   }
 }
-function providerHttpError(status) {
+async function readProviderErrorFields(response) {
+  const declared = Number(response.headers.get("content-length"));
+  if (!response.body || Number.isFinite(declared) && declared > MAX_REALTIME_ERROR_BODY_BYTES) {
+    await response.body?.cancel().catch(() => void 0);
+    return {};
+  }
+  let text = "";
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let total = 0;
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done) break;
+      total += next.value.byteLength;
+      if (total > MAX_REALTIME_ERROR_BODY_BYTES) {
+        await reader.cancel().catch(() => void 0);
+        return {};
+      }
+      text += decoder.decode(next.value, { stream: true });
+    }
+  } catch {
+    return {};
+  } finally {
+    reader.releaseLock();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return {};
+  }
+  if (!parsed || typeof parsed !== "object") return {};
+  const record = parsed;
+  const error = record.error && typeof record.error === "object" ? record.error : null;
+  const code = providerErrorToken(error?.code) ?? providerErrorToken(record.detail);
+  const type = providerErrorToken(error?.type);
+  const param = providerErrorToken(error?.param);
+  return {
+    ...code ? { providerErrorCode: code } : {},
+    ...type ? { providerErrorType: type } : {},
+    ...param ? { providerErrorParam: param } : {}
+  };
+}
+function providerErrorToken(value) {
+  return typeof value === "string" && REALTIME_PROVIDER_ERROR_TOKEN.test(value) ? value : null;
+}
+function providerHttpError(status, diagnostics) {
   if (status === 401) {
     return new CodexRealtimeError(
       "authentication",
       "Codex subscription rejected authentication",
-      status
+      status,
+      diagnostics
     );
   }
   if (status === 403) {
     return new CodexRealtimeError(
       "entitlement",
       "Codex subscription lacks realtime entitlement",
-      status
+      status,
+      diagnostics
     );
   }
   if (status === 404) {
     return new CodexRealtimeError(
       "incompatible",
       "Codex subscription realtime is unavailable",
-      status
+      status,
+      diagnostics
     );
   }
   if (status === 429) {
-    return new CodexRealtimeError("rate_limited", "Codex realtime is rate limited", status);
+    return new CodexRealtimeError(
+      "rate_limited",
+      "Codex realtime is rate limited",
+      status,
+      diagnostics
+    );
   }
-  return new CodexRealtimeError("provider", "Codex realtime provider request failed", status);
+  return new CodexRealtimeError(
+    "provider",
+    "Codex realtime provider request failed",
+    status,
+    diagnostics
+  );
 }
 function validRealtimeLocation(location) {
   const path = location.split("?", 1)[0] ?? "";
@@ -3536,14 +3647,15 @@ function validRealtimeLocation(location) {
 function isAudioSdp(sdp) {
   return /^v=0(?:\r?\n)/.test(sdp) && /(?:^|\r?\n)m=audio\s/m.test(sdp);
 }
-async function readBoundedSdp(response) {
+async function readBoundedSdp(response, diagnostics) {
   const declared = Number(response.headers.get("content-length"));
   if (Number.isFinite(declared) && declared > MAX_REALTIME_SDP_BYTES) {
     await response.body?.cancel().catch(() => void 0);
     throw new CodexRealtimeError(
       "invalid_response",
       "Codex realtime SDP answer is too large",
-      response.status
+      response.status,
+      diagnostics
     );
   }
   if (!response.body) return "";
@@ -3560,7 +3672,8 @@ async function readBoundedSdp(response) {
         throw new CodexRealtimeError(
           "invalid_response",
           "Codex realtime SDP answer is too large",
-          response.status
+          response.status,
+          diagnostics
         );
       }
       chunks.push(next.value);
@@ -3580,7 +3693,8 @@ async function readBoundedSdp(response) {
     throw new CodexRealtimeError(
       "invalid_response",
       "Codex realtime SDP answer was not valid UTF-8",
-      response.status
+      response.status,
+      diagnostics
     );
   }
 }