@opengeni/codex 2.0.1 → 2.0.2-canary.38789554071001

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export * from "./api-client.js";
 export * from "./request-context.js";
 export * from "./response-timeout.js";
 export * from "./fetch.js";
+export * from "./responses-websocket.js";
 export * from "./mcp-sanitize.js";
 export * from "./model-output-truncation.js";
 export * from "./opaque-artifact.js";

package/dist/index.js

@@ -2037,6 +2037,322 @@ function inspectCodexSseBlock(block, source, onSemanticTerminal, onOutput) {
   return false;
 }
 
+// src/responses-websocket.ts
+var CODEX_RESPONSES_WEBSOCKET_BETA = "responses_websockets=2026-02-06";
+var DEFAULT_IDLE_MS = 5 * 6e4;
+var DEFAULT_MAX_AGE_MS = 45 * 6e4;
+var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
+var DEFAULT_HANDSHAKE_BACKOFF_MS = 5 * 6e4;
+var PER_REQUEST_HEADERS = /* @__PURE__ */ new Set([
+  "accept",
+  "content-type",
+  "content-length",
+  "idempotency-key",
+  "openai-beta"
+]);
+var TERMINAL_EVENTS = /* @__PURE__ */ new Set([
+  "response.completed",
+  "response.done",
+  "response.failed",
+  "response.incomplete",
+  "response.error",
+  "error"
+]);
+var RATE_LIMITS_EVENT = "codex.rate_limits";
+var METADATA_EVENT = "codex.response.metadata";
+var TIMING_EVENT = "responsesapi.websocket_timing";
+var HEADER_NAME = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+function bunWebSocketFactory() {
+  const runtime = globalThis;
+  if (!runtime.Bun || typeof runtime.WebSocket !== "function") return null;
+  const Socket = runtime.WebSocket;
+  return (url, headers) => new Socket(url, { headers });
+}
+function eventData(data) {
+  if (typeof data === "string") return data;
+  if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+  if (ArrayBuffer.isView(data)) return new TextDecoder().decode(data);
+  return null;
+}
+function codexRateLimitHeaders(event) {
+  const limits = event.rate_limits;
+  if (!limits || typeof limits !== "object") return [];
+  const headers = [];
+  for (const slot of ["primary", "secondary"]) {
+    const window = limits[slot];
+    if (!window || typeof window !== "object") continue;
+    const value = window;
+    const number3 = (field) => typeof value[field] === "number" && Number.isFinite(value[field]) ? Math.round(value[field]) : null;
+    const used = number3("used_percent");
+    const minutes = number3("window_minutes");
+    const resetAfter = number3("reset_after_seconds");
+    const resetAt = number3("reset_at");
+    if (used !== null) headers.push([`x-codex-${slot}-used-percent`, String(used)]);
+    if (minutes !== null) {
+      headers.push([`x-codex-${slot}-window-minutes`, String(minutes)]);
+      headers.push([`x-codex-${slot}-limit-window-seconds`, String(minutes * 60)]);
+    }
+    if (resetAfter !== null)
+      headers.push([`x-codex-${slot}-reset-after-seconds`, String(resetAfter)]);
+    if (resetAt !== null) headers.push([`x-codex-${slot}-reset-at`, String(resetAt)]);
+  }
+  return headers;
+}
+function metadataHeaders(event) {
+  const headers = event.headers;
+  if (!headers || typeof headers !== "object") return [];
+  return Object.entries(headers).flatMap(
+    ([name, value]) => HEADER_NAME.test(name) && typeof value === "string" && !/[\r\n]/.test(value) ? [[name.toLowerCase(), value]] : []
+  );
+}
+function sseBlock(event) {
+  const type = typeof event.type === "string" ? event.type : "message";
+  return new TextEncoder().encode(`event: ${type}
+data: ${JSON.stringify(event)}
+
+`);
+}
+function requestUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.toString();
+  return null;
+}
+function codexResponsesTransport(http, options = {}) {
+  const createSocket = options.createSocket === void 0 ? bunWebSocketFactory() : options.createSocket;
+  if (!createSocket) return http;
+  const idleMs = options.idleMs ?? DEFAULT_IDLE_MS;
+  const maxAgeMs = options.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+  const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+  const handshakeBackoffMs = options.handshakeBackoffMs ?? DEFAULT_HANDSHAKE_BACKOFF_MS;
+  const now = options.now ?? Date.now;
+  const pool = /* @__PURE__ */ new Map();
+  const backoffUntil = /* @__PURE__ */ new Map();
+  const retire = (connection) => {
+    if (connection.idleTimer) clearTimeout(connection.idleTimer);
+    connection.idleTimer = null;
+    if (pool.get(connection.key) === connection) pool.delete(connection.key);
+    if (!connection.closed) {
+      connection.closed = true;
+      try {
+        connection.socket.close(1e3, "done");
+      } catch {
+      }
+    }
+  };
+  const release = (connection) => {
+    connection.busy = false;
+    connection.onEvent = null;
+    connection.onClose = null;
+    if (connection.closed) return;
+    if (connection.idleTimer) clearTimeout(connection.idleTimer);
+    connection.idleTimer = setTimeout(() => retire(connection), idleMs);
+    connection.idleTimer.unref?.();
+  };
+  const connect = (url, key, headers) => new Promise((resolve, reject) => {
+    let socket;
+    try {
+      socket = createSocket(url, headers);
+    } catch (error) {
+      reject(error);
+      return;
+    }
+    const connection = {
+      key,
+      socket,
+      openedAt: now(),
+      busy: false,
+      closed: false,
+      idleTimer: null,
+      onEvent: null,
+      onClose: null
+    };
+    let opened = false;
+    const timer = setTimeout(() => {
+      if (opened) return;
+      connection.closed = true;
+      try {
+        socket.close();
+      } catch {
+      }
+      reject(new Error("Codex response WebSocket handshake timed out"));
+    }, connectTimeoutMs);
+    socket.onopen = () => {
+      opened = true;
+      clearTimeout(timer);
+      resolve(connection);
+    };
+    socket.onerror = () => {
+    };
+    socket.onclose = (event) => {
+      clearTimeout(timer);
+      connection.closed = true;
+      if (pool.get(key) === connection) pool.delete(key);
+      if (connection.idleTimer) clearTimeout(connection.idleTimer);
+      if (!opened) {
+        reject(
+          new Error(`Codex response WebSocket handshake failed (${event?.code ?? "closed"})`)
+        );
+        return;
+      }
+      connection.onClose?.(
+        new Error(
+          `Codex response WebSocket closed before the response finished (${event?.code ?? "closed"})`
+        )
+      );
+    };
+    socket.onmessage = (message) => {
+      const text = eventData(message.data);
+      if (text === null) return;
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        return;
+      }
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        connection.onEvent?.(parsed);
+      }
+    };
+  });
+  return async (input, init) => {
+    const url = requestUrl(input);
+    const method = (init?.method ?? "GET").toUpperCase();
+    const body = init?.body;
+    if (!url || method !== "POST" || typeof body !== "string" || !/^https:\/\/[^/]+\/.*\/codex\/responses(?:\?|$)/.test(url)) {
+      return await http(input, init);
+    }
+    let payload;
+    try {
+      const parsed = JSON.parse(body);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error();
+      payload = parsed;
+    } catch {
+      return await http(input, init);
+    }
+    if (payload.stream !== true) return await http(input, init);
+    const handshake = {};
+    for (const [name, value] of new Headers(init?.headers).entries()) {
+      if (!PER_REQUEST_HEADERS.has(name)) handshake[name] = value;
+    }
+    handshake["openai-beta"] = CODEX_RESPONSES_WEBSOCKET_BETA;
+    const wsUrl = url.replace(/^https:/, "wss:");
+    const key = JSON.stringify([wsUrl, Object.entries(handshake).sort()]);
+    if ((backoffUntil.get(key) ?? 0) > now()) return await http(input, init);
+    const signal = init?.signal ?? null;
+    signal?.throwIfAborted();
+    let connection = pool.get(key);
+    if (connection && (connection.closed || now() - connection.openedAt > maxAgeMs)) {
+      if (!connection.busy) retire(connection);
+      connection = void 0;
+    }
+    if (connection?.busy) return await http(input, init);
+    if (!connection) {
+      try {
+        connection = await connect(wsUrl, key, handshake);
+      } catch {
+        backoffUntil.set(key, now() + handshakeBackoffMs);
+        return await http(input, init);
+      }
+      if (pool.has(key)) {
+        const existing = pool.get(key);
+        if (!existing.busy && !existing.closed) {
+          retire(connection);
+          connection = existing;
+        } else {
+          pool.set(key, connection);
+        }
+      } else {
+        pool.set(key, connection);
+      }
+      if (connection.busy) return await http(input, init);
+    }
+    const active = connection;
+    active.busy = true;
+    if (active.idleTimer) clearTimeout(active.idleTimer);
+    active.idleTimer = null;
+    return await new Promise((resolve, reject) => {
+      const headers = new Headers({ "content-type": "text/event-stream" });
+      let controller = null;
+      let started = false;
+      let finished = false;
+      const pending = [];
+      const finish = (error) => {
+        if (finished) return;
+        finished = true;
+        signal?.removeEventListener("abort", onAbort);
+        if (error !== void 0) {
+          retire(active);
+          active.busy = false;
+          if (started) controller?.error(error);
+          else reject(error);
+          return;
+        }
+        release(active);
+        try {
+          controller?.close();
+        } catch {
+        }
+      };
+      const onAbort = () => finish(signal?.reason ?? new Error("Model request aborted"));
+      signal?.addEventListener("abort", onAbort, { once: true });
+      const stream = new ReadableStream({
+        start(streamController) {
+          controller = streamController;
+          for (const block of pending.splice(0)) streamController.enqueue(block);
+          if (finished) streamController.close();
+        },
+        cancel() {
+          if (!finished) finish(new Error("Model response stream cancelled"));
+        }
+      });
+      const begin = (status = 200, errorBody) => {
+        started = true;
+        if (errorBody !== void 0) {
+          headers.set("content-type", "application/json");
+          resolve(new Response(errorBody, { status, headers }));
+          return;
+        }
+        resolve(new Response(stream, { status, headers }));
+      };
+      active.onClose = (error) => finish(error);
+      active.onEvent = (event) => {
+        if (finished) return;
+        const type = typeof event.type === "string" ? event.type : "";
+        if (type === RATE_LIMITS_EVENT) {
+          if (!started)
+            for (const [name, value] of codexRateLimitHeaders(event)) headers.set(name, value);
+          return;
+        }
+        if (type === METADATA_EVENT) {
+          if (!started)
+            for (const [name, value] of metadataHeaders(event)) headers.set(name, value);
+          return;
+        }
+        if (type === TIMING_EVENT) return;
+        if (!started && type === "error" && typeof event.status === "number") {
+          for (const [name, value] of metadataHeaders(event)) headers.set(name, value);
+          const status = event.status >= 400 && event.status < 600 ? event.status : 500;
+          begin(status, JSON.stringify({ error: event.error ?? null }));
+          finished = true;
+          signal?.removeEventListener("abort", onAbort);
+          release(active);
+          return;
+        }
+        if (!started) begin();
+        const block = sseBlock(event);
+        if (controller) controller.enqueue(block);
+        else pending.push(block);
+        if (TERMINAL_EVENTS.has(type)) finish();
+      };
+      try {
+        active.socket.send(JSON.stringify({ ...payload, type: "response.create" }));
+      } catch (error) {
+        finish(error);
+      }
+    });
+  };
+}
+
 // src/mcp-sanitize.ts
 var VALID_TOOL_NAME = /^[a-zA-Z0-9_-]+$/;
 var MAX_TOOL_NAME_LEN = 64;
@@ -3461,6 +3777,7 @@ export {
   CODEX_REQUEST_ID_HEADER,
   CODEX_REQUEST_MODEL_HEADER,
   CODEX_RESPONSES_BASE,
+  CODEX_RESPONSES_WEBSOCKET_BETA,
   CODEX_RESPONSE_HEADERS_TIMEOUT_MS,
   CODEX_RESPONSE_NO_BYTE_RETRIES,
   CODEX_RESPONSE_RETRY_BACKOFF_MS,
@@ -3505,7 +3822,9 @@ export {
   codexPlanEntitlementLost,
   codexPlanIsUpgrade,
   codexPlanKey,
+  codexRateLimitHeaders,
   codexRequestStorage,
+  codexResponsesTransport,
   codexSubscriptionFetch,
   codexSubscriptionHeaders,
   codexUsageConfirmsQuotaAvailable,