@code-yeongyu/senpi 2026.5.29 → 2026.6.3

package/node_modules/@earendil-works/pi-ai/dist/providers/openai-codex-responses.js

@@ -15,9 +15,9 @@ if (typeof process !== "undefined" && (process.versions?.node || process.version
         _os = m;
     });
 }
-import { getEnvApiKey } from "../env-api-keys.js";
 import { clampThinkingLevel, supportsXhigh } 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 { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
@@ -32,6 +32,8 @@ 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;
+const DEFAULT_SSE_HEADER_TIMEOUT_MS = 10_000;
+const DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS = 15_000;
 const CODEX_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
 const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
 const CODEX_RESPONSE_STATUSES = new Set([
@@ -96,6 +98,27 @@ function sleep(ms, signal) {
         });
     });
 }
+function normalizeTimeoutMs(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`Invalid timeoutMs: ${String(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,
+    };
+}
 // ============================================================================
 // Main Stream Function
 // ============================================================================
@@ -120,7 +143,7 @@ export const streamOpenAICodexResponses = (model, context, options) => {
             timestamp: Date.now(),
         };
         try {
-            const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+            const apiKey = options?.apiKey;
             if (!apiKey) {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
@@ -134,6 +157,8 @@ export const streamOpenAICodexResponses = (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 websocketConnectTimeoutMs = normalizeTimeoutMs(options?.websocketConnectTimeoutMs);
             const transport = options?.transport || "auto";
             const websocketDisabledForSession = transport !== "sse" && isWebSocketSseFallbackActive(options?.sessionId);
             if (websocketDisabledForSession) {
@@ -144,7 +169,7 @@ export const streamOpenAICodexResponses = (model, context, options) => {
                 try {
                     await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), body, websocketHeaders, output, stream, model, () => {
                         websocketStarted = true;
-                    }, options);
+                    }, idleTimeoutMs, websocketConnectTimeoutMs, options);
                     if (options?.signal?.aborted) {
                         throw new Error("Request was aborted");
                     }
@@ -184,12 +209,24 @@ export const streamOpenAICodexResponses = (model, context, options) => {
                     throw new Error("Request was aborted");
                 }
                 try {
-                    response = await fetch(resolveCodexUrl(model.baseUrl), {
-                        method: "POST",
-                        headers: sseHeaders,
-                        body: bodyJson,
-                        signal: options?.signal,
-                    });
+                    const headerTimeout = createSSEHeaderTimeout();
+                    const combinedSignal = combineAbortSignals([options?.signal, headerTimeout.signal]);
+                    try {
+                        response = await fetch(resolveCodexUrl(model.baseUrl), {
+                            method: "POST",
+                            headers: sseHeaders,
+                            body: bodyJson,
+                            signal: combinedSignal.signal,
+                        });
+                    }
+                    catch (error) {
+                        const timeoutError = headerTimeout.error();
+                        throw timeoutError && !options?.signal?.aborted ? timeoutError : error;
+                    }
+                    finally {
+                        combinedSignal.cleanup();
+                        headerTimeout.clear();
+                    }
                     await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
                     if (response.ok) {
                         break;
@@ -257,7 +294,7 @@ export const streamOpenAICodexResponses = (model, context, options) => {
     return stream;
 };
 export const streamSimpleOpenAICodexResponses = (model, context, options) => {
-    const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+    const apiKey = options?.apiKey;
     if (!apiKey) {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
@@ -277,6 +314,7 @@ function buildRequestBody(model, context, options) {
     const messages = convertResponsesMessages(model, context, CODEX_TOOL_CALL_PROVIDERS, {
         includeSystemPrompt: false,
         preserveThinking: reasoningRequested,
+        preserveTextSignatures: true,
     });
     const body = {
         model: model.id,
@@ -360,7 +398,7 @@ function resolveCodexWebSocketUrl(baseUrl) {
 // Response Processing
 // ============================================================================
 async function processStream(response, output, stream, model, options) {
-    await processResponsesStream(mapCodexEvents(parseSSE(response)), output, stream, model, {
+    await processResponsesStream(mapCodexEvents(parseSSE(response, options?.signal)), output, stream, model, {
         serviceTier: options?.serviceTier,
         resolveServiceTier: resolveCodexServiceTier,
         applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
@@ -428,15 +466,25 @@ function normalizeCodexStatus(status) {
 // ============================================================================
 // SSE Parsing
 // ============================================================================
-async function* parseSSE(response) {
+async function* parseSSE(response, signal) {
     if (!response.body)
         return;
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
+    const onAbort = () => {
+        void reader.cancel().catch(() => { });
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
     try {
         while (true) {
+            if (signal?.aborted) {
+                throw new Error("Request was aborted");
+            }
             const { done, value } = await reader.read();
+            if (signal?.aborted) {
+                throw new Error("Request was aborted");
+            }
             if (done)
                 break;
             buffer += decoder.decode(value, { stream: true });
@@ -467,6 +515,7 @@ async function* parseSSE(response) {
         }
     }
     finally {
+        signal?.removeEventListener("abort", onAbort);
         try {
             await reader.cancel();
         }
@@ -642,7 +691,7 @@ function scheduleSessionWebSocketExpiry(sessionId, entry) {
         websocketSessionCache.delete(sessionId);
     }, SESSION_WEBSOCKET_CACHE_TTL_MS);
 }
-async function connectWebSocket(url, headers, signal) {
+async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS) {
     const WebSocketCtor = await getWebSocketConstructor();
     if (!WebSocketCtor) {
         throw new Error("WebSocket transport is not available in this runtime");
@@ -651,6 +700,7 @@ async function connectWebSocket(url, headers, signal) {
     delete wsHeaders["OpenAI-Beta"];
     return new Promise((resolve, reject) => {
         let settled = false;
+        let timeout;
         let socket;
         try {
             socket = new WebSocketCtor(url, { headers: wsHeaders });
@@ -659,62 +709,63 @@ async function connectWebSocket(url, headers, signal) {
             reject(error instanceof Error ? error : new Error(String(error)));
             return;
         }
-        const onOpen = () => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            resolve(socket);
+        const cleanup = () => {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = undefined;
+            }
+            socket.removeEventListener("open", onOpen);
+            socket.removeEventListener("error", onError);
+            socket.removeEventListener("close", onClose);
+            signal?.removeEventListener("abort", onAbort);
         };
-        const onError = (event) => {
-            const error = extractWebSocketError(event);
+        const fail = (error, closeReason) => {
             if (settled)
                 return;
             settled = true;
             cleanup();
+            if (closeReason) {
+                closeWebSocketSilently(socket, 1000, closeReason);
+            }
             reject(error);
         };
-        const onClose = (event) => {
-            const error = extractWebSocketCloseError(event);
+        const onOpen = () => {
             if (settled)
                 return;
             settled = true;
             cleanup();
-            reject(error);
+            resolve(socket);
         };
-        const onAbort = () => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            socket.close(1000, "aborted");
-            reject(new Error("Request was aborted"));
+        const onError = (event) => {
+            fail(extractWebSocketError(event));
         };
-        const cleanup = () => {
-            socket.removeEventListener("open", onOpen);
-            socket.removeEventListener("error", onError);
-            socket.removeEventListener("close", onClose);
-            signal?.removeEventListener("abort", onAbort);
+        const onClose = (event) => {
+            fail(extractWebSocketCloseError(event));
+        };
+        const onAbort = () => {
+            fail(new Error("Request was aborted"), "aborted");
         };
         socket.addEventListener("open", onOpen);
         socket.addEventListener("error", onError);
         socket.addEventListener("close", onClose);
         signal?.addEventListener("abort", onAbort);
+        if (connectTimeoutMs > 0) {
+            timeout = setTimeout(() => {
+                fail(new Error(`WebSocket connect timeout after ${connectTimeoutMs}ms`), "connect_timeout");
+            }, connectTimeoutMs);
+        }
+        if (signal?.aborted) {
+            onAbort();
+        }
     });
 }
-async function acquireWebSocket(url, headers, sessionId, signal) {
+async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutMs) {
     if (!sessionId) {
-        const socket = await connectWebSocket(url, headers, signal);
+        const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs);
         return {
             socket,
             reused: false,
-            release: ({ keep } = {}) => {
-                if (keep === false) {
-                    closeWebSocketSilently(socket);
-                    return;
-                }
-                closeWebSocketSilently(socket);
-            },
+            release: () => closeWebSocketSilently(socket),
         };
     }
     const cached = websocketSessionCache.get(sessionId);
@@ -741,7 +792,7 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
             };
         }
         if (cached.busy) {
-            const socket = await connectWebSocket(url, headers, signal);
+            const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs);
             return {
                 socket,
                 reused: false,
@@ -755,7 +806,7 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
             websocketSessionCache.delete(sessionId);
         }
     }
-    const socket = await connectWebSocket(url, headers, signal);
+    const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs);
     const entry = { socket, busy: true };
     websocketSessionCache.set(sessionId, entry);
     return {
@@ -831,7 +882,7 @@ async function decodeWebSocketData(data) {
     }
     return null;
 }
-async function* parseWebSocket(socket, signal) {
+async function* parseWebSocket(socket, signal, idleTimeoutMs) {
     const queue = [];
     let pending = null;
     let done = false;
@@ -909,8 +960,23 @@ async function* parseWebSocket(socket, signal) {
             }
             if (done)
                 break;
-            await new Promise((resolve) => {
+            let timeout;
+            await new Promise((resolve, reject) => {
                 pending = resolve;
+                if (idleTimeoutMs !== undefined && idleTimeoutMs > 0) {
+                    timeout = setTimeout(() => {
+                        const error = new Error(`WebSocket idle timeout after ${idleTimeoutMs}ms`);
+                        failed = error;
+                        done = true;
+                        pending = null;
+                        closeWebSocketSilently(socket, 1000, "idle_timeout");
+                        reject(error);
+                    }, idleTimeoutMs);
+                }
+            }).finally(() => {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
             });
         }
         if (failed) {
@@ -979,8 +1045,8 @@ async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart
         yield event;
     }
 }
-async function processWebSocketStream(url, body, headers, output, stream, model, onStart, options) {
-    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
+async function processWebSocketStream(url, body, headers, output, stream, model, onStart, idleTimeoutMs, websocketConnectTimeoutMs, options) {
+    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal, websocketConnectTimeoutMs);
     let keepConnection = true;
     const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
     // ChatGPT Codex Responses rejects `store: true` ("Store must be set to false").
@@ -1012,7 +1078,7 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
     }
     try {
         socket.send(JSON.stringify({ type: "response.create", ...requestBody }));
-        await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal)), output, stream, onStart), output, stream, model, {
+        await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal, idleTimeoutMs)), output, stream, onStart), output, stream, model, {
             serviceTier: options?.serviceTier,
             resolveServiceTier: resolveCodexServiceTier,
             applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),