@code-yeongyu/senpi-ai 2026.7.31 → 2026.8.3

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

@@ -6,7 +6,7 @@ function loadNodeOs() {
 }
 // NEVER convert to top-level runtime imports - breaks browser/Vite builds
 const _os = loadNodeOs();
-import { clampThinkingLevel, supportsXhigh } from "../models.js";
+import { clampThinkingLevel, supportsMax, supportsXhigh } from "../models.js";
 import { registerSessionResourceCleanup } from "../session-resources.js";
 import { combineAbortSignals } from "../utils/abort-signals.js";
 import { splitDeferredTools } from "../utils/deferred-tools.js";
@@ -16,10 +16,12 @@ import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { resolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
 import { extractOpenAiCodexAccountId } from "../utils/openai-codex-auth.js";
+import { appendRetryAfterMsMarker, extract429RetryAfterMs } from "../utils/retry-hint.js";
 import { uuidv7 } from "../utils/uuid.js";
 import { createGrammarToolInputProperties } from "./constrained-sampling.js";
+import { clearWebSocketFallbackState, getOrCreateWebSocketDebugStats, getWebSocketDebugStats, isWebSocketSseFallbackActive, recordWebSocketFailure, recordWebSocketSseFallback, } from "./openai-codex-responses/fallback-state.js";
 import { buildCodexReasoning } from "./openai-codex-responses/reasoning.js";
-import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
+import { applyOpenAICodexCacheAffinityHeaders, clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
 import { applyExtraBody, buildBaseOptions, clampMaxForOpenAI, OPENAI_RESPONSES_RESERVED_BODY_KEYS, } from "./simple-options.js";
 // ============================================================================
@@ -46,6 +48,14 @@ const CODEX_RESPONSE_STATUSES = new Set([
     "queued",
     "in_progress",
 ]);
+function assertSuccessfulOutput(output) {
+    if (output.stopReason === "pending") {
+        throw new Error("Codex stream ended without a stop reason");
+    }
+    if (output.stopReason === "error" || output.stopReason === "aborted") {
+        throw new Error(output.errorMessage || "An unknown error occurred");
+    }
+}
 // ============================================================================
 // Retry Helpers
 // ============================================================================
@@ -61,28 +71,6 @@ function isRetryableError(status, errorText) {
     }
     return /rate.?limit|overloaded|service.?unavailable|upstream.?connect|connection.?refused/i.test(errorText);
 }
-function getRetryAfterDelayMs(headers) {
-    const retryAfterMs = headers.get("retry-after-ms");
-    if (retryAfterMs !== null) {
-        const millis = Number(retryAfterMs);
-        if (Number.isFinite(millis)) {
-            return Math.max(0, millis);
-        }
-    }
-    const retryAfter = headers.get("retry-after");
-    if (!retryAfter) {
-        return undefined;
-    }
-    const seconds = Number(retryAfter);
-    if (Number.isFinite(seconds)) {
-        return Math.max(0, seconds * 1000);
-    }
-    const date = Date.parse(retryAfter);
-    if (!Number.isNaN(date)) {
-        return Math.max(0, date - Date.now());
-    }
-    return undefined;
-}
 class RetryDelayExceededError extends Error {
 }
 function validateRetryDelayMs(delayMs, options) {
@@ -162,7 +150,7 @@ export const stream = (model, context, options) => {
                 totalTokens: 0,
                 cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
             },
-            stopReason: "stop",
+            stopReason: "pending",
             timestamp: Date.now(),
         };
         try {
@@ -204,10 +192,11 @@ export const stream = (model, context, options) => {
                                 startEmitted = true;
                                 stream.push({ type: "start", partial: output });
                             }
-                        }, httpTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, grammarToolInputProperties, options);
+                        }, httpTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, accountId ?? apiKey, grammarToolInputProperties, options);
                         if (options?.signal?.aborted) {
                             throw new Error("Request was aborted");
                         }
