@fleetagent/pi-ai 0.1.8 → 0.2.0

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

@@ -22,7 +22,7 @@ import { appendAssistantMessageDiagnostic, createAssistantMessageDiagnostic, for
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
-import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
+import { convertResponsesMessages, convertResponsesTools, processResponsesStream, } from "./openai-responses-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
 // ============================================================================
 // Configuration
@@ -36,6 +36,7 @@ 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 PREVIOUS_RESPONSE_NOT_FOUND_CODE = "previous_response_not_found";
 const CODEX_RESPONSE_STATUSES = new Set([
     "completed",
     "incomplete",
@@ -44,6 +45,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
 // ============================================================================
@@ -81,9 +90,14 @@ function getRetryAfterDelayMs(headers) {
     }
     return undefined;
 }
-function capRetryDelayMs(delayMs, options) {
+class RetryDelayExceededError extends Error {
+}
+function validateRetryDelayMs(delayMs, options) {
     const maxRetryDelayMs = options?.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
-    return maxRetryDelayMs > 0 ? Math.min(delayMs, maxRetryDelayMs) : delayMs;
+    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) => {
@@ -124,176 +138,224 @@ function createSSEHeaderTimeout() {
         error: () => error,
     };
 }
+function createCodexAssistantMessage(model) {
+    return {
+        role: "assistant",
+        content: [],
+        api: "openai-codex-responses",
+        provider: model.provider,
+        model: model.id,
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+        stopReason: "pending",
+        timestamp: Date.now(),
+    };
+}
+async function prepareCodexRequest(model, context, options) {
+    const apiKey = options?.apiKey;
+    if (!apiKey)
+        throw new Error(`No API key for provider: ${model.provider}`);
+    const accountId = extractAccountId(apiKey);
+    let body = buildRequestBody(model, context, options);
+    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 websocketHeaders = buildWebSocketHeaders(model.headers, options?.headers, accountId, apiKey, websocketRequestId);
+    const transport = options?.transport || "auto";
+    const websocketDisabledForSession = transport !== "sse" && isWebSocketSseFallbackActive(options?.sessionId);
+    if (websocketDisabledForSession)
+        recordWebSocketSseFallback(options?.sessionId);
+    return {
+        body,
+        bodyJson: JSON.stringify(body),
+        sseHeaders,
+        websocketHeaders,
+        idleTimeoutMs: normalizeTimeoutMs(options?.timeoutMs),
+        websocketConnectTimeoutMs: normalizeTimeoutMs(options?.websocketConnectTimeoutMs),
+        transport,
+        websocketDisabledForSession,
+    };
+}
+function throwIfCodexRequestAborted(signal) {
+    if (signal?.aborted)
+        throw new Error("Request was aborted");
+}
+function completeCodexStream(output, stream) {
+    stream.push({ type: "done", reason: output.stopReason, message: output });
+    stream.end();
+}
+function failCodexStream(output, stream, options, error) {
+    for (const block of output.content) {
+        // partialJson is only a streaming scratch buffer; never persist it.
+        delete block.partialJson;
+    }
+    output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+    output.errorMessage = error instanceof Error ? error.message : String(error);
+    stream.push({ type: "error", reason: output.stopReason, error: output });
+    stream.end();
+}
+function handleCodexWebSocketFailure(execution, error, streamStarted, retriedMissingContinuation) {
+    const { options, output, request } = execution;
+    const aborted = options?.signal?.aborted;
+    if (!aborted && !streamStarted && isPreviousResponseNotFoundError(error) && !retriedMissingContinuation) {
+        return "retry";
+    }
+    if (aborted || isCodexNonTransportError(error))
+        throw error;
+    appendAssistantMessageDiagnostic(output, createAssistantMessageDiagnostic("provider_transport_failure", error, {
+        configuredTransport: request.transport,
+        fallbackTransport: streamStarted ? undefined : "sse",
+        eventsEmitted: streamStarted,
+        phase: streamStarted ? "after_message_stream_start" : "before_message_stream_start",
+        requestBytes: new TextEncoder().encode(request.bodyJson).byteLength,
+    }));
+    recordWebSocketFailure(options?.sessionId, error);
+    if (streamStarted)
+        throw error;
+    recordWebSocketSseFallback(options?.sessionId);
+    return "fallback";
+}
+async function tryCodexWebSocketTransport(execution) {
+    const { model, options, output, stream, request } = execution;
+    if (request.transport === "sse" || request.websocketDisabledForSession)
+        return false;
+    let retriedMissingContinuation = false;
+    while (true) {
+        let streamStarted = false;
+        try {
+            await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), request.body, request.websocketHeaders, output, stream, model, () => {
+                streamStarted = true;
+            }, request.idleTimeoutMs, request.websocketConnectTimeoutMs, options);
+            throwIfCodexRequestAborted(options?.signal);
+            assertSuccessfulOutput(output);
+            completeCodexStream(output, stream);
+            return true;
+        }
+        catch (error) {
+            const action = handleCodexWebSocketFailure(execution, error, streamStarted, retriedMissingContinuation);
+            if (action === "retry") {
+                retriedMissingContinuation = true;
+                continue;
+            }
+            return false;
+        }
+    }
+}
+async function fetchCodexSseAttempt(execution) {
+    const { model, options, request } = execution;
+    const headerTimeout = createSSEHeaderTimeout();
+    const combinedSignal = combineAbortSignals([options?.signal, headerTimeout.signal]);
+    let response;
+    try {
+        try {
+            response = await fetch(resolveCodexUrl(model.baseUrl), {
+                method: "POST",
+                headers: request.sseHeaders,
+                body: request.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);
+    return response;
+}
+function normalizeCodexSseError(error) {
+    if (error instanceof Error && (error.name === "AbortError" || error.message === "Request was aborted")) {
+        return new Error("Request was aborted");
+    }
+    return error instanceof Error ? error : new Error(String(error));
+}
+async function handleCodexHttpFailure(response, attempt, maxRetries, options) {
+    const errorText = await response.text();
+    if (attempt < maxRetries && isRetryableError(response.status, errorText)) {
+        const retryAfterDelayMs = getRetryAfterDelayMs(response.headers);
+        const delayMs = retryAfterDelayMs === undefined
+            ? BASE_DELAY_MS * 2 ** attempt
+            : validateRetryDelayMs(retryAfterDelayMs, options);
+        await sleep(delayMs, options?.signal);
+        return;
+    }
+    const fakeResponse = new Response(errorText, {
+        status: response.status,
+        statusText: response.statusText,
+    });
+    const info = await parseErrorResponse(fakeResponse);
+    throw new Error(info.friendlyMessage || info.message);
+}
+async function handleCodexSseAttemptError(error, attempt, maxRetries, options) {
+    const requestError = normalizeCodexSseError(error);
+    if (requestError.message === "Request was aborted")
+        throw requestError;
+    if (attempt < maxRetries &&
+        !(requestError instanceof RetryDelayExceededError) &&
+        !requestError.message.includes("usage limit")) {
+        await sleep(BASE_DELAY_MS * 2 ** attempt, options?.signal);
+        return;
+    }
+    throw requestError;
+}
+async function fetchCodexSseResponse(execution) {
+    const { options } = execution;
+    const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        throwIfCodexRequestAborted(options?.signal);
+        try {
+            const response = await fetchCodexSseAttempt(execution);
+            if (response.ok)
+                return response;
+            await handleCodexHttpFailure(response, attempt, maxRetries, options);
+        }
+        catch (error) {
+            await handleCodexSseAttemptError(error, attempt, maxRetries, options);
+        }
+    }
+    throw new Error("Failed after retries");
+}
+async function processCodexSseTransport(execution, response) {
+    const { model, options, output, stream } = execution;
+    if (!response.body)
+        throw new Error("No response body");
+    stream.push({ type: "start", partial: output });
+    await processStream(response, output, stream, model, options);
+    throwIfCodexRequestAborted(options?.signal);
+    assertSuccessfulOutput(output);
+    completeCodexStream(output, stream);
+}
+async function runCodexStream(execution) {
+    if (await tryCodexWebSocketTransport(execution))
+        return;
+    const response = await fetchCodexSseResponse(execution);
+    await processCodexSseTransport(execution, response);
+}
 // ============================================================================
 // Main Stream Function
 // ============================================================================
 export const streamOpenAICodexResponses = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
+    const output = createCodexAssistantMessage(model);
     (async () => {
-        const output = {
-            role: "assistant",
-            content: [],
-            api: "openai-codex-responses",
-            provider: model.provider,
-            model: model.id,
-            usage: {
-                input: 0,
-                output: 0,
-                cacheRead: 0,
-                cacheWrite: 0,
-                totalTokens: 0,
-                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-            },
-            stopReason: "stop",
-            timestamp: Date.now(),
-        };
         try {
-            const apiKey = options?.apiKey;
-            if (!apiKey) {
-                throw new Error(`No API key for provider: ${model.provider}`);
-            }
-            const accountId = extractAccountId(apiKey);
-            let body = buildRequestBody(model, context, options);
-            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 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) {
-                recordWebSocketSseFallback(options?.sessionId);
-            }
-            if (transport !== "sse" && !websocketDisabledForSession) {
-                let websocketStarted = false;
-                try {
-                    await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), body, websocketHeaders, output, stream, model, () => {
-                        websocketStarted = true;
-                    }, 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;
-                }
-                catch (error) {
-                    const aborted = options?.signal?.aborted;
-                    if (aborted || isCodexNonTransportError(error)) {
-                        throw error;
-                    }
-                    appendAssistantMessageDiagnostic(output, createAssistantMessageDiagnostic("provider_transport_failure", error, {
-                        configuredTransport: transport,
-                        fallbackTransport: websocketStarted ? undefined : "sse",
-                        eventsEmitted: websocketStarted,
-                        phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
-                        requestBytes: new TextEncoder().encode(bodyJson).byteLength,
-                    }));
-                    recordWebSocketFailure(options?.sessionId, error);
-                    if (websocketStarted) {
-                        throw error;
-                    }
-                    recordWebSocketSseFallback(options?.sessionId);
-                }
-            }
-            // Fetch with retry logic for rate limits and transient errors
-            let response;
-            let lastError;
-            const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
-            for (let attempt = 0; attempt <= maxRetries; attempt++) {
-                if (options?.signal?.aborted) {
-                    throw new Error("Request was aborted");
-                }
-                try {
-                    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;
-                    }
-                    const errorText = await response.text();
-                    if (attempt < maxRetries && isRetryableError(response.status, errorText)) {
-                        const retryAfterDelayMs = getRetryAfterDelayMs(response.headers);
-                        const delayMs = retryAfterDelayMs === undefined
-                            ? BASE_DELAY_MS * 2 ** attempt
-                            : response.status === 429
-                                ? capRetryDelayMs(retryAfterDelayMs, options)
-                                : retryAfterDelayMs;
-                        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);
-                }
-                catch (error) {
-                    if (error instanceof Error) {
-                        if (error.name === "AbortError" || error.message === "Request was aborted") {
-                            throw new Error("Request was aborted");
-                        }
-                    }
-                    lastError = error instanceof Error ? error : new Error(String(error));
-                    // Network errors are retryable
-                    if (attempt < maxRetries && !lastError.message.includes("usage limit")) {
-                        const delayMs = BASE_DELAY_MS * 2 ** attempt;
-                        await sleep(delayMs, options?.signal);
-                        continue;
-                    }
-                    throw lastError;
-                }
-            }
-            if (!response?.ok) {
-                throw lastError ?? new Error("Failed after retries");
-            }
-            if (!response.body) {
-                throw new Error("No response body");
-            }
-            stream.push({ type: "start", partial: output });
-            await processStream(response, output, stream, model, options);
-            if (options?.signal?.aborted) {
-                throw new Error("Request was aborted");
-            }
-            stream.push({ type: "done", reason: output.stopReason, message: output });
-            stream.end();
+            const request = await prepareCodexRequest(model, context, options);
+            await runCodexStream({ model, options, output, stream, request });
         }
         catch (error) {
-            for (const block of output.content) {
-                // partialJson is only a streaming scratch buffer; never persist it.
-                delete block.partialJson;
-            }
-            output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : String(error);
-            stream.push({ type: "error", reason: output.stopReason, error: output });
-            stream.end();
+            failCodexStream(output, stream, options, error);
         }
     })();
     return stream;
