@earendil-works/pi-ai 0.80.2 → 0.80.5

package/dist/api/openai-codex-responses.js

@@ -1,24 +1,16 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
+function loadNodeOs() {
+    if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) {
+        return null;
     }
-    return path;
-};
-// NEVER convert to top-level runtime imports - breaks browser/Vite builds
-let _os = null;
-const dynamicImport = (specifier) => import(__rewriteRelativeImportExtension(specifier));
-const NODE_OS_SPECIFIER = "node:" + "os";
-if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
-    dynamicImport(NODE_OS_SPECIFIER).then((m) => {
-        _os = m;
-    });
+    return process.getBuiltinModule?.("node:os") ?? null;
 }
+// NEVER convert to top-level runtime imports - breaks browser/Vite builds
+const _os = loadNodeOs();
 import { clampThinkingLevel } from "../models.js";
 import { registerSessionResourceCleanup } from "../session-resources.js";
 import { combineAbortSignals } from "../utils/abort-signals.js";
 import { appendAssistantMessageDiagnostic, createAssistantMessageDiagnostic, formatThrownValue, } from "../utils/diagnostics.js";
+import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { resolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
@@ -33,10 +25,10 @@ const JWT_CLAIM_PATH = "https://api.openai.com/auth";
 const DEFAULT_MAX_RETRIES = 0;
 const BASE_DELAY_MS = 1000;
 const DEFAULT_MAX_RETRY_DELAY_MS = 60_000;
-// Keep a bounded pre-header timeout so zero-event Codex SSE stalls fail instead of
-// leaving callers stuck on "Working..." indefinitely. See #4945.
-const DEFAULT_SSE_HEADER_TIMEOUT_MS = 20_000;
 const DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS = 15_000;
+// The Codex backend accepts zstd-compressed request bodies on the SSE responses
+// endpoint (the same endpoint the official Codex client compresses against).
+const REQUEST_COMPRESSION_ZSTD_LEVEL = 3;
 const CODEX_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
 const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
 const WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE = "websocket_connection_limit_reached";
@@ -110,18 +102,29 @@ function normalizeTimeoutMs(value) {
     }
     return Math.floor(value);
 }
-function createSSEHeaderTimeout() {
-    const controller = new AbortController();
-    let error;
-    const timeout = setTimeout(() => {
-        error = new Error(`Codex SSE response headers timed out after ${DEFAULT_SSE_HEADER_TIMEOUT_MS}ms`);
-        controller.abort(error);
-    }, DEFAULT_SSE_HEADER_TIMEOUT_MS);
-    return {
-        signal: controller.signal,
-        clear: () => clearTimeout(timeout),
-        error: () => error,
-    };
+function loadNodeZlib() {
+    if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) {
+        return null;
+    }
+    return process.getBuiltinModule?.("node:zlib") ?? null;
+}
+// Returns the zstd-compressed body bytes, or null when compression is
+// unavailable (browser/Vite builds). Callers fall back to sending the
+// uncompressed JSON when this returns null.
+function compressRequestBodyZstd(bodyJson) {
+    const zlib = loadNodeZlib();
+    if (!zlib || typeof zlib.zstdCompressSync !== "function") {
+        return null;
+    }
+    try {
+        const compressed = zlib.zstdCompressSync(bodyJson, {
+            params: { [zlib.constants.ZSTD_c_compressionLevel]: REQUEST_COMPRESSION_ZSTD_LEVEL },
+        });
+        return new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength);
+    }
+    catch {
+        return null;
+    }
 }
 // ============================================================================
 // Main Stream Function
@@ -161,7 +164,7 @@ export const stream = (model, context, options) => {
             const sseHeaders = buildSSEHeaders(model.headers, options?.headers, accountId, apiKey, options?.sessionId);
             const websocketHeaders = buildWebSocketHeaders(model.headers, options?.headers, accountId, apiKey, websocketRequestId);
             const bodyJson = JSON.stringify(body);
-            const idleTimeoutMs = normalizeTimeoutMs(options?.timeoutMs);
+            const httpTimeoutMs = normalizeTimeoutMs(options?.timeoutMs);
             const websocketConnectTimeoutMs = normalizeTimeoutMs(options?.websocketConnectTimeoutMs);
             const transport = options?.transport || "auto";
             const websocketDisabledForSession = transport !== "sse" && isWebSocketSseFallbackActive(options?.sessionId);
@@ -176,7 +179,7 @@ export const stream = (model, context, options) => {
                     try {
                         await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), body, websocketHeaders, output, stream, model, () => {
                             websocketStarted = true;
-                        }, idleTimeoutMs, websocketConnectTimeoutMs, options);
+                        }, httpTimeoutMs, websocketConnectTimeoutMs, options);
                         if (options?.signal?.aborted) {
                             throw new Error("Request was aborted");
                         }