+                        assertSuccessfulOutput(output);
                         stream.push({
                             type: "done",
                             reason: output.stopReason,
@@ -267,7 +256,7 @@ export const stream = (model, context, options) => {
                     const headerTimeoutSignal = httpTimeoutMs !== undefined && httpTimeoutMs > 0 ? AbortSignal.timeout(httpTimeoutMs) : undefined;
                     const combinedSignal = combineAbortSignals([options?.signal, headerTimeoutSignal]);
                     try {
-                        response = await fetch(resolveCodexUrl(model.baseUrl), {
+                        response = await (options?.fetch ?? globalThis.fetch)(resolveCodexUrl(model.baseUrl), {
                             method: "POST",
                             headers: sseHeaders,
                             body: sseBody,
@@ -289,7 +278,14 @@ export const stream = (model, context, options) => {
                     }
                     const errorText = await response.text();
                     if (attempt < maxRetries && isRetryableError(response.status, errorText)) {
-                        const retryAfterDelayMs = getRetryAfterDelayMs(response.headers);
+                        // Force 429 eligibility with empty body so the extractor checks
+                        // only retry-after / retry-after-ms headers (matching the old
+                        // getRetryAfterDelayMs behavior for all retryable statuses).
+                        const retryAfterDelayMs = extract429RetryAfterMs({
+                            status: 429,
+                            headers: response.headers,
+                            bodyText: "",
+                        });
                         const delayMs = retryAfterDelayMs === undefined
                             ? BASE_DELAY_MS * 2 ** attempt
                             : validateRetryDelayMs(retryAfterDelayMs, options);
@@ -302,7 +298,18 @@ export const stream = (model, context, options) => {
                         statusText: response.statusText,
                     });
                     const info = await parseErrorResponse(fakeResponse);
-                    throw new Error(info.friendlyMessage || info.message);
+                    let errorMessage = info.friendlyMessage || info.message;
+                    if (response.status === 429) {
+                        const hintMs = extract429RetryAfterMs({
+                            status: response.status,
+                            headers: response.headers,
+                            bodyText: errorText,
+                        });
+                        if (hintMs !== undefined) {
+                            errorMessage = appendRetryAfterMsMarker(errorMessage, hintMs);
+                        }
+                    }
+                    throw new Error(errorMessage);
                 }
                 catch (error) {
                     if (error instanceof Error) {
@@ -336,6 +343,7 @@ export const stream = (model, context, options) => {
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
+            assertSuccessfulOutput(output);
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
         }
@@ -362,7 +370,7 @@ export const streamSimple = (model, context, options) => {
     const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
     const reasoningEffort = clampedReasoning === "off"
         ? undefined
-        : clampedReasoning === "max" && model.thinkingLevelMap?.max !== undefined
+        : clampedReasoning === "max" && supportsMax(model)
             ? "max"
             : clampMaxForOpenAI(clampedReasoning, supportsXhigh(model));
     return stream(model, context, {
@@ -540,7 +548,12 @@ async function* mapCodexEvents(events) {
         if (type === "error") {
             const code = getCodexEventErrorCode(event);
             const message = getCodexEventErrorMessage(event);
-            throw new CodexApiError(`Codex error: ${message || code || JSON.stringify(event)}`, {
+            let errorText = `Codex error: ${message || code || JSON.stringify(event)}`;
+            const hintMs = extract429RetryAfterMs({ bodyText: JSON.stringify(event) });
+            if (hintMs !== undefined) {
+                errorText = appendRetryAfterMsMarker(errorText, hintMs);
+            }
+            throw new CodexApiError(errorText, {
                 code: code || undefined,
                 payload: event,
             });
@@ -548,7 +561,12 @@ async function* mapCodexEvents(events) {
         if (type === "response.failed") {
             const code = getCodexEventErrorCode(event);
             const message = getCodexEventErrorMessage(event);
-            throw new CodexApiError(message || "Codex response failed", { code, payload: event });
+            let errorText = message || "Codex response failed";
+            const hintMs = extract429RetryAfterMs({ bodyText: JSON.stringify(event) });
+            if (hintMs !== undefined) {
+                errorText = appendRetryAfterMsMarker(errorText, hintMs);
+            }
+            throw new CodexApiError(errorText, { code, payload: event });
         }
         if (type === "response.done" || type === "response.completed" || type === "response.incomplete") {
             const response = event.response;
@@ -637,39 +655,11 @@ 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();
-function getOrCreateWebSocketDebugStats(sessionId) {
-    let stats = websocketDebugStats.get(sessionId);
-    if (!stats) {
-        stats = {
-            requests: 0,
-            connectionsCreated: 0,
-            connectionsReused: 0,
-            cachedContextRequests: 0,
-            storeTrueRequests: 0,
-            fullContextRequests: 0,
-            deltaRequests: 0,
-            lastInputItems: 0,
-            websocketFailures: 0,
-            sseFallbacks: 0,
-        };
-        websocketDebugStats.set(sessionId, stats);
-    }
-    return stats;
-}
 export function getOpenAICodexWebSocketDebugStats(sessionId) {
-    const stats = websocketDebugStats.get(sessionId);
-    return stats ? { ...stats } : undefined;
+    return getWebSocketDebugStats(sessionId);
 }
 export function resetOpenAICodexWebSocketDebugStats(sessionId) {
-    if (sessionId) {
-        websocketDebugStats.delete(sessionId);
-        websocketSseFallbackSessions.delete(sessionId);
-        return;
-    }
-    websocketDebugStats.clear();
-    websocketSseFallbackSessions.clear();
+    clearWebSocketFallbackState(sessionId);
 }
 export function closeOpenAICodexWebSocketSessions(sessionId) {
     const closeEntry = (entry) => {
@@ -678,37 +668,20 @@ export function closeOpenAICodexWebSocketSessions(sessionId) {
         closeWebSocketSilently(entry.socket, 1000, "debug_close");
     };
     if (sessionId) {
-        const entry = websocketSessionCache.get(sessionId);
-        if (entry)
+        for (const entry of websocketSessionCache.get(sessionId)?.values() ?? [])
             closeEntry(entry);
         websocketSessionCache.delete(sessionId);
+        clearWebSocketFallbackState(sessionId);
         return;
     }
-    for (const entry of websocketSessionCache.values()) {
-        closeEntry(entry);
+    for (const accountEntries of websocketSessionCache.values()) {
+        for (const entry of accountEntries.values())
+            closeEntry(entry);
     }
     websocketSessionCache.clear();
+    clearWebSocketFallbackState();
 }
 registerSessionResourceCleanup(closeOpenAICodexWebSocketSessions);
-function isWebSocketSseFallbackActive(sessionId) {
-    return sessionId ? websocketSseFallbackSessions.has(sessionId) : false;
-}
-function recordWebSocketSseFallback(sessionId) {
-    if (!sessionId)
-        return;
-    const stats = getOrCreateWebSocketDebugStats(sessionId);
-    stats.sseFallbacks++;
-    stats.websocketFallbackActive = isWebSocketSseFallbackActive(sessionId);
-}
-function recordWebSocketFailure(sessionId, error) {
-    if (!sessionId)
-        return;
-    websocketSseFallbackSessions.add(sessionId);
-    const stats = getOrCreateWebSocketDebugStats(sessionId);
-    stats.websocketFailures++;
-    stats.lastWebSocketError = formatThrownValue(error);
-    stats.websocketFallbackActive = true;
-}
 let _cachedWebsocket = null;
 async function getWebSocketConstructor(env) {
     if (!env && _cachedWebsocket)
@@ -784,7 +757,7 @@ function closeWebSocketSilently(socket, code = 1000, reason = "done") {
     }
     catch { }
 }
-function scheduleSessionWebSocketExpiry(sessionId, entry) {
+function scheduleSessionWebSocketExpiry(sessionId, accountId, entry) {
     if (entry.idleTimer) {
         clearTimeout(entry.idleTimer);
     }
@@ -792,7 +765,11 @@ function scheduleSessionWebSocketExpiry(sessionId, entry) {
         if (entry.busy)
             return;
         closeWebSocketSilently(entry.socket, 1000, "idle_timeout");
-        websocketSessionCache.delete(sessionId);
+        const accountEntries = websocketSessionCache.get(sessionId);
+        if (accountEntries?.get(accountId) === entry)
+            accountEntries.delete(accountId);
+        if (accountEntries?.size === 0)
+            websocketSessionCache.delete(sessionId);
     }, SESSION_WEBSOCKET_CACHE_TTL_MS);
 }
 async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS, env) {
@@ -863,7 +840,7 @@ async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT
         }
     });
 }
-async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutMs, env) {
+async function acquireWebSocket(url, headers, sessionId, accountId, signal, connectTimeoutMs, env) {
     if (!sessionId) {
         const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
         return {
@@ -872,7 +849,8 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
             release: () => closeWebSocketSilently(socket),
         };
     }
-    const cached = websocketSessionCache.get(sessionId);
+    let accountEntries = websocketSessionCache.get(sessionId);
+    const cached = accountEntries?.get(accountId);
     if (cached) {
         if (cached.idleTimer) {
             clearTimeout(cached.idleTimer);
@@ -880,7 +858,9 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
         }
         if (!cached.busy && isWebSocketSessionExpired(cached)) {
             closeWebSocketSilently(cached.socket, 1000, "connection_age_limit");
-            websocketSessionCache.delete(sessionId);
+            accountEntries?.delete(accountId);
+            if (accountEntries?.size === 0)
+                websocketSessionCache.delete(sessionId);
         }
         else if (!cached.busy && isWebSocketReusable(cached.socket)) {
             cached.busy = true;
@@ -891,11 +871,15 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
                 release: ({ keep } = {}) => {
                     if (!keep || !isWebSocketReusable(cached.socket)) {
                         closeWebSocketSilently(cached.socket);
-                        websocketSessionCache.delete(sessionId);
+                        const currentEntries = websocketSessionCache.get(sessionId);
+                        if (currentEntries?.get(accountId) === cached)
+                            currentEntries.delete(accountId);
+                        if (currentEntries?.size === 0)
+                            websocketSessionCache.delete(sessionId);
                         return;
                     }
                     cached.busy = false;
-                    scheduleSessionWebSocketExpiry(sessionId, cached);
+                    scheduleSessionWebSocketExpiry(sessionId, accountId, cached);
                 },
             };
         }
@@ -911,12 +895,19 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
         }
         if (!isWebSocketReusable(cached.socket)) {
             closeWebSocketSilently(cached.socket);
-            websocketSessionCache.delete(sessionId);
+            accountEntries?.delete(accountId);
+            if (accountEntries?.size === 0)
+                websocketSessionCache.delete(sessionId);
         }
     }
     const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
     const entry = { socket, busy: true, createdAt: Date.now() };
-    websocketSessionCache.set(sessionId, entry);
+    accountEntries = websocketSessionCache.get(sessionId);
+    if (!accountEntries) {
+        accountEntries = new Map();
+        websocketSessionCache.set(sessionId, accountEntries);
+    }
+    accountEntries.set(accountId, entry);
     return {
         socket,
         entry,
@@ -926,13 +917,15 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
                 closeWebSocketSilently(entry.socket);
                 if (entry.idleTimer)
                     clearTimeout(entry.idleTimer);
-                if (websocketSessionCache.get(sessionId) === entry) {
+                const currentEntries = websocketSessionCache.get(sessionId);
+                if (currentEntries?.get(accountId) === entry)
+                    currentEntries.delete(accountId);
+                if (currentEntries?.size === 0)
                     websocketSessionCache.delete(sessionId);
-                }
                 return;
             }
             entry.busy = false;
-            scheduleSessionWebSocketExpiry(sessionId, entry);
+            scheduleSessionWebSocketExpiry(sessionId, accountId, entry);
         },
     };
 }
@@ -1176,8 +1169,8 @@ async function* startWebSocketOutputOnFirstEvent(events, onStart) {
         yield event;
     }
 }
-async function processWebSocketStream(url, body, headers, output, stream, model, onStart, idleTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, grammarToolInputProperties, options) {
-    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, cacheSessionId, options?.signal, websocketConnectTimeoutMs, options?.env);
+async function processWebSocketStream(url, body, headers, output, stream, model, onStart, idleTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, accountId, grammarToolInputProperties, options) {
+    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, cacheSessionId, accountId, options?.signal, websocketConnectTimeoutMs, options?.env);
     let keepConnection = true;
     const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
     // ChatGPT Codex Responses rejects `store: true` ("Store must be set to false").
@@ -1298,10 +1291,7 @@ function buildSSEHeaders(initHeaders, additionalHeaders, accountId, token, sessi
     headers.set("OpenAI-Beta", "responses=experimental");
     headers.set("accept", "text/event-stream");
     headers.set("content-type", "application/json");
-    if (sessionId) {
-        headers.set("session-id", sessionId);
-        headers.set("x-client-request-id", sessionId);
-    }
+    applyOpenAICodexCacheAffinityHeaders(headers, sessionId);
     return headers;
 }
 function buildWebSocketHeaders(initHeaders, additionalHeaders, accountId, token, requestId) {
@@ -1311,8 +1301,7 @@ function buildWebSocketHeaders(initHeaders, additionalHeaders, accountId, token,
     headers.delete("OpenAI-Beta");
     headers.delete("openai-beta");
     headers.set("OpenAI-Beta", OPENAI_BETA_RESPONSES_WEBSOCKETS);
-    headers.set("x-client-request-id", requestId);
-    headers.set("session-id", requestId);
+    applyOpenAICodexCacheAffinityHeaders(headers, requestId);
     return headers;
 }
 //# sourceMappingURL=openai-codex-responses.js.map