@@ -428,25 +490,41 @@ class CodexProtocolError extends Error {
 function isCodexNonTransportError(error) {
     return error instanceof CodexApiError || error instanceof CodexProtocolError;
 }
+function isPreviousResponseNotFoundError(error) {
+    return error instanceof CodexApiError && error.code === PREVIOUS_RESPONSE_NOT_FOUND_CODE;
+}
+function extractCodexEventError(event) {
+    const nested = event.error && typeof event.error === "object" ? event.error : undefined;
+    return {
+        code: typeof event.code === "string" ? event.code : typeof nested?.code === "string" ? nested.code : undefined,
+        message: typeof event.message === "string"
+            ? event.message
+            : typeof nested?.message === "string"
+                ? nested.message
+                : undefined,
+    };
+}
+function throwIfCodexEventFailed(type, event) {
+    if (type === "error") {
+        const { code, message } = extractCodexEventError(event);
+        throw new CodexApiError(`Codex error: ${message || code || JSON.stringify(event)}`, {
+            code,
+            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 });
+    }
+}
 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 || "";
-            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;
-            throw new CodexApiError(message || "Codex response failed", { code, payload: event });
-        }
+        throwIfCodexEventFailed(type, event);
         if (type === "response.done" || type === "response.completed" || type === "response.incomplete") {
             const response = event.response;
             const normalizedResponse = response
@@ -466,6 +544,39 @@ function normalizeCodexStatus(status) {
 // ============================================================================
 // SSE Parsing
 // ============================================================================
+function parseCodexSseFrame(frame) {
+    const dataLines = frame
+        .split(/\r\n|\r|\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trim());
+    if (dataLines.length === 0)
+        return undefined;
+    const data = dataLines.join("\n").trim();
+    if (!data || data === "[DONE]")
+        return undefined;
+    try {
+        return JSON.parse(data);
+    }
+    catch (cause) {
+        throw new CodexProtocolError(`Invalid Codex SSE JSON: ${formatThrownValue(cause)}`, {
+            cause,
+            payload: data,
+        });
+    }
+}
+function* decodeCodexSseFrames(buffer) {
+    const separator = /(?:\r\n|\r|\n)(?:\r\n|\r|\n)/;
+    let match = separator.exec(buffer);
+    while (match) {
+        const frame = buffer.slice(0, match.index);
+        buffer = buffer.slice(match.index + match[0].length);
+        const event = parseCodexSseFrame(frame);
+        if (event)
+            yield event;
+        match = separator.exec(buffer);
+    }
+    return buffer;
+}
 async function* parseSSE(response, signal) {
     if (!response.body)
         return;
@@ -478,41 +589,13 @@ async function* parseSSE(response, signal) {
     signal?.addEventListener("abort", onAbort, { once: true });
     try {
         while (true) {
-            if (signal?.aborted) {
-                throw new Error("Request was aborted");
-            }
+            throwIfCodexRequestAborted(signal);
             const { done, value } = await reader.read();
-            if (signal?.aborted) {
-                throw new Error("Request was aborted");
-            }
+            throwIfCodexRequestAborted(signal);
             if (done)
                 break;
             buffer += decoder.decode(value, { stream: true });
-            const separator = /(?:\r\n|\r|\n)(?:\r\n|\r|\n)/;
-            let match = separator.exec(buffer);
-            while (match) {
-                const chunk = buffer.slice(0, match.index);
-                buffer = buffer.slice(match.index + match[0].length);
-                const dataLines = chunk
-                    .split(/\r\n|\r|\n/)
-                    .filter((line) => line.startsWith("data:"))
-                    .map((line) => line.slice(5).trim());
-                if (dataLines.length > 0) {
-                    const data = dataLines.join("\n").trim();
-                    if (data && data !== "[DONE]") {
-                        try {
-                            yield JSON.parse(data);
-                        }
-                        catch (cause) {
-                            throw new CodexProtocolError(`Invalid Codex SSE JSON: ${formatThrownValue(cause)}`, {
-                                cause,
-                                payload: data,
-                            });
-                        }
-                    }
-                }
-                match = separator.exec(buffer);
-            }
+            buffer = (yield* decodeCodexSseFrames(buffer));
         }
     }
     finally {
@@ -830,42 +913,46 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
         },
     };
 }
+function extractNonemptyErrorMessage(value) {
+    if (!value || typeof value !== "object" || !("message" in value))
+        return undefined;
+    const message = value.message;
+    return typeof message === "string" && message.length > 0 ? message : undefined;
+}
 function extractWebSocketError(event) {
-    if (event && typeof event === "object") {
-        const message = "message" in event ? event.message : undefined;
-        if (typeof message === "string" && message.length > 0) {
-            return new Error(message);
-        }
-        const nestedError = "error" in event ? event.error : undefined;
-        if (nestedError instanceof Error && nestedError.message.length > 0) {
-            return nestedError;
-        }
-        if (nestedError && typeof nestedError === "object" && "message" in nestedError) {
-            const nestedMessage = nestedError.message;
-            if (typeof nestedMessage === "string" && nestedMessage.length > 0) {
-                return new Error(nestedMessage);
-            }
-        }
-    }
-    return new Error("WebSocket error");
+    const message = extractNonemptyErrorMessage(event);
+    if (message)
+        return new Error(message);
+    if (!event || typeof event !== "object" || !("error" in event))
+        return new Error("WebSocket error");
+    const nestedError = event.error;
+    if (nestedError instanceof Error && nestedError.message.length > 0)
+        return nestedError;
+    const nestedMessage = extractNonemptyErrorMessage(nestedError);
+    return nestedMessage ? new Error(nestedMessage) : new Error("WebSocket error");
+}
+function readWebSocketCloseErrorOptions(event) {
+    const code = "code" in event ? event.code : undefined;
+    const reason = "reason" in event ? event.reason : undefined;
+    const wasClean = "wasClean" in event ? event.wasClean : undefined;
+    return {
+        code: typeof code === "number" ? code : undefined,
+        reason: typeof reason === "string" && reason.length > 0 ? reason : undefined,
+        wasClean: typeof wasClean === "boolean" ? wasClean : undefined,
+    };
+}
+function formatWebSocketCloseReason(options) {
+    if (options.reason)
+        return ` ${options.reason}`;
+    return options.code === WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE ? " message too big" : "";
 }
 function extractWebSocketCloseError(event) {
-    if (event && typeof event === "object") {
-        const code = "code" in event ? event.code : undefined;
-        const reason = "reason" in event ? event.reason : undefined;
-        const wasClean = "wasClean" in event ? event.wasClean : undefined;
-        const codeText = typeof code === "number" ? ` ${code}` : "";
-        let reasonText = typeof reason === "string" && reason.length > 0 ? ` ${reason}` : "";
-        if (!reasonText && code === WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE) {
-            reasonText = " message too big";
-        }
-        return new WebSocketCloseError(`WebSocket closed${codeText}${reasonText}`.trim(), {
-            code: typeof code === "number" ? code : undefined,
-            reason: typeof reason === "string" && reason.length > 0 ? reason : undefined,
-            wasClean: typeof wasClean === "boolean" ? wasClean : undefined,
-        });
-    }
-    return new Error("WebSocket closed");
+    if (!event || typeof event !== "object")
+        return new Error("WebSocket closed");
+    const options = readWebSocketCloseErrorOptions(event);
+    const codeText = options.code === undefined ? "" : ` ${options.code}`;
+    const reasonText = formatWebSocketCloseReason(options);
+    return new WebSocketCloseError(`WebSocket closed${codeText}${reasonText}`.trim(), options);
 }
 async function decodeWebSocketData(data) {
     if (typeof data === "string")
@@ -884,122 +971,128 @@ async function decodeWebSocketData(data) {
     }
     return null;
 }
-async function* parseWebSocket(socket, signal, idleTimeoutMs) {
-    const queue = [];
-    let pending = null;
-    let done = false;
-    let failed = null;
-    let sawCompletion = false;
-    const wake = () => {
-        if (!pending)
-            return;
-        const resolve = pending;
-        pending = null;
-        resolve();
-    };
-    const enqueue = (processEvent) => {
-        processing = processing.then(processEvent).catch((cause) => {
-            failed =
-                cause instanceof CodexProtocolError
-                    ? cause
-                    : new CodexProtocolError(`Invalid Codex WebSocket JSON: ${formatThrownValue(cause)}`, { cause });
-            done = true;
-            wake();
+function wakeWebSocketParser(state) {
+    if (!state.pending)
+        return;
+    const resolve = state.pending;
+    state.pending = null;
+    resolve();
+}
+function enqueueWebSocketEvent(state, processEvent) {
+    state.processing = state.processing.then(processEvent).catch((cause) => {
+        state.failed =
+            cause instanceof CodexProtocolError
+                ? cause
+                : new CodexProtocolError(`Invalid Codex WebSocket JSON: ${formatThrownValue(cause)}`, { cause });
+        state.done = true;
+        wakeWebSocketParser(state);
+    });
+}
+function parseWebSocketMessageJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch (cause) {
+        throw new CodexProtocolError(`Invalid Codex WebSocket JSON: ${formatThrownValue(cause)}`, {
+            cause,
+            payload: text,
         });
+    }
+}
+async function processWebSocketMessage(event, state) {
+    if (!event || typeof event !== "object" || !("data" in event))
+        return;
+    const text = await decodeWebSocketData(event.data);
+    if (!text)
+        return;
+    const parsed = parseWebSocketMessageJson(text);
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    if (type === "response.completed" || type === "response.done" || type === "response.incomplete") {
+        state.sawCompletion = true;
+        state.done = true;
+    }
+    state.queue.push(parsed);
+    wakeWebSocketParser(state);
+}
+function processWebSocketError(event, state) {
+    state.failed = extractWebSocketError(event);
+    state.done = true;
+    wakeWebSocketParser(state);
+}
+function processWebSocketClose(event, state) {
+    if (state.sawCompletion) {
+        state.done = true;
+        wakeWebSocketParser(state);
+        return;
+    }
+    if (!state.failed)
+        state.failed = extractWebSocketCloseError(event);
+    state.done = true;
+    wakeWebSocketParser(state);
+}
+function abortWebSocketParsing(state) {
+    state.failed = new Error("Request was aborted");
+    state.done = true;
+    wakeWebSocketParser(state);
+}
+async function waitForWebSocketActivity(socket, state, idleTimeoutMs) {
+    let timeout;
+    await new Promise((resolve, reject) => {
+        state.pending = resolve;
+        if (idleTimeoutMs !== undefined && idleTimeoutMs > 0) {
+            timeout = setTimeout(() => {
+                const error = new Error(`WebSocket idle timeout after ${idleTimeoutMs}ms`);
+                state.failed = error;
+                state.done = true;
+                state.pending = null;
+                closeWebSocketSilently(socket, 1000, "idle_timeout");
+                reject(error);
+            }, idleTimeoutMs);
+        }
+    }).finally(() => {
+        if (timeout)
+            clearTimeout(timeout);
+    });
+}
+async function* parseWebSocket(socket, signal, idleTimeoutMs) {
+    const state = {
+        queue: [],
+        pending: null,
+        done: false,
+        failed: null,
+        sawCompletion: false,
+        processing: Promise.resolve(),
     };
-    let processing = Promise.resolve();
     const onMessage = (event) => {
-        enqueue(async () => {
-            if (!event || typeof event !== "object" || !("data" in event))
-                return;
-            const text = await decodeWebSocketData(event.data);
-            if (!text)
-                return;
-            let parsed;
-            try {
-                parsed = JSON.parse(text);
-            }
-            catch (cause) {
-                throw new CodexProtocolError(`Invalid Codex WebSocket JSON: ${formatThrownValue(cause)}`, {
-                    cause,
-                    payload: text,
-                });
-            }
-            const type = typeof parsed.type === "string" ? parsed.type : "";
-            if (type === "response.completed" || type === "response.done" || type === "response.incomplete") {
-                sawCompletion = true;
-                done = true;
-            }
-            queue.push(parsed);
-            wake();
-        });
+        enqueueWebSocketEvent(state, () => processWebSocketMessage(event, state));
     };
     const onError = (event) => {
-        enqueue(() => {
-            failed = extractWebSocketError(event);
-            done = true;
-            wake();
-        });
+        enqueueWebSocketEvent(state, () => processWebSocketError(event, state));
     };
     const onClose = (event) => {
-        enqueue(() => {
-            if (sawCompletion) {
-                done = true;
-                wake();
-                return;
-            }
-            if (!failed) {
-                failed = extractWebSocketCloseError(event);
-            }
-            done = true;
-            wake();
-        });
-    };
-    const onAbort = () => {
-        failed = new Error("Request was aborted");
-        done = true;
-        wake();
+        enqueueWebSocketEvent(state, () => processWebSocketClose(event, state));
     };
+    const onAbort = () => abortWebSocketParsing(state);
     socket.addEventListener("message", onMessage);
     socket.addEventListener("error", onError);
     socket.addEventListener("close", onClose);
     signal?.addEventListener("abort", onAbort);
     try {
         while (true) {
-            if (signal?.aborted) {
+            if (signal?.aborted)
                 throw new Error("Request was aborted");
-            }
-            if (queue.length > 0) {
-                yield queue.shift();
+            if (state.queue.length > 0) {
+                yield* state.queue.splice(0, 1);
                 continue;
             }
-            if (done)
+            if (state.done)
                 break;
-            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) {
-            throw failed;
+            await waitForWebSocketActivity(socket, state, idleTimeoutMs);
         }
-        if (!sawCompletion) {
+        if (state.failed)
+            throw state.failed;
+        if (!state.sawCompletion)
             throw new Error("WebSocket stream closed before response.completed");
-        }
     }
     finally {
         socket.removeEventListener("message", onMessage);
@@ -1060,6 +1153,44 @@ async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart
         yield event;
     }
 }
+function recordWebSocketRequestStats(stats, reused, useCachedContext, requestBody) {
+    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;
+        return;
+    }
+    stats.fullContextRequests++;
+    stats.lastDeltaInputItems = undefined;
+    stats.lastPreviousResponseId = undefined;
+}
+function finishWebSocketRequest(entry, fullBody, output, model, useCachedContext, signal) {
+    if (signal?.aborted)
+        return false;
+    if (!useCachedContext || !entry || !output.responseId)
+        return true;
+    const responseItems = convertResponsesMessages(model, { messages: [output] }, CODEX_TOOL_CALL_PROVIDERS, {
+        includeSystemPrompt: false,
+    }).filter((item) => item.type !== "function_call_output");
+    entry.continuation = {
+        lastRequestBody: fullBody,
+        lastResponseId: output.responseId,
+        lastResponseItems: responseItems,
+    };
+    return true;
+}
 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;
@@ -1069,28 +1200,7 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
     const fullBody = body;
     const 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;
-        }
-    }
+    recordWebSocketRequestStats(stats, reused, useCachedContext, requestBody);
     try {
         socket.send(JSON.stringify({ type: "response.create", ...requestBody }));
         await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal, idleTimeoutMs)), output, stream, onStart), output, stream, model, {
@@ -1098,19 +1208,7 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
             resolveServiceTier: resolveCodexServiceTier,
             applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
         });
