@opengeni/codex 0.2.9 → 0.2.10

package/dist/index.js

@@ -21,6 +21,10 @@ import {
   CODEX_ORIGINATOR,
   CODEX_PROVIDER_BASE_URL,
   CODEX_PROVIDER_ID,
+  CODEX_REALTIME_CALL_TIMEOUT_MS,
+  CODEX_REALTIME_DEFAULT_VOICE,
+  CODEX_REALTIME_MODEL,
+  CODEX_REALTIME_VERSION,
   CODEX_REFRESH_FALLBACK_MS,
   CODEX_REFRESH_WINDOW_MS,
   CODEX_RESPONSES_BASE,
@@ -32,7 +36,19 @@ import {
   CODEX_RESPONSE_WHOLE_TIMEOUT_MS,
   CODEX_TOKEN_URL,
   CODEX_WHAM_BASE
-} from "./chunk-YGKQDUY7.js";
+} from "./chunk-HT463QWA.js";
+import {
+  CODEX_REALTIME_CONTEXT_APPEND_MAX_BYTES,
+  CODEX_REALTIME_INITIAL_ITEMS_MAX_COUNT,
+  CODEX_REALTIME_INITIAL_ITEMS_MAX_TOKENS,
+  CODEX_REALTIME_V3_MAX_EVENT_BYTES,
+  CODEX_REALTIME_V3_MAX_IDENTIFIER_BYTES,
+  CODEX_REALTIME_V3_MAX_TEXT_BYTES,
+  contextAppendChunks,
+  encodeCodexRealtimeV3DelegationContextAppend,
+  encodeCodexRealtimeV3SessionContextAppend,
+  parseCodexRealtimeV3Event
+} from "./chunk-MFVGCR3N.js";
 
 // src/billing.ts
 function isCodexBilledModel(model) {
@@ -567,7 +583,7 @@ function normalizeCodexUsage(httpStatus, rawPayload) {
 var CODEX_READ_TIMEOUT_MS = 5e3;
 var RESET_CREDIT_DETAILS_TIMEOUT_MS = 5e3;
 var RESET_CREDIT_CONSUME_TIMEOUT_MS = 1e4;
-function subscriptionHeaders(a) {
+function codexSubscriptionHeaders(a) {
   return {
     Authorization: `Bearer ${a.accessToken}`,
     ...a.chatgptAccountId ? { "ChatGPT-Account-ID": a.chatgptAccountId } : {},
@@ -581,7 +597,7 @@ async function fetchCodexModels(a, fetchImpl = fetch, timeoutMs = CODEX_READ_TIM
   const fetched = await runBoundedCodexOperation(async (signal) => {
     const res = await fetchImpl(
       `${CODEX_RESPONSES_BASE}/models?client_version=${encodeURIComponent(a.clientVersion)}`,
-      { method: "GET", headers: subscriptionHeaders(a), signal }
+      { method: "GET", headers: codexSubscriptionHeaders(a), signal }
     );
     if (!res.ok) {
       await res.arrayBuffer().catch(() => void 0);
@@ -597,7 +613,7 @@ async function fetchCodexUsage(a, fetchImpl = fetch, timeoutMs = CODEX_READ_TIME
   const fetched = await runBoundedCodexOperation(async (signal) => {
     const res = await fetchImpl(`${CODEX_WHAM_BASE}/wham/usage`, {
       method: "GET",
-      headers: subscriptionHeaders(a),
+      headers: codexSubscriptionHeaders(a),
       signal
     });
     const payload = res.ok || res.status === 404 ? await res.json().catch(() => null) : null;
@@ -611,15 +627,23 @@ async function fetchCodexRateLimitResetCredits(a, fetchImpl = fetch, timeoutMs =
   const fetched = await runBoundedCodexOperation(async (signal) => {
     const res = await fetchImpl(`${CODEX_WHAM_BASE}/wham/rate-limit-reset-credits`, {
       method: "GET",
-      headers: subscriptionHeaders(a),
+      headers: codexSubscriptionHeaders(a),
       signal
     });
     if (!res.ok) {
       await res.arrayBuffer().catch(() => void 0);
-      return { ok: false, status: res.status, reason: "http_error" };
+      return {
+        ok: false,
+        status: res.status,
+        reason: "http_error"
+      };
     }
     const details = parseCodexRateLimitResetCreditsDetails(await res.json().catch(() => null));
-    return details ? { ok: true, status: res.status, details } : { ok: false, status: res.status, reason: "invalid_response" };
+    return details ? { ok: true, status: res.status, details } : {
+      ok: false,
+      status: res.status,
+      reason: "invalid_response"
+    };
   }, timeoutMs);
   return fetched.ok ? fetched.value : { ok: false, status: 0, reason: fetched.reason };
 }
@@ -631,7 +655,7 @@ async function consumeCodexRateLimitResetCredit(a, input, fetchImpl = fetch, tim
     const res = await fetchImpl(`${CODEX_WHAM_BASE}/wham/rate-limit-reset-credits/consume`, {
       method: "POST",
       headers: {
-        ...subscriptionHeaders(a),
+        ...codexSubscriptionHeaders(a),
         "content-type": "application/json"
       },
       body: JSON.stringify({
@@ -642,10 +666,18 @@ async function consumeCodexRateLimitResetCredit(a, input, fetchImpl = fetch, tim
     });
     if (!res.ok) {
       await res.arrayBuffer().catch(() => void 0);
-      return { ok: false, status: res.status, reason: "http_error" };
+      return {
+        ok: false,
+        status: res.status,
+        reason: "http_error"
+      };
     }
     const result = parseCodexRateLimitResetConsumeResponse(await res.json().catch(() => null));
-    return result ? { ok: true, status: res.status, result } : { ok: false, status: res.status, reason: "invalid_response" };
+    return result ? { ok: true, status: res.status, result } : {
+      ok: false,
+      status: res.status,
+      reason: "invalid_response"
+    };
   }, timeoutMs);
   return fetched.ok ? fetched.value : { ok: false, status: 0, reason: fetched.reason };
 }
@@ -2219,6 +2251,269 @@ function isResponsesProtocolContentPrefix(output) {
 function isImageDataUrl(value) {
   return /^data:image\/[a-z0-9.+-]+;base64,/i.test(value);
 }
+
+// src/realtime.ts
+var CODEX_REALTIME_CALL_URL = `${CODEX_RESPONSES_BASE}/realtime/calls?intent=quicksilver&architecture=avas`;
+var MAX_REALTIME_SDP_BYTES = 1024 * 1024;
+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",
+  "maple",
+  "spruce",
+  "ember",
+  "vale",
+  "breeze",
+  "arbor",
+  "sol",
+  "cove"
+];
+var CodexRealtimeError = class extends Error {
+  constructor(code, message, providerStatus = null) {
+    super(message);
+    this.code = code;
+    this.providerStatus = providerStatus;
+    this.name = "CodexRealtimeError";
+  }
+};
+async function createCodexRealtimeCall(auth, input, fetchImpl = fetch, options = {}) {
+  validateRealtimeInput(input);
+  const timeoutMs = options.timeoutMs ?? CODEX_REALTIME_CALL_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new CodexRealtimeError("invalid_request", "Codex realtime timeout must be positive");
+  }
+  if (options.signal?.aborted) {
+    throw new CodexRealtimeError("cancelled", "Codex realtime request cancelled");
+  }
+  const controller = new AbortController();
+  let timedOut = false;
+  let timeout;
+  let rejectCancellation;
+  const cancellation = new Promise((_resolve, reject) => {
+    rejectCancellation = reject;
+  });
+  const onAbort = () => {
+    controller.abort(options.signal?.reason);
+    rejectCancellation?.(new CodexRealtimeError("cancelled", "Codex realtime request cancelled"));
+  };
+  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"));
+    }, timeoutMs);
+  });
+  const request = (async () => {
+    const response = await fetchImpl(CODEX_REALTIME_CALL_URL, {
+      method: "POST",
+      headers: {
+        ...codexSubscriptionHeaders(auth),
+        "content-type": "application/json",
+        "openai-alpha": "quicksilver=v2",
+        "session-id": input.sessionId,
+        "thread-id": input.sessionId
+      },
+      body: JSON.stringify({
+        sdp: input.sdp,
+        session: {
+          instructions: input.instructions ?? "",
+          audio: {
+            output: { voice: input.voice ?? CODEX_REALTIME_DEFAULT_VOICE }
+          },
+          delegation: { type: "client" },
+          model: CODEX_REALTIME_MODEL,
+          ...input.initialItems?.length ? {
+            initial_items: input.initialItems.map((item) => ({
+              type: "message",
+              role: item.role,
+              content: [
+                {
+                  type: item.role === "assistant" ? "output_text" : "input_text",
+                  text: item.text
+                }
+              ]
+            }))
+          } : {}
+        }
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      await response.body?.cancel().catch(() => void 0);
+      throw providerHttpError(response.status);
+    }
+    const location = response.headers.get("location");
+    if (!location || !validRealtimeLocation(location)) {
+      await response.body?.cancel().catch(() => void 0);
+      throw new CodexRealtimeError(
+        "invalid_response",
+        "Codex realtime response did not identify a compatible call",
+        response.status
+      );
+    }
+    const sdp = await readBoundedSdp(response);
+    if (!isAudioSdp(sdp)) {
+      throw new CodexRealtimeError(
+        "invalid_response",
+        "Codex realtime response was not an audio SDP answer",
+        response.status
+      );
+    }
+    return {
+      sdp,
+      version: CODEX_REALTIME_VERSION,
+      model: CODEX_REALTIME_MODEL
+    };
+  })();
+  try {
+    return await Promise.race([request, cancellation, deadline]);
+  } catch (error) {
+    if (error instanceof CodexRealtimeError) throw error;
+    if (options.signal?.aborted) {
+      throw new CodexRealtimeError("cancelled", "Codex realtime request cancelled");
+    }
+    if (timedOut || controller.signal.aborted) {
+      throw new CodexRealtimeError("timeout", "Codex realtime request timed out");
+    }
+    throw new CodexRealtimeError("network", "Codex realtime provider request failed");
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    options.signal?.removeEventListener("abort", onAbort);
+  }
+}
+function selectCodexCredentialId(args) {
+  if (args.sessionPinnedCredentialId && args.connectedIds.has(args.sessionPinnedCredentialId)) {
+    return args.sessionPinnedCredentialId;
+  }
+  if (args.activeCredentialId && args.connectedIds.has(args.activeCredentialId)) {
+    return args.activeCredentialId;
+  }
+  return null;
+}
+function validateRealtimeInput(input) {
+  if (input.version !== CODEX_REALTIME_VERSION) {
+    throw new CodexRealtimeError(
+      "incompatible",
+      `Codex realtime requires ${CODEX_REALTIME_VERSION}`
+    );
+  }
+  if (!input.sessionId || input.sessionId.length > 128) {
+    throw new CodexRealtimeError("invalid_request", "Codex realtime session id is invalid");
+  }
+  if (new TextEncoder().encode(input.sdp).byteLength > MAX_REALTIME_SDP_BYTES) {
+    throw new CodexRealtimeError("invalid_request", "Codex realtime SDP offer is too large");
+  }
+  if (!isAudioSdp(input.sdp)) {
+    throw new CodexRealtimeError("invalid_request", "Codex realtime requires an audio SDP offer");
+  }
+  if (input.voice !== void 0 && !CODEX_REALTIME_VOICES.includes(input.voice)) {
+    throw new CodexRealtimeError("invalid_request", "Codex realtime voice is unsupported");
+  }
+  const initialItems = input.initialItems ?? [];
+  if (initialItems.length > CODEX_REALTIME_INITIAL_ITEMS_MAX_COUNT) {
+    throw new CodexRealtimeError(
+      "invalid_request",
+      `Codex realtime history exceeds ${CODEX_REALTIME_INITIAL_ITEMS_MAX_COUNT} items`
+    );
+  }
+  let estimatedTokens = 0;
+  for (const item of initialItems) {
+    if (item.role !== "user" && item.role !== "developer" && item.role !== "assistant" || typeof item.text !== "string") {
+      throw new CodexRealtimeError("invalid_request", "Codex realtime history item is invalid");
+    }
+    const itemTokens = Math.ceil(new TextEncoder().encode(item.text).byteLength / 4);
+    if (itemTokens > CODEX_REALTIME_INITIAL_ITEMS_MAX_TOKENS) {
+      throw new CodexRealtimeError("invalid_request", "Codex realtime history item is too large");
+    }
+    estimatedTokens += itemTokens;
+  }
+  if (estimatedTokens > CODEX_REALTIME_INITIAL_ITEMS_MAX_TOKENS) {
+    throw new CodexRealtimeError("invalid_request", "Codex realtime history is too large");
+  }
+}
+function providerHttpError(status) {
+  if (status === 401) {
+    return new CodexRealtimeError(
+      "authentication",
+      "Codex subscription rejected authentication",
+      status
+    );
+  }
+  if (status === 403) {
+    return new CodexRealtimeError(
+      "entitlement",
+      "Codex subscription lacks realtime entitlement",
+      status
+    );
+  }
+  if (status === 404) {
+    return new CodexRealtimeError(
+      "incompatible",
+      "Codex subscription realtime is unavailable",
+      status
+    );
+  }
+  if (status === 429) {
+    return new CodexRealtimeError("rate_limited", "Codex realtime is rate limited", status);
+  }
+  return new CodexRealtimeError("provider", "Codex realtime provider request failed", status);
+}
+function validRealtimeLocation(location) {
+  const path = location.split("?", 1)[0] ?? "";
+  const segment = path.split("/").filter(Boolean).at(-1) ?? "";
+  return REALTIME_CALL_ID.test(segment);
+}
+function isAudioSdp(sdp) {
+  return /^v=0(?:\r?\n)/.test(sdp) && /(?:^|\r?\n)m=audio\s/m.test(sdp);
+}
+async function readBoundedSdp(response) {
+  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
+    );
+  }
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done) break;
+      total += next.value.byteLength;
+      if (total > MAX_REALTIME_SDP_BYTES) {
+        await reader.cancel();
+        throw new CodexRealtimeError(
+          "invalid_response",
+          "Codex realtime SDP answer is too large",
+          response.status
+        );
+      }
+      chunks.push(next.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new CodexRealtimeError(
+      "invalid_response",
+      "Codex realtime SDP answer was not valid UTF-8",
+      response.status
+    );
+  }
+}
 export {
   CODEX_APPS_MCP_SERVER_ID,
   CODEX_APPS_MCP_SERVER_NAME,
@@ -2245,6 +2540,17 @@ export {
   CODEX_PROVIDER_BASE_URL,
   CODEX_PROVIDER_ID,
   CODEX_RATE_LIMIT_RESET_OUTCOMES,
+  CODEX_REALTIME_CALL_TIMEOUT_MS,
+  CODEX_REALTIME_CONTEXT_APPEND_MAX_BYTES,
+  CODEX_REALTIME_DEFAULT_VOICE,
+  CODEX_REALTIME_INITIAL_ITEMS_MAX_COUNT,
+  CODEX_REALTIME_INITIAL_ITEMS_MAX_TOKENS,
+  CODEX_REALTIME_MODEL,
+  CODEX_REALTIME_V3_MAX_EVENT_BYTES,
+  CODEX_REALTIME_V3_MAX_IDENTIFIER_BYTES,
+  CODEX_REALTIME_V3_MAX_TEXT_BYTES,
+  CODEX_REALTIME_VERSION,
+  CODEX_REALTIME_VOICES,
   CODEX_REFRESH_FALLBACK_MS,
   CODEX_REFRESH_WINDOW_MS,
   CODEX_RESPONSES_BASE,
@@ -2262,6 +2568,7 @@ export {
   CODEX_WEEKLY_WINDOW_SECONDS,
   CODEX_WHAM_BASE,
   CodexDeviceError,
+  CodexRealtimeError,
   CodexRefreshTransient,
   CodexReloginRequired,
   CodexResponseTimeoutError,
@@ -2283,8 +2590,13 @@ export {
   codexAppsSanitizingFetch,
   codexRequestStorage,
   codexSubscriptionFetch,
+  codexSubscriptionHeaders,
   consumeCodexRateLimitResetCredit,
+  contextAppendChunks,
+  createCodexRealtimeCall,
   decodeJwtPayload,
+  encodeCodexRealtimeV3DelegationContextAppend,
+  encodeCodexRealtimeV3SessionContextAppend,
   exchangeDeviceCode,
   fetchCodexModels,
   fetchCodexRateLimitResetCredits,
@@ -2298,6 +2610,7 @@ export {
   parseCodexRateLimitResetConsumeResponse,
   parseCodexRateLimitResetCreditsDetails,
   parseCodexRateLimitResetCreditsSummary,
+  parseCodexRealtimeV3Event,
   parseCodexUsageHeaders,
   parseIdToken,
   pollDeviceCode,
@@ -2306,6 +2619,7 @@ export {
   resolveCodexResponseTimeoutPolicy,
   sanitizeMcpJsonBody,
   sanitizeMcpSseBody,
+  selectCodexCredentialId,
   startDeviceCode,
   truncateMiddleWithTokenBudget,
   withCodexRequestOverrides