@code-yeongyu/senpi 2026.6.16 → 2026.6.17

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

@@ -21,6 +21,7 @@ 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";
+import { resolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
 import { 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";
@@ -38,6 +39,7 @@ const DEFAULT_SSE_HEADER_TIMEOUT_MS = 20_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_PREVIOUS_RESPONSE_STALE_CODES = new Set(["previous_response_not_found", "codex_previous_response_stale"]);
 const CODEX_RESPONSE_STATUSES = new Set([
     "completed",
     "incomplete",
@@ -426,23 +428,46 @@ class CodexProtocolError extends Error {
 function isCodexNonTransportError(error) {
     return error instanceof CodexApiError || error instanceof CodexProtocolError;
 }
+function asRecord(value) {
+    return value && typeof value === "object" ? value : null;
+}
+function getString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function getCodexEventError(event) {
+    const response = asRecord(event.response);
+    return asRecord(event.error) ?? (response ? asRecord(response.error) : null);
+}
+function getCodexEventErrorCode(event) {
+    const error = getCodexEventError(event);
+    return getString(error?.code) ?? getString(error?.type) ?? getString(event.code) ?? "";
+}
+function getCodexEventErrorMessage(event) {
+    const response = asRecord(event.response);
+    const error = getCodexEventError(event);
+    return getString(error?.message) ?? getString(event.message) ?? getString(response?.message) ?? "";
+}
+function isCodexPreviousResponseStale(error) {
+    return (error instanceof CodexApiError &&
+        typeof error.code === "string" &&
+        CODEX_PREVIOUS_RESPONSE_STALE_CODES.has(error.code));
+}
 async function* mapCodexEvents(events) {
     for await (const event of events) {
         const type = typeof event.type === "string" ? event.type : undefined;
         if (!type)
             continue;
         if (type === "error") {
-            const code = event.code || "";
-            const message = event.message || "";
+            const code = getCodexEventErrorCode(event);
+            const message = getCodexEventErrorMessage(event);
             throw new CodexApiError(`Codex error: ${message || code || JSON.stringify(event)}`, {
                 code: code || undefined,
                 payload: event,
             });
         }
         if (type === "response.failed") {
-            const response = event.response;
-            const code = response?.error?.code;
-            const message = response?.error?.message;
+            const code = getCodexEventErrorCode(event);
+            const message = getCodexEventErrorMessage(event);
             throw new CodexApiError(message || "Codex response failed", { code, payload: event });
         }
         if (type === "response.done" || type === "response.completed" || type === "response.incomplete") {
@@ -604,16 +629,13 @@ function recordWebSocketFailure(sessionId, error) {
     stats.websocketFallbackActive = true;
 }
 let _cachedWebsocket = null;
-async function getWebSocketConstructor() {
-    if (_cachedWebsocket)
+async function getWebSocketConstructor(env) {
+    if (!env && _cachedWebsocket)
         return _cachedWebsocket;
     // bun doesn't respect http proxy envs, ref: https://github.com/oven-sh/bun/issues/15489
     // TODO: remove this when bun supports proxy envs in websocket.
-    if (process?.versions?.bun &&
-        (process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy)) {
-        const m = await dynamicImport("proxy-from-env");
-        const getProxyForUrl = m.getProxyForUrl;
-        _cachedWebsocket = class {
+    if (typeof process !== "undefined" && process.versions?.bun) {
+        const WebSocketWithProxy = class {
             constructor(url, options) {
                 let _opts = {};
                 if (Array.isArray(options) || typeof options === "string") {
@@ -622,10 +644,10 @@ async function getWebSocketConstructor() {
                 else {
                     _opts = { ...options };
                 }
-                const proxy = getProxyForUrl(url.toString().replace(/^wss:/, "https:").replace(/^ws:/, "http:"));
+                const proxyUrl = resolveHttpProxyUrlForTarget(url.toString().replace(/^wss:/, "https:").replace(/^ws:/, "http:"), env);
                 this.socket = Reflect.construct(WebSocket, [
                     url,
-                    { ..._opts, ...(proxy ? { proxy } : {}) },
+                    { ..._opts, ...(proxyUrl ? { proxy: proxyUrl.toString() } : {}) },
                 ]);
             }
             close(code, reason) {
@@ -641,7 +663,10 @@ async function getWebSocketConstructor() {
                 this.socket.removeEventListener(type, listener);
             }
         };
-        return _cachedWebsocket;
+        if (!env) {
+            _cachedWebsocket = WebSocketWithProxy;
+        }
+        return WebSocketWithProxy;
     }
     const ctor = globalThis.WebSocket;
     if (!isWebSocketConstructor(ctor))
@@ -686,8 +711,8 @@ function scheduleSessionWebSocketExpiry(sessionId, entry) {
         websocketSessionCache.delete(sessionId);
     }, SESSION_WEBSOCKET_CACHE_TTL_MS);
 }
-async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS) {
-    const WebSocketCtor = await getWebSocketConstructor();
+async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS, env) {
+    const WebSocketCtor = await getWebSocketConstructor(env);
     if (!WebSocketCtor) {
         throw new Error("WebSocket transport is not available in this runtime");
     }
@@ -754,9 +779,9 @@ async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT
         }
     });
 }
-async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutMs) {
+async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutMs, env) {
     if (!sessionId) {
-        const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs);
+        const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
         return {
             socket,
             reused: false,
@@ -787,7 +812,7 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
             };
         }
         if (cached.busy) {
-            const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs);
+            const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
             return {
                 socket,
                 reused: false,
@@ -801,7 +826,7 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
             websocketSessionCache.delete(sessionId);
         }
     }
-    const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs);
+    const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
     const entry = { socket, busy: true };
     websocketSessionCache.set(sessionId, entry);
     return {
@@ -1029,6 +1054,30 @@ function buildCachedWebSocketRequestBody(entry, body) {
         input: delta,
     };
 }
+function recordWebSocketRequestStats(stats, requestBody, reused, useCachedContext) {
+    if (!stats)
+        return;
+    stats.requests++;
+    if (reused)
+        stats.connectionsReused++;
+    else
+        stats.connectionsCreated++;
+    if (useCachedContext)
+        stats.cachedContextRequests++;
+    if (requestBody.store === true)
+        stats.storeTrueRequests++;
+    stats.lastInputItems = requestBody.input?.length ?? 0;
+    if (requestBody.previous_response_id) {
+        stats.deltaRequests++;
+        stats.lastDeltaInputItems = requestBody.input?.length ?? 0;
+        stats.lastPreviousResponseId = requestBody.previous_response_id;
+    }
+    else {
+        stats.fullContextRequests++;
+        stats.lastDeltaInputItems = undefined;
+        stats.lastPreviousResponseId = undefined;
+    }
+}
 async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart) {
     let started = false;
     for await (const event of events) {
@@ -1041,43 +1090,41 @@ async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart
     }
 }
 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);
+    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, options?.sessionId, 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").
     // WebSocket continuation still works via connection-scoped previous_response_id state.
     const fullBody = body;
-    const requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, fullBody) : fullBody;
+    let requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, fullBody) : fullBody;
     const stats = options?.sessionId ? getOrCreateWebSocketDebugStats(options.sessionId) : undefined;
-    if (stats) {
-        stats.requests++;
-        if (reused)
-            stats.connectionsReused++;
-        else
-            stats.connectionsCreated++;
-        if (useCachedContext)
-            stats.cachedContextRequests++;
-        if (requestBody.store === true)
-            stats.storeTrueRequests++;
-        stats.lastInputItems = requestBody.input?.length ?? 0;
-        if (requestBody.previous_response_id) {
-            stats.deltaRequests++;
-            stats.lastDeltaInputItems = requestBody.input?.length ?? 0;
-            stats.lastPreviousResponseId = requestBody.previous_response_id;
-        }
-        else {
-            stats.fullContextRequests++;
-            stats.lastDeltaInputItems = undefined;
-            stats.lastPreviousResponseId = undefined;
-        }
-    }
+    let recoveredStalePreviousResponse = false;
     try {
-        socket.send(JSON.stringify({ type: "response.create", ...requestBody }));
-        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),
-        });
+        while (true) {
+            recordWebSocketRequestStats(stats, requestBody, reused && !recoveredStalePreviousResponse, useCachedContext);
+            try {
+                socket.send(JSON.stringify({ type: "response.create", ...requestBody }));
+                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),
+                });
+                break;
+            }
+            catch (error) {
+                if (!recoveredStalePreviousResponse &&
+                    entry &&
+                    requestBody.previous_response_id &&
+                    isCodexPreviousResponseStale(error) &&
+                    !options?.signal?.aborted) {
+                    entry.continuation = undefined;
+                    requestBody = fullBody;
+                    recoveredStalePreviousResponse = true;
+                    continue;
+                }
+                throw error;
+            }
+        }
         if (options?.signal?.aborted) {
             keepConnection = false;
         }
@@ -1136,15 +1183,13 @@ function extractAccountId(token) {
     try {
         const parts = token.split(".");
         if (parts.length !== 3)
-            throw new Error("Invalid token");
+            return undefined;
         const payload = JSON.parse(atob(parts[1]));
         const accountId = payload?.[JWT_CLAIM_PATH]?.chatgpt_account_id;
-        if (!accountId)
-            throw new Error("No account ID in token");
-        return accountId;
+        return typeof accountId === "string" && accountId.length > 0 ? accountId : undefined;
     }
     catch {
-        throw new Error("Failed to extract accountId from token");
+        return undefined;
     }
 }
 function createCodexRequestId() {
@@ -1159,7 +1204,12 @@ function buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token)
         headers.set(key, value);
     }
     headers.set("Authorization", `Bearer ${token}`);
-    headers.set("chatgpt-account-id", accountId);
+    if (accountId) {
+        headers.set("chatgpt-account-id", accountId);
+    }
+    else {
+        headers.delete("chatgpt-account-id");
+    }
     headers.set("originator", "senpi");
     const userAgent = _os ? `senpi (${_os.platform()} ${_os.release()}; ${_os.arch()})` : "senpi (browser)";
     headers.set("User-Agent", userAgent);