@@ -214,6 +217,14 @@ export const stream = (model, context, options) => {
                     }
                 }
             }
+            // Compress the request body once for the SSE path. The Codex backend
+            // decodes Content-Encoding: zstd; the WebSocket transport above sends the
+            // uncompressed JSON frame, matching the official Codex client.
+            const compressedBody = compressRequestBodyZstd(bodyJson);
+            if (compressedBody) {
+                sseHeaders.set("content-encoding", "zstd");
+            }
+            const sseBody = compressedBody ?? bodyJson;
             // Fetch with retry logic for rate limits and transient errors
             let response;
             let lastError;
@@ -223,23 +234,24 @@ export const stream = (model, context, options) => {
                     throw new Error("Request was aborted");
                 }
                 try {
-                    const headerTimeout = createSSEHeaderTimeout();
-                    const combinedSignal = combineAbortSignals([options?.signal, headerTimeout.signal]);
+                    const headerTimeoutSignal = httpTimeoutMs !== undefined && httpTimeoutMs > 0 ? AbortSignal.timeout(httpTimeoutMs) : undefined;
+                    const combinedSignal = combineAbortSignals([options?.signal, headerTimeoutSignal]);
                     try {
                         response = await fetch(resolveCodexUrl(model.baseUrl), {
                             method: "POST",
                             headers: sseHeaders,
-                            body: bodyJson,
+                            body: sseBody,
                             signal: combinedSignal.signal,
                         });
                     }
                     catch (error) {
-                        const timeoutError = headerTimeout.error();
-                        throw timeoutError && !options?.signal?.aborted ? timeoutError : error;
+                        if (headerTimeoutSignal?.aborted && !options?.signal?.aborted) {
+                            throw new Error(`Codex SSE response headers timed out after ${httpTimeoutMs}ms`);
+                        }
+                        throw error;
                     }
                     finally {
                         combinedSignal.cleanup();
-                        headerTimeout.clear();
                     }
                     await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
                     if (response.ok) {
@@ -300,7 +312,7 @@ export const stream = (model, context, options) => {
                 delete block.partialJson;
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : String(error);
+            output.errorMessage = formatProviderError(normalizeProviderError(error));
             stream.push({ type: "error", reason: output.stopReason, error: output });
             stream.end();
         }
@@ -312,7 +324,7 @@ export const streamSimple = (model, context, options) => {
     if (!apiKey) {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
-    const base = buildBaseOptions(model, options, apiKey);
+    const base = buildBaseOptions(model, context, options, apiKey);
     const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
     const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
     return stream(model, context, {
@@ -553,6 +565,7 @@ async function* parseSSE(response, signal) {
 // ============================================================================
 const OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
 const SESSION_WEBSOCKET_CACHE_TTL_MS = 5 * 60 * 1000;
+const SESSION_WEBSOCKET_MAX_AGE_MS = 55 * 60 * 1000;
 const websocketSessionCache = new Map();
 const websocketDebugStats = new Map();
 const websocketSseFallbackSessions = new Set();
@@ -677,6 +690,9 @@ function isWebSocketReusable(socket) {
     // If readyState is unavailable, assume the runtime keeps it open/reusable.
     return readyState === undefined || readyState === 1;
 }
+function isWebSocketSessionExpired(entry) {
+    return Date.now() - entry.createdAt >= SESSION_WEBSOCKET_MAX_AGE_MS;
+}
 function closeWebSocketSilently(socket, code = 1000, reason = "done") {
     try {
         socket.close(code, reason);
@@ -777,7 +793,11 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
             clearTimeout(cached.idleTimer);
             cached.idleTimer = undefined;
         }
-        if (!cached.busy && isWebSocketReusable(cached.socket)) {
+        if (!cached.busy && isWebSocketSessionExpired(cached)) {
+            closeWebSocketSilently(cached.socket, 1000, "connection_age_limit");
+            websocketSessionCache.delete(sessionId);
+        }
+        else if (!cached.busy && isWebSocketReusable(cached.socket)) {
             cached.busy = true;
             return {
                 socket: cached.socket,
@@ -810,7 +830,7 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
         }
     }
     const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
-    const entry = { socket, busy: true };
+    const entry = { socket, busy: true, createdAt: Date.now() };
     websocketSessionCache.set(sessionId, entry);
     return {
         socket,