@jecruz/merc-ai 0.1.4 → 0.2.0

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

@@ -1,21 +1,23 @@
-// NEVER convert to top-level runtime imports - breaks browser/Vite builds (web-ui)
-let _os = null;
 const dynamicImport = (specifier) => import(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;
-    });
+function loadNodeOs() {
+    if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) {
+        return null;
+    }
+    return process.getBuiltinModule?.("node:os") ?? null;
 }
+// NEVER convert to top-level runtime imports - breaks browser/Vite builds (web-ui)
+const _os = loadNodeOs();
+import { v7 as uuidv7 } from "uuid";
 import { getEnvApiKey } from "../env-api-keys.js";
 import { clampThinkingLevel } from "../models.js";
 import { registerSessionResourceCleanup } from "../session-resources.js";
 import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { appendAssistantMessageDiagnostic, createAssistantMessageDiagnostic, formatThrownValue, } from "../utils/diagnostics.js";
-import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
+import { formatProviderError, isDeterministicProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { resolveProviderProxyUrl } from "../utils/provider-env.js";
+import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
 // ============================================================================
@@ -23,11 +25,14 @@ import { buildBaseOptions } from "./simple-options.js";
 // ============================================================================
 const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 const JWT_CLAIM_PATH = "https://api.openai.com/auth";
-const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_MAX_RETRIES = 0;
 const BASE_DELAY_MS = 1000;
+const DEFAULT_MAX_RETRY_DELAY_MS = 60_000;
 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 WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE = "websocket_connection_limit_reached";
 const CODEX_RESPONSE_STATUSES = new Set([
     "completed",
     "incomplete",
@@ -36,6 +41,7 @@ const CODEX_RESPONSE_STATUSES = new Set([
     "queued",
     "in_progress",
 ]);
+// Codex requests never carry max_output_tokens, so supportsMaxOutputTokens does not apply here.
 function getCompat(model) {
     return {
         supportsDeveloperRole: model.compat?.supportsDeveloperRole ?? true,
@@ -47,17 +53,32 @@ function getCompat(model) {
 function defaultSupportsToolSearch(model) {
     if (model.provider !== "openai" && model.provider !== "openai-codex")
         return false;
-    return /gpt-5\.(4|5|6)/.test(model.id);
+    return /(?:^|\/)gpt-(?:5\.[456]|6)(?:[.-]|$)/.test(model.id);
 }
 // ============================================================================
 // Retry Helpers
 // ============================================================================
+function isTerminalRateLimitError(errorText) {
+    return /GoUsageLimitError|FreeUsageLimitError|Monthly usage limit reached|available balance|insufficient_quota|out of budget|quota exceeded|billing/i.test(errorText);
+}
 function isRetryableError(status, errorText) {
+    if (status === 429 && isTerminalRateLimitError(errorText)) {
+        return false;
+    }
     if (status === 429 || status === 500 || status === 502 || status === 503 || status === 504) {
         return true;
     }
     return /rate.?limit|overloaded|service.?unavailable|upstream.?connect|connection.?refused/i.test(errorText);
 }
+class RetryDelayExceededError extends Error {
+}
+function validateRetryDelayMs(delayMs, options) {
+    const maxRetryDelayMs = options?.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
+    if (maxRetryDelayMs > 0 && delayMs > maxRetryDelayMs) {
+        throw new RetryDelayExceededError(`Server requested ${Math.ceil(delayMs / 1000)}s retry delay (max: ${Math.ceil(maxRetryDelayMs / 1000)}s)`);
+    }
+    return delayMs;
+}
 function sleep(ms, signal) {
     return new Promise((resolve, reject) => {
         if (signal?.aborted) {
@@ -93,6 +114,14 @@ function parseRetryAfterDelay(response) {
     }
     return undefined;
 }
+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);
+}
 // ============================================================================
 // Main Stream Function
 // ============================================================================
@@ -122,58 +151,82 @@ export const streamOpenAICodexResponses = (model, context, options) => {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
             const accountId = extractAccountId(apiKey);
-            let body = buildRequestBody(model, context, options);
+            const cacheSessionId = options?.cacheRetention === "none" ? undefined : options?.sessionId;
+            let body = buildRequestBody(model, context, options, cacheSessionId);
             const nextBody = await options?.onPayload?.(body, model);
             if (nextBody !== undefined) {
                 body = nextBody;
             }
-            const websocketRequestId = options?.sessionId || createCodexRequestId();
-            const sseHeaders = buildSSEHeaders(model.headers, options?.headers, accountId, apiKey, options?.sessionId);
+            const websocketRequestId = cacheSessionId || uuidv7();
+            const sseHeaders = buildSSEHeaders(model.headers, options?.headers, accountId, apiKey, cacheSessionId);
             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);
+            const websocketDisabledForSession = transport !== "sse" && isWebSocketSseFallbackActive(cacheSessionId);
             if (websocketDisabledForSession) {
-                recordWebSocketSseFallback(options?.sessionId);
+                recordWebSocketSseFallback(cacheSessionId);
             }
             if (transport !== "sse") {
                 let websocketReceivedEvent = false;
-                try {
-                    await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), body, websocketHeaders, output, stream, model, () => { }, () => {
-                        websocketReceivedEvent = true;
-                    }, options);
-                    if (options?.signal?.aborted) {
-                        throw new Error("Request was aborted");
-                    }
-                    stream.push({
-                        type: "done",
-                        reason: output.stopReason,
-                        message: output,
-                    });
-                    stream.end();
-                    return;
-                }
-                catch (error) {
-                    // In auto mode, ChatGPT's Codex WebSocket can occasionally close
-                    // abnormally (1006) after `response.create` is sent but before any
-                    // response event arrives. That is still safe to retry over SSE using
-                    // the original full request body. Once any response event has arrived,
-                    // do not retry: replaying could duplicate partial assistant/tool output.
-                    if (transport === "websocket" || transport === "websocket-cached" || websocketReceivedEvent) {
-                        throw error;
+                let retriedWebSocketConnectionLimit = false;
+                let websocketStartPushed = false;
+                while (true) {
+                    websocketReceivedEvent = false;
+                    try {
+                        await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), body, websocketHeaders, output, stream, model, () => {
+                            if (websocketStartPushed)
+                                return;
+                            websocketStartPushed = true;
+                            stream.push({ type: "start", partial: output });
+                        }, () => {
+                            websocketReceivedEvent = true;
+                        }, cacheSessionId, idleTimeoutMs, websocketConnectTimeoutMs, options);
+                        if (options?.signal?.aborted) {
+                            throw new Error("Request was aborted");
+                        }
+                        stream.push({
+                            type: "done",
+                            reason: output.stopReason,
+                            message: output,
+                        });
+                        stream.end();
+                        return;
                     }
-                    appendAssistantMessageDiagnostic(output, createAssistantMessageDiagnostic("provider_transport_failure", error, {
-                        configuredTransport: transport,
-                        fallbackTransport: websocketReceivedEvent ? undefined : "sse",
-                        eventsEmitted: websocketReceivedEvent,
-                        phase: websocketReceivedEvent ? "after_message_stream_start" : "before_message_stream_start",
-                        requestBytes: new TextEncoder().encode(bodyJson).byteLength,
-                    }));
-                    recordWebSocketFailure(options?.sessionId, error);
-                    if (websocketReceivedEvent) {
-                        throw error;
+                    catch (error) {
+                        // ChatGPT rejects a new WebSocket with websocket_connection_limit_reached when the
+                        // account already holds its maximum number of connections. Nothing was streamed yet,
+                        // so reconnect once instead of surfacing the error or dropping to SSE.
+                        if (!options?.signal?.aborted &&
+                            !websocketReceivedEvent &&
+                            !retriedWebSocketConnectionLimit &&
+                            isWebSocketConnectionLimitReachedError(error)) {
+                            retriedWebSocketConnectionLimit = true;
+                            continue;
+                        }
+                        // In auto mode, ChatGPT's Codex WebSocket can occasionally close
+                        // abnormally (1006) after `response.create` is sent but before any
+                        // response event arrives. That is still safe to retry over SSE using
+                        // the original full request body. Once any response event has arrived,
+                        // do not retry: replaying could duplicate partial assistant/tool output.
+                        if (transport === "websocket" || transport === "websocket-cached" || websocketReceivedEvent) {
+                            throw error;
+                        }
+                        appendAssistantMessageDiagnostic(output, createAssistantMessageDiagnostic("provider_transport_failure", error, {
+                            configuredTransport: transport,
+                            fallbackTransport: websocketReceivedEvent ? undefined : "sse",
+                            eventsEmitted: websocketReceivedEvent,
+                            phase: websocketReceivedEvent ? "after_message_stream_start" : "before_message_stream_start",
+                            requestBytes: new TextEncoder().encode(bodyJson).byteLength,
+                        }));
+                        recordWebSocketFailure(cacheSessionId, error);
+                        if (websocketReceivedEvent) {
+                            throw error;
+                        }
+                        recordWebSocketSseFallback(cacheSessionId);
+                        break;
                     }
-                    recordWebSocketSseFallback(options?.sessionId);
                 }
             }
             // Fetch with retry logic for rate limits and transient errors
@@ -186,10 +239,11 @@ export const streamOpenAICodexResponses = (model, context, options) => {
                 }
                 const headerTimeoutController = new AbortController();
                 let timedOut = false;
+                const headerTimeoutMs = options?.timeoutMs ?? DEFAULT_SSE_HEADER_TIMEOUT_MS;
                 const headerTimeout = setTimeout(() => {
                     timedOut = true;
                     headerTimeoutController.abort();
-                }, DEFAULT_SSE_HEADER_TIMEOUT_MS);
+                }, headerTimeoutMs);
                 const onAbort = () => {
                     headerTimeoutController.abort();
                 };
@@ -206,22 +260,25 @@ export const streamOpenAICodexResponses = (model, context, options) => {
                         break;
                     }
                     const errorText = await response.text();
-                    if (attempt < maxRetries && isRetryableError(response.status, errorText)) {
-                        const delayMs = parseRetryAfterDelay(response) ?? BASE_DELAY_MS * 2 ** attempt;
+                    const info = await parseErrorResponse(new Response(errorText, {
+                        status: response.status,
+                        statusText: response.statusText,
+                    }));
+                    if (attempt < maxRetries &&
+                        !isDeterministicProviderError(info.errorMetadata) &&
+                        isRetryableError(response.status, errorText)) {
+                        const retryAfterDelayMs = parseRetryAfterDelay(response);
+                        const delayMs = retryAfterDelayMs === undefined
+                            ? BASE_DELAY_MS * 2 ** attempt
+                            : validateRetryDelayMs(retryAfterDelayMs, options);
                         await sleep(delayMs, options?.signal);
                         continue;
                     }
-                    // Parse error for friendly message on final attempt or non-retryable error
-                    const fakeResponse = new Response(errorText, {
-                        status: response.status,
-                        statusText: response.statusText,
-                    });
-                    const info = await parseErrorResponse(fakeResponse);
-                    throw new Error(info.friendlyMessage || info.message);
+                    throw new CodexApiError(info.friendlyMessage || info.message, info.errorMetadata);
                 }
                 catch (error) {
                     if (timedOut && !options?.signal?.aborted) {
-                        throw new Error(`Codex SSE response headers timed out after ${DEFAULT_SSE_HEADER_TIMEOUT_MS}ms`);
+                        throw new Error(`Codex SSE response headers timed out after ${headerTimeoutMs}ms`);
                     }
                     if (error instanceof Error) {
                         if (error.name === "AbortError" || error.message === "Request was aborted") {
@@ -230,7 +287,10 @@ export const streamOpenAICodexResponses = (model, context, options) => {
                     }
                     lastError = error instanceof Error ? error : new Error(String(error));
                     // Network errors are retryable
-                    if (attempt < maxRetries && !lastError.message.includes("usage limit")) {
+                    if (attempt < maxRetries &&
+                        !(lastError instanceof RetryDelayExceededError) &&
+                        !isDeterministicProviderError(normalizeProviderError(lastError).errorMetadata) &&
+                        !lastError.message.includes("usage limit")) {
                         const delayMs = BASE_DELAY_MS * 2 ** attempt;
                         await sleep(delayMs, options?.signal);
                         continue;
@@ -262,7 +322,9 @@ export const streamOpenAICodexResponses = (model, context, options) => {
                 delete block.partialJson;
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = formatProviderError(normalizeProviderError(error));
+            const normalized = normalizeProviderError(error);
+            output.errorMetadata = normalized.errorMetadata;
+            output.errorMessage = formatProviderError(normalized);
             stream.push({ type: "error", reason: output.stopReason, error: output });
             stream.end();
         }
@@ -274,7 +336,7 @@ export const streamSimpleOpenAICodexResponses = (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 streamOpenAICodexResponses(model, context, {
@@ -285,7 +347,7 @@ export const streamSimpleOpenAICodexResponses = (model, context, options) => {
 // ============================================================================
 // Request Building
 // ============================================================================
-function buildRequestBody(model, context, options) {
+function buildRequestBody(model, context, options, cacheSessionId) {
     const compat = getCompat(model);
     const toolPlacement = splitDeferredTools(context, compat.supportsToolSearch);
     const messages = convertResponsesMessages(model, context, CODEX_TOOL_CALL_PROVIDERS, {
@@ -300,7 +362,7 @@ function buildRequestBody(model, context, options) {
         input: messages,
         text: { verbosity: options?.textVerbosity || "low" },
         include: ["reasoning.encrypted_content"],
-        prompt_cache_key: options?.sessionId,
+        prompt_cache_key: clampOpenAIPromptCacheKey(cacheSessionId),
         tool_choice: options?.toolChoice ?? "auto",
         parallel_tool_calls: true,
     };
@@ -315,7 +377,9 @@ function buildRequestBody(model, context, options) {
     }
     if (options?.reasoningEffort !== undefined) {
         const effort = options.reasoningEffort === "none"
-            ? (model.thinkingLevelMap?.off ?? "none")
+            ? model.thinkingLevelMap?.off === undefined
+                ? "none"
+                : model.thinkingLevelMap.off
             : (model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort);
         if (effort !== null) {
             body.reasoning = {
@@ -324,6 +388,9 @@ function buildRequestBody(model, context, options) {
             };
         }
     }
+    else if (model.reasoning && model.thinkingLevelMap?.off !== null) {
+        body.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+    }
     return body;
 }
 function getServiceTierCostMultiplier(model, serviceTier) {
@@ -381,11 +448,13 @@ async function processStream(response, output, stream, model, options) {
 }
 class CodexApiError extends Error {
     code;
+    type;
     payload;
     constructor(message, options) {
         super(message);
         this.name = "CodexApiError";
         this.code = options?.code;
+        this.type = options?.type;
         this.payload = options?.payload;
         this.cause = options?.cause;
     }
@@ -402,24 +471,43 @@ class CodexProtocolError extends Error {
 function _isCodexNonTransportError(error) {
     return error instanceof CodexApiError || error instanceof CodexProtocolError;
 }
+function isWebSocketConnectionLimitReachedError(error) {
+    return error instanceof CodexApiError && error.code === WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE;
+}
+function isWebSocketConnectionLimitReachedEvent(event) {
+    return event.type === "error" && extractCodexEventError(event).code === WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE;
+}
+function extractCodexEventError(event) {
+    const nested = event.error && typeof event.error === "object" ? event.error : undefined;
+    return {
+        ...normalizeProviderError({ code: event.code, error: nested }).errorMetadata,
+        message: typeof event.message === "string"
+            ? event.message
+            : typeof nested?.message === "string"
+                ? nested.message
+                : undefined,
+    };
+}
 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, type: errorType, message } = extractCodexEventError(event);
             throw new CodexApiError(`Codex error: ${message || code || JSON.stringify(event)}`, {
-                code: code || undefined,
+                code,
+                type: errorType,
                 payload: event,
             });
         }
         if (type === "response.failed") {
             const response = event.response;
-            const code = response?.error?.code;
             const message = response?.error?.message;
-            throw new CodexApiError(message || "Codex response failed", { code, payload: event });
+            throw new CodexApiError(message || "Codex response failed", {
+                ...normalizeProviderError(response?.error).errorMetadata,
+                payload: event,
+            });
         }
         if (type === "response.done" || type === "response.completed" || type === "response.incomplete") {
             const response = event.response;
@@ -459,9 +547,10 @@ async function* parseSSE(response, signal) {
             if (signal?.aborted) {
                 throw new Error("Request was aborted");
             }
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
+            buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
+            // Treat EOF as terminating the residual SSE frame.
+            if (done && buffer.trim())
+                buffer += "\n\n";
             let idx = buffer.indexOf("\n\n");
             while (idx !== -1) {
                 const chunk = buffer.slice(0, idx);
@@ -486,6 +575,8 @@ async function* parseSSE(response, signal) {
                 }
                 idx = buffer.indexOf("\n\n");
             }
+            if (done)
+                break;
         }
     }
     finally {
@@ -682,7 +773,7 @@ function scheduleSessionWebSocketExpiry(sessionId, entry) {
         websocketSessionCache.delete(sessionId);
     }, SESSION_WEBSOCKET_CACHE_TTL_MS);
 }
-async function connectWebSocket(url, headers, signal, env) {
+async function connectWebSocket(url, headers, signal, env, connectTimeoutMs = DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS) {
     const WebSocketCtor = await getWebSocketConstructor(env);
     if (!WebSocketCtor) {
         throw new Error("WebSocket transport is not available in this runtime");
@@ -691,6 +782,7 @@ async function connectWebSocket(url, headers, signal, env) {
     delete wsHeaders["OpenAI-Beta"];
     return new Promise((resolve, reject) => {
         let settled = false;
+        let timeout;
         let socket;
         try {
             socket = new WebSocketCtor(url, { headers: wsHeaders });
@@ -699,52 +791,59 @@ async function connectWebSocket(url, headers, signal, env) {
             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, env) {
+async function acquireWebSocket(url, headers, sessionId, signal, env, connectTimeoutMs) {
     if (!sessionId) {
-        const socket = await connectWebSocket(url, headers, signal, env);
+        const socket = await connectWebSocket(url, headers, signal, env, connectTimeoutMs);
         return {
             socket,
             reused: false,
@@ -758,7 +857,20 @@ async function acquireWebSocket(url, headers, sessionId, signal, env) {
         };
     }
     const proxyKey = getScopedProxyKey(env);
+    const accountId = headers.get("chatgpt-account-id") ?? undefined;
     const cached = websocketSessionCache.get(sessionId);
+    if (cached && cached.accountId !== accountId) {
+        // A cached socket is authenticated for one account; never reuse it for another
+        // account sharing the session id. Leave the cached entry untouched.
+        const socket = await connectWebSocket(url, headers, signal, env, connectTimeoutMs);
+        return {
+            socket,
+            reused: false,
+            release: () => {
+                closeWebSocketSilently(socket);
+            },
+        };
+    }
     if (cached) {
         if (cached.proxyKey !== proxyKey) {
             closeWebSocketSilently(cached.socket, 1000, "proxy_config_changed");
@@ -793,7 +905,7 @@ async function acquireWebSocket(url, headers, sessionId, signal, env) {
                 };
             }
             if (cached.busy) {
-                const socket = await connectWebSocket(url, headers, signal, env);
+                const socket = await connectWebSocket(url, headers, signal, env, connectTimeoutMs);
                 return {
                     socket,
                     reused: false,
@@ -808,8 +920,8 @@ async function acquireWebSocket(url, headers, sessionId, signal, env) {
             }
         }
     }
-    const socket = await connectWebSocket(url, headers, signal, env);
-    const entry = { socket, busy: true, createdAt: Date.now(), proxyKey };
+    const socket = await connectWebSocket(url, headers, signal, env, connectTimeoutMs);
+    const entry = { socket, busy: true, createdAt: Date.now(), proxyKey, accountId };
     websocketSessionCache.set(sessionId, entry);
     return {
         socket,
@@ -884,7 +996,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;
@@ -962,8 +1074,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) {
@@ -1032,15 +1159,15 @@ async function* _startWebSocketOutputOnFirstEvent(events, output, stream, onStar
         yield event;
     }
 }
-async function processWebSocketStream(url, body, headers, output, stream, model, onStart, onResponseEvent, options) {
-    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal, options?.env);
+async function processWebSocketStream(url, body, headers, output, stream, model, onStart, onResponseEvent, cacheSessionId, idleTimeoutMs, websocketConnectTimeoutMs, options) {
+    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, cacheSessionId, options?.signal, options?.env, 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").
     // WebSocket continuation still works via connection-scoped previous_response_id state.
     const fullBody = body;
     const requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, fullBody) : fullBody;
-    const stats = options?.sessionId ? getOrCreateWebSocketDebugStats(options.sessionId) : undefined;
+    const stats = cacheSessionId ? getOrCreateWebSocketDebugStats(cacheSessionId) : undefined;
     if (stats) {
         stats.requests++;
         if (reused)
@@ -1066,10 +1193,11 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
     try {
         socket.send(JSON.stringify({ type: "response.create", ...requestBody }));
         onStart();
-        stream.push({ type: "start", partial: output });
         async function* observedWebSocketEvents() {
-            for await (const event of parseWebSocket(socket, options?.signal)) {
-                onResponseEvent();
+            for await (const event of parseWebSocket(socket, options?.signal, idleTimeoutMs)) {
+                // A connection-limit rejection carries no response data, so the request can be retried.
+                if (!isWebSocketConnectionLimitReachedEvent(event))
+                    onResponseEvent();
                 yield event;
             }
         }
@@ -1110,9 +1238,11 @@ async function parseErrorResponse(response) {
     const raw = await response.text();
     let message = raw || response.statusText || "Request failed";
     let friendlyMessage;
+    let errorMetadata;
     try {
         const parsed = JSON.parse(raw);
         const err = parsed?.error;
+        errorMetadata = normalizeProviderError(parsed).errorMetadata;
         if (err) {
             const code = err.code || err.type || "";
             if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code) || response.status === 429) {
@@ -1127,7 +1257,7 @@ async function parseErrorResponse(response) {
         }
     }
     catch { }
-    return { message, friendlyMessage };
+    return { message, friendlyMessage, errorMetadata };
 }
 // ============================================================================
 // Auth & Headers
@@ -1147,22 +1277,18 @@ function extractAccountId(token) {
         throw new Error("Failed to extract accountId from token");
     }
 }
-function createCodexRequestId() {
-    if (typeof globalThis.crypto?.randomUUID === "function") {
-        return globalThis.crypto.randomUUID();
-    }
-    return `codex_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-}
 function buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token) {
-    const headers = new Headers(initHeaders);
+    const userAgent = _os ? `pi (${_os.platform()} ${_os.release()}; ${_os.arch()})` : "pi (browser)";
+    // Defaults first so model and caller headers can override them, matching the other providers.
+    const headers = new Headers({ originator: "pi", "User-Agent": userAgent });
+    for (const [key, value] of Object.entries(initHeaders || {})) {
+        headers.set(key, value);
+    }
     for (const [key, value] of Object.entries(additionalHeaders || {})) {
         headers.set(key, value);
     }
     headers.set("Authorization", `Bearer ${token}`);
     headers.set("chatgpt-account-id", accountId);
-    headers.set("originator", "pi");
-    const userAgent = _os ? `pi (${_os.platform()} ${_os.release()}; ${_os.arch()})` : "pi (browser)";
-    headers.set("User-Agent", userAgent);
     return headers;
 }
 function buildSSEHeaders(initHeaders, additionalHeaders, accountId, token, sessionId) {
@@ -1171,7 +1297,7 @@ function buildSSEHeaders(initHeaders, additionalHeaders, accountId, token, sessi
     headers.set("accept", "text/event-stream");
     headers.set("content-type", "application/json");
     if (sessionId) {
-        headers.set("session_id", sessionId);
+        headers.set("session-id", sessionId);
         headers.set("x-client-request-id", sessionId);
     }
     return headers;
@@ -1184,7 +1310,7 @@ function buildWebSocketHeaders(initHeaders, additionalHeaders, accountId, token,
     headers.delete("openai-beta");
     headers.set("OpenAI-Beta", OPENAI_BETA_RESPONSES_WEBSOCKETS);
     headers.set("x-client-request-id", requestId);
-    headers.set("session_id", requestId);
+    headers.set("session-id", requestId);
     return headers;
 }
 //# sourceMappingURL=openai-codex-responses.js.map