-        if (options?.signal?.aborted) {
-            keepConnection = false;
-        }
-        else if (useCachedContext && entry && output.responseId) {
-            const responseItems = convertResponsesMessages(model, { messages: [output] }, CODEX_TOOL_CALL_PROVIDERS, {
-                includeSystemPrompt: false,
-            }).filter((item) => item.type !== "function_call_output");
-            entry.continuation = {
-                lastRequestBody: fullBody,
-                lastResponseId: output.responseId,
-                lastResponseItems: responseItems,
-            };
-        }
+        keepConnection = finishWebSocketRequest(entry, fullBody, output, model, useCachedContext, options?.signal);
     }
     catch (error) {
         if (entry) {
@@ -1126,28 +1224,29 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
 // ============================================================================
 // Error Handling
 // ============================================================================
+function describeCodexApiError(error, status, fallbackMessage) {
+    const code = error.code || error.type || "";
+    if (!/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code) && status !== 429) {
+        return { message: error.message || fallbackMessage };
+    }
+    const plan = error.plan_type ? ` (${error.plan_type.toLowerCase()} plan)` : "";
+    const minutesUntilReset = error.resets_at
+        ? Math.max(0, Math.round((error.resets_at * 1000 - Date.now()) / 60000))
+        : undefined;
+    const retryMessage = minutesUntilReset !== undefined ? ` Try again in ~${minutesUntilReset} min.` : "";
+    const friendlyMessage = `You have hit your ChatGPT usage limit${plan}.${retryMessage}`.trim();
+    return { message: error.message || friendlyMessage, friendlyMessage };
+}
 async function parseErrorResponse(response) {
     const raw = await response.text();
-    let message = raw || response.statusText || "Request failed";
-    let friendlyMessage;
+    const fallbackMessage = raw || response.statusText || "Request failed";
     try {
-        const parsed = JSON.parse(raw);
-        const err = parsed?.error;
-        if (err) {
-            const code = err.code || err.type || "";
-            if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code) || response.status === 429) {
-                const plan = err.plan_type ? ` (${err.plan_type.toLowerCase()} plan)` : "";
-                const mins = err.resets_at
-                    ? Math.max(0, Math.round((err.resets_at * 1000 - Date.now()) / 60000))
-                    : undefined;
-                const when = mins !== undefined ? ` Try again in ~${mins} min.` : "";
-                friendlyMessage = `You have hit your ChatGPT usage limit${plan}.${when}`.trim();
-            }
-            message = err.message || friendlyMessage || message;
-        }
+        const error = JSON.parse(raw).error;
+        if (error)
+            return describeCodexApiError(error, response.status, fallbackMessage);
     }
     catch { }
-    return { message, friendlyMessage };
+    return { message: fallbackMessage };
 }
 // ============================================================================
 // Auth & Headers
@@ -1176,7 +1275,10 @@ function createCodexRequestId() {
 function buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token) {
     const headers = new Headers(initHeaders);
     for (const [key, value] of Object.entries(additionalHeaders || {})) {
-        headers.set(key, value);
+        if (value === null)
+            headers.delete(key);
+        else
+            headers.set(key, value);
     }
     headers.set("Authorization", `Bearer ${token}`);
     headers.set("chatgpt-account-id", accountId);