@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/vendor/engine/runtime/ai/api/openai-codex-responses.js

@@ -0,0 +1,1302 @@
+import { andorraClampThinkingLevel } from "../models.js";
+import { andorraRegisterSessionResourceCleanup } from "../session-resources.js";
+import { andorraCombineAbortSignals } from "../utils/abort-signals.js";
+import { andorraAppendAssistantMessageDiagnostic, andorraCreateAssistantMessageDiagnostic, andorraFormatThrownValue, } from "../utils/diagnostics.js";
+import { andorraFormatProviderError, andorraNormalizeProviderError } from "../utils/error-body.js";
+import { AndorraAssistantMessageEventStream } from "../utils/event-stream.js";
+import { andorraHeadersToRecord } from "../utils/headers.js";
+import { andorraResolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
+import { andorraGetAndorraUserAgent } from "../utils/pi-user-agent.js";
+import { andorraGetSystemMessageText } from "../utils/text.js";
+import { andorraGetDeclaredTools, andorraGetInitialSystemMessage, andorraNormalizeContext, andorraResolveTranscript, andorraResolveTranscriptTools, } from "../utils/transcript.js";
+import { andorraUuidv7 } from "../utils/uuid.js";
+import { andorraCreateGrammarToolInputProperties } from "./constrained-sampling.js";
+import { andorraClampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
+import { andorraConvertResponsesMessages, andorraConvertResponsesTools, andorraProcessResponsesStream } from "./openai-responses-shared.js";
+import { andorraBuildBaseOptions } from "./simple-options.js";
+// ============================================================================
+// Configuration
+// ============================================================================
+const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+const JWT_CLAIM_PATH = "https://api.openai.com/auth";
+const DEFAULT_MAX_RETRIES = 0;
+const BASE_DELAY_MS = 1000;
+const DEFAULT_MAX_RETRY_DELAY_MS = 60_000;
+const DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS = 15_000;
+// The Codex backend accepts zstd-compressed request bodies on the SSE responses
+// endpoint (the same endpoint the official Codex client compresses against).
+const REQUEST_COMPRESSION_ZSTD_LEVEL = 3;
+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 PREVIOUS_RESPONSE_NOT_FOUND_CODE = "previous_response_not_found";
+const CODEX_RESPONSE_STATUSES = new Set([
+    "completed",
+    "incomplete",
+    "failed",
+    "cancelled",
+    "queued",
+    "in_progress",
+]);
+function andorraAssertSuccessfulOutput(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
+// ============================================================================
+function andorraIsTerminalRateLimitError(errorText) {
+    return /GoUsageLimitError|FreeUsageLimitError|Monthly usage limit reached|available balance|insufficient_quota|out of budget|quota exceeded|billing/i.test(errorText);
+}
+function andorraIsRetryableError(status, errorText) {
+    if (status === 429 && andorraIsTerminalRateLimitError(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);
+}
+function andorraGetRetryAfterDelayMs(headers) {
+    const retryAfterMs = headers.get("retry-after-ms");
+    if (retryAfterMs !== null) {
+        const millis = Number(retryAfterMs);
+        if (Number.isFinite(millis)) {
+            return Math.max(0, millis);
+        }
+    }
+    const retryAfter = headers.get("retry-after");
+    if (!retryAfter) {
+        return undefined;
+    }
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, seconds * 1000);
+    }
+    const date = Date.parse(retryAfter);
+    if (!Number.isNaN(date)) {
+        return Math.max(0, date - Date.now());
+    }
+    return undefined;
+}
+class AndorraRetryDelayExceededError extends Error {
+}
+function andorraValidateRetryDelayMs(delayMs, options) {
+    const maxRetryDelayMs = options?.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
+    if (maxRetryDelayMs > 0 && delayMs > maxRetryDelayMs) {
+        throw new AndorraRetryDelayExceededError(`Server requested ${Math.ceil(delayMs / 1000)}s retry delay (max: ${Math.ceil(maxRetryDelayMs / 1000)}s)`);
+    }
+    return delayMs;
+}
+function andorraSleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new Error("Request was aborted"));
+            return;
+        }
+        const timeout = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(timeout);
+            reject(new Error("Request was aborted"));
+        });
+    });
+}
+function andorraNormalizeTimeoutMs(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`Invalid timeoutMs: ${String(value)}`);
+    }
+    return Math.floor(value);
+}
+function andorraLoadNodeZlib() {
+    if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) {
+        return null;
+    }
+    return process.getBuiltinModule?.("node:zlib") ?? null;
+}
+// Returns the zstd-compressed body bytes, or null when compression is
+// unavailable (browser/Vite builds). Callers fall back to sending the
+// uncompressed JSON when this returns null.
+function andorraCompressRequestBodyZstd(bodyJson) {
+    const zlib = andorraLoadNodeZlib();
+    if (!zlib || typeof zlib.zstdCompressSync !== "function") {
+        return null;
+    }
+    try {
+        const compressed = zlib.zstdCompressSync(bodyJson, {
+            params: { [zlib.constants.ZSTD_c_compressionLevel]: REQUEST_COMPRESSION_ZSTD_LEVEL },
+        });
+        return new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength);
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================================
+// Main Stream Function
+// ============================================================================
+export const andorraStream = (model, context, options) => {
+    const stream = new AndorraAssistantMessageEventStream();
+    const normalizedContext = andorraResolveTranscript(context, model.compat?.supportsMidConvoSystemMessages);
+    (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: "pending",
+            timestamp: Date.now(),
+        };
+        try {
+            const apiKey = options?.apiKey;
+            if (!apiKey) {
+                throw new Error(`No API key for provider: ${model.provider}`);
+            }
+            const accountId = andorraExtractAccountId(apiKey);
+            const grammarToolInputProperties = andorraCreateGrammarToolInputProperties(andorraGetDeclaredTools(normalizedContext.messages), model.compat?.supportsOpenAIGrammarTools ?? false);
+            const cacheSessionId = options?.cacheRetention === "none" ? undefined : options?.sessionId;
+            const codexSessionId = andorraClampOpenAIPromptCacheKey(cacheSessionId);
+            let body = andorraBuildRequestBody(model, normalizedContext, options, codexSessionId, grammarToolInputProperties);
+            const nextBody = await options?.onPayload?.(body, model);
+            if (nextBody !== undefined) {
+                body = nextBody;
+            }
+            const websocketRequestId = codexSessionId || andorraUuidv7();
+            const sseHeaders = andorraBuildSSEHeaders(model.headers, options?.headers, accountId, apiKey, codexSessionId);
+            const websocketHeaders = andorraBuildWebSocketHeaders(model.headers, options?.headers, accountId, apiKey, websocketRequestId);
+            const bodyJson = JSON.stringify(body);
+            const httpTimeoutMs = andorraNormalizeTimeoutMs(options?.timeoutMs);
+            const websocketConnectTimeoutMs = andorraNormalizeTimeoutMs(options?.websocketConnectTimeoutMs);
+            const transport = options?.transport || "auto";
+            let startEmitted = false;
+            const websocketDisabledForSession = transport !== "sse" && andorraIsWebSocketSseFallbackActive(cacheSessionId);
+            if (websocketDisabledForSession) {
+                andorraRecordWebSocketSseFallback(cacheSessionId);
+            }
+            if (transport !== "sse" && !websocketDisabledForSession) {
+                let websocketStarted = false;
+                let retriedWebSocketConnectionLimit = false;
+                let retriedMissingWebSocketContinuation = false;
+                while (true) {
+                    websocketStarted = false;
+                    try {
+                        await andorraProcessWebSocketStream(andorraResolveCodexWebSocketUrl(model.baseUrl), body, websocketHeaders, output, stream, model, () => {
+                            websocketStarted = true;
+                            if (!startEmitted) {
+                                startEmitted = true;
+                                stream.push({ type: "start", partial: output });
+                            }
+                        }, httpTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, accountId, grammarToolInputProperties, options);
+                        if (options?.signal?.aborted) {
+                            throw new Error("Request was aborted");
+                        }
+                        andorraAssertSuccessfulOutput(output);
+                        stream.push({
+                            type: "done",
+                            reason: output.stopReason,
+                            message: output,
+                        });
+                        stream.end();
+                        return;
+                    }
+                    catch (error) {
+                        const aborted = options?.signal?.aborted;
+                        const connectionLimitBeforeStart = !websocketStarted && andorraIsWebSocketConnectionLimitReachedError(error);
+                        const previousResponseNotFound = andorraIsPreviousResponseNotFoundError(error);
+                        if (!aborted && previousResponseNotFound && !retriedMissingWebSocketContinuation) {
+                            retriedMissingWebSocketContinuation = true;
+                            continue;
+                        }
+                        if (!aborted && connectionLimitBeforeStart && !retriedWebSocketConnectionLimit) {
+                            retriedWebSocketConnectionLimit = true;
+                            continue;
+                        }
+                        if (aborted || (andorraIsCodexNonTransportError(error) && !connectionLimitBeforeStart)) {
+                            throw error;
+                        }
+                        andorraAppendAssistantMessageDiagnostic(output, andorraCreateAssistantMessageDiagnostic("provider_transport_failure", error, {
+                            configuredTransport: transport,
+                            ...(websocketStarted ? {} : { fallbackTransport: "sse" }),
+                            eventsEmitted: websocketStarted,
+                            phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
+                            requestBytes: new TextEncoder().encode(bodyJson).byteLength,
+                        }));
+                        andorraRecordWebSocketFailure(cacheSessionId, error);
+                        if (websocketStarted) {
+                            throw error;
+                        }
+                        andorraRecordWebSocketSseFallback(cacheSessionId);
+                        break;
+                    }
+                }
+            }
+            // Compress the request body once for the SSE path. The Codex backend
+            // decodes Content-Encoding: zstd; the WebSocket transport above sends the
+            // uncompressed JSON frame, matching the official Codex client.
+            const compressedBody = andorraCompressRequestBodyZstd(bodyJson);
+            if (compressedBody) {
+                sseHeaders.set("content-encoding", "zstd");
+            }
+            const sseBody = compressedBody ?? bodyJson;
+            // 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 headerTimeoutSignal = httpTimeoutMs !== undefined && httpTimeoutMs > 0 ? AbortSignal.timeout(httpTimeoutMs) : undefined;
+                    const combinedSignal = andorraCombineAbortSignals([options?.signal, headerTimeoutSignal]);
+                    try {
+                        response = await (options?.fetch ?? globalThis.fetch)(andorraResolveCodexUrl(model.baseUrl), {
+                            method: "POST",
+                            headers: sseHeaders,
+                            body: sseBody,
+                            signal: combinedSignal.signal,
+                        });
+                    }
+                    catch (error) {
+                        if (headerTimeoutSignal?.aborted && !options?.signal?.aborted) {
+                            throw new Error(`Codex SSE response headers timed out after ${httpTimeoutMs}ms`);
+                        }
+                        throw error;
+                    }
+                    finally {
+                        combinedSignal.cleanup();
+                    }
+                    await options?.onResponse?.({ status: response.status, headers: andorraHeadersToRecord(response.headers) }, model);
+                    if (response.ok) {
+                        break;
+                    }
+                    const errorText = await response.text();
+                    if (attempt < maxRetries && andorraIsRetryableError(response.status, errorText)) {
+                        const retryAfterDelayMs = andorraGetRetryAfterDelayMs(response.headers);
+                        const delayMs = retryAfterDelayMs === undefined
+                            ? BASE_DELAY_MS * 2 ** attempt
+                            : andorraValidateRetryDelayMs(retryAfterDelayMs, options);
+                        await andorraSleep(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 andorraParseErrorResponse(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 instanceof AndorraRetryDelayExceededError) &&
+                        !lastError.message.includes("usage limit")) {
+                        const delayMs = BASE_DELAY_MS * 2 ** attempt;
+                        await andorraSleep(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");
+            }
+            if (!startEmitted) {
+                startEmitted = true;
+                stream.push({ type: "start", partial: output });
+            }
+            await andorraProcessStream(response, output, stream, model, grammarToolInputProperties, options);
+            if (options?.signal?.aborted) {
+                throw new Error("Request was aborted");
+            }
+            andorraAssertSuccessfulOutput(output);
+            stream.push({ type: "done", reason: output.stopReason, message: output });
+            stream.end();
+        }
+        catch (error) {
+            for (const block of output.content) {
+                // Streaming scratch buffers are only used during parsing; never persist them.
+                delete block.partialJson;
+                delete block.customInput;
+            }
+            output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+            output.errorMessage = andorraFormatProviderError(andorraNormalizeProviderError(error));
+            stream.push({ type: "error", reason: output.stopReason, error: output });
+            stream.end();
+        }
+    })();
+    return stream;
+};
+export const andorraStreamSimple = (model, context, options) => {
+    const apiKey = options?.apiKey;
+    if (!apiKey) {
+        throw new Error(`No API key for provider: ${model.provider}`);
+    }
+    const base = {
+        ...andorraBuildBaseOptions(model, context, options, apiKey),
+        toolChoice: options?.toolChoice,
+    };
+    const clampedReasoning = options?.reasoning ? andorraClampThinkingLevel(model, options.reasoning) : undefined;
+    const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
+    return andorraStream(model, context, {
+        ...base,
+        reasoningEffort,
+    });
+};
+// ============================================================================
+// Request Building
+// ============================================================================
+function andorraBuildRequestBody(model, context, options, cacheSessionId, grammarToolInputProperties = andorraCreateGrammarToolInputProperties(andorraGetDeclaredTools(context.messages), model.compat?.supportsOpenAIGrammarTools ?? false)) {
+    const supportsStrictMode = model.compat?.supportsStrictMode ?? true;
+    const supportsOpenAIGrammarTools = model.compat?.supportsOpenAIGrammarTools ?? false;
+    const supportsAdditionalTools = model.compat?.supportsAdditionalTools ?? false;
+    const supportsToolSearch = model.compat?.supportsToolSearch ?? false;
+    const transcriptTools = andorraResolveTranscriptTools(context.messages, supportsAdditionalTools || supportsToolSearch);
+    const messages = andorraConvertResponsesMessages(model, context, CODEX_TOOL_CALL_PROVIDERS, {
+        includeSystemPrompt: false,
+        grammarToolInputProperties,
+        supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
+        supportsAdditionalTools,
+        supportsToolSearch,
+        toolOptions: { strict: null, supportsStrictMode, supportsOpenAIGrammarTools },
+    });
+    const initialSystemMessage = andorraGetInitialSystemMessage(context.messages);
+    const instructions = initialSystemMessage ? andorraGetSystemMessageText(initialSystemMessage) : "";
+    const body = {
+        model: model.id,
+        store: false,
+        stream: true,
+        instructions: instructions || "You are a helpful assistant.",
+        input: messages,
+        text: { verbosity: options?.textVerbosity || "low" },
+        include: ["reasoning.encrypted_content"],
+        prompt_cache_key: cacheSessionId,
+        tool_choice: options?.toolChoice ?? "auto",
+        parallel_tool_calls: true,
+    };
+    if (options?.temperature !== undefined) {
+        body.temperature = options.temperature;
+    }
+    if (options?.serviceTier !== undefined) {
+        body.service_tier = options.serviceTier;
+    }
+    if (transcriptTools.requestTools.length > 0) {
+        body.tools = andorraConvertResponsesTools(transcriptTools.requestTools, {
+            strict: null,
+            supportsStrictMode,
+            supportsOpenAIGrammarTools,
+        });
+    }
+    if (options?.reasoningEffort !== undefined) {
+        const effort = options.reasoningEffort === "none"
+            ? model.thinkingLevelMap?.off === undefined
+                ? "none"
+                : model.thinkingLevelMap.off
+            : (model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort);
+        if (effort !== null) {
+            body.reasoning = {
+                effort,
+                summary: options.reasoningSummary ?? "auto",
+            };
+        }
+    }
+    else if (model.reasoning && model.thinkingLevelMap?.off !== null) {
+        body.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+    }
+    return body;
+}
+function andorraGetServiceTierCostMultiplier(model, serviceTier) {
+    switch (serviceTier) {
+        case "flex":
+            return 0.5;
+        case "priority":
+            return model.id === "gpt-5.5" ? 2.5 : 2;
+        default:
+            return 1;
+    }
+}
+function andorraApplyServiceTierPricing(usage, serviceTier, model) {
+    const multiplier = andorraGetServiceTierCostMultiplier(model, serviceTier);
+    if (multiplier === 1)
+        return;
+    usage.cost.input *= multiplier;
+    usage.cost.output *= multiplier;
+    usage.cost.cacheRead *= multiplier;
+    usage.cost.cacheWrite *= multiplier;
+    usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+}
+function andorraResolveCodexServiceTier(responseServiceTier, requestServiceTier) {
+    if (responseServiceTier === "default" && (requestServiceTier === "flex" || requestServiceTier === "priority")) {
+        return requestServiceTier;
+    }
+    return responseServiceTier ?? requestServiceTier;
+}
+function andorraResolveCodexUrl(baseUrl) {
+    const raw = baseUrl && baseUrl.trim().length > 0 ? baseUrl : DEFAULT_CODEX_BASE_URL;
+    const normalized = raw.replace(/\/+$/, "");
+    if (normalized.endsWith("/codex/responses"))
+        return normalized;
+    if (normalized.endsWith("/codex"))
+        return `${normalized}/responses`;
+    return `${normalized}/codex/responses`;
+}
+function andorraResolveCodexWebSocketUrl(baseUrl) {
+    const url = new URL(andorraResolveCodexUrl(baseUrl));
+    if (url.protocol === "https:")
+        url.protocol = "wss:";
+    if (url.protocol === "http:")
+        url.protocol = "ws:";
+    return url.toString();
+}
+// ============================================================================
+// Response Processing
+// ============================================================================
+async function andorraProcessStream(response, output, stream, model, grammarToolInputProperties, options) {
+    await andorraProcessResponsesStream(andorraMapCodexEvents(andorraParseSSE(response, options?.signal), output), output, stream, model, {
+        serviceTier: options?.serviceTier,
+        grammarToolInputProperties,
+        resolveServiceTier: andorraResolveCodexServiceTier,
+        applyServiceTierPricing: (usage, serviceTier) => andorraApplyServiceTierPricing(usage, serviceTier, model),
+    });
+}
+class AndorraCodexApiError extends Error {
+    code;
+    payload;
+    constructor(message, options) {
+        super(message);
+        this.name = "CodexApiError";
+        this.code = options?.code;
+        this.payload = options?.payload;
+        this.cause = options?.cause;
+    }
+}
+class AndorraCodexProtocolError extends Error {
+    payload;
+    constructor(message, options) {
+        super(message);
+        this.name = "CodexProtocolError";
+        this.payload = options?.payload;
+        this.cause = options?.cause;
+    }
+}
+function andorraIsCodexNonTransportError(error) {
+    return error instanceof AndorraCodexApiError || error instanceof AndorraCodexProtocolError;
+}
+function andorraIsWebSocketConnectionLimitReachedError(error) {
+    return error instanceof AndorraCodexApiError && error.code === WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE;
+}
+function andorraIsPreviousResponseNotFoundError(error) {
+    return error instanceof AndorraCodexApiError && error.code === PREVIOUS_RESPONSE_NOT_FOUND_CODE;
+}
+function andorraExtractCodexEventError(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,
+    };
+}
+async function* andorraMapCodexEvents(events, output) {
+    for await (const event of events) {
+        const type = typeof event.type === "string" ? event.type : undefined;
+        if (!type)
+            continue;
+        if (type === "error") {
+            const { code, message } = andorraExtractCodexEventError(event);
+            throw new AndorraCodexApiError(`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 AndorraCodexApiError(message || "Codex response failed", { code, payload: event });
+        }
+        if (type === "response.done" || type === "response.completed" || type === "response.incomplete") {
+            const response = event.response;
+            if (typeof response?.end_turn === "boolean") {
+                output.endTurn = response.end_turn;
+            }
+            const normalizedResponse = response
+                ? { ...response, status: andorraNormalizeCodexStatus(response.status) }
+                : response;
+            yield { ...event, type: "response.completed", response: normalizedResponse };
+            return;
+        }
+        yield event;
+    }
+}
+function andorraNormalizeCodexStatus(status) {
+    if (typeof status !== "string")
+        return undefined;
+    return CODEX_RESPONSE_STATUSES.has(status) ? status : undefined;
+}
+// ============================================================================
+// SSE Parsing
+// ============================================================================
+async function* andorraParseSSE(response, signal) {
+    if (!response.body)
+        return;
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const andorraOnAbort = () => {
+        void reader.cancel().catch(() => { });
+    };
+    signal?.addEventListener("abort", andorraOnAbort, { once: true });
+    try {
+        while (true) {
+            if (signal?.aborted) {
+                throw new Error("Request was aborted");
+            }
+            const { done, value } = await reader.read();
+            if (signal?.aborted) {
+                throw new Error("Request was aborted");
+            }
+            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);
+                buffer = buffer.slice(idx + 2);
+                const dataLines = chunk
+                    .split("\n")
+                    .filter((l) => l.startsWith("data:"))
+                    .map((l) => l.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 AndorraCodexProtocolError(`Invalid Codex SSE JSON: ${andorraFormatThrownValue(cause)}`, {
+                                cause,
+                                payload: data,
+                            });
+                        }
+                    }
+                }
+                idx = buffer.indexOf("\n\n");
+            }
+            if (done)
+                break;
+        }
+    }
+    finally {
+        signal?.removeEventListener("abort", andorraOnAbort);
+        try {
+            await reader.cancel();
+        }
+        catch { }
+        try {
+            reader.releaseLock();
+        }
+        catch { }
+    }
+}
+// ============================================================================
+// WebSocket Parsing
+// ============================================================================
+const OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
+const SESSION_WEBSOCKET_CACHE_TTL_MS = 5 * 60 * 1000;
+const SESSION_WEBSOCKET_MAX_AGE_MS = 55 * 60 * 1000;
+const websocketSessionCache = new Map();
+const websocketDebugStats = new Map();
+const websocketSseFallbackSessions = new Set();
+function andorraGetOrCreateWebSocketDebugStats(sessionId) {
+    let stats = websocketDebugStats.get(sessionId);
+    if (!stats) {
+        stats = {
+            requests: 0,
+            connectionsCreated: 0,
+            connectionsReused: 0,
+            cachedContextRequests: 0,
+            storeTrueRequests: 0,
+            fullContextRequests: 0,
+            deltaRequests: 0,
+            lastInputItems: 0,
+            websocketFailures: 0,
+            sseFallbacks: 0,
+        };
+        websocketDebugStats.set(sessionId, stats);
+    }
+    return stats;
+}
+export function andorraGetOpenAICodexWebSocketDebugStats(sessionId) {
+    const stats = websocketDebugStats.get(sessionId);
+    return stats ? { ...stats } : undefined;
+}
+export function andorraResetOpenAICodexWebSocketDebugStats(sessionId) {
+    if (sessionId) {
+        websocketDebugStats.delete(sessionId);
+        websocketSseFallbackSessions.delete(sessionId);
+        return;
+    }
+    websocketDebugStats.clear();
+    websocketSseFallbackSessions.clear();
+}
+export function andorraCloseOpenAICodexWebSocketSessions(sessionId) {
+    const andorraCloseEntry = (entry) => {
+        if (entry.idleTimer)
+            clearTimeout(entry.idleTimer);
+        andorraCloseWebSocketSilently(entry.socket, 1000, "debug_close");
+    };
+    if (sessionId) {
+        for (const entry of websocketSessionCache.get(sessionId)?.values() ?? [])
+            andorraCloseEntry(entry);
+        websocketSessionCache.delete(sessionId);
+        return;
+    }
+    for (const accountEntries of websocketSessionCache.values()) {
+        for (const entry of accountEntries.values())
+            andorraCloseEntry(entry);
+    }
+    websocketSessionCache.clear();
+}
+andorraRegisterSessionResourceCleanup(andorraCloseOpenAICodexWebSocketSessions);
+function andorraIsWebSocketSseFallbackActive(sessionId) {
+    return sessionId ? websocketSseFallbackSessions.has(sessionId) : false;
+}
+function andorraRecordWebSocketSseFallback(sessionId) {
+    if (!sessionId)
+        return;
+    const stats = andorraGetOrCreateWebSocketDebugStats(sessionId);
+    stats.sseFallbacks++;
+    stats.websocketFallbackActive = andorraIsWebSocketSseFallbackActive(sessionId);
+}
+function andorraRecordWebSocketFailure(sessionId, error) {
+    if (!sessionId)
+        return;
+    websocketSseFallbackSessions.add(sessionId);
+    const stats = andorraGetOrCreateWebSocketDebugStats(sessionId);
+    stats.websocketFailures++;
+    stats.lastWebSocketError = andorraFormatThrownValue(error);
+    stats.websocketFallbackActive = true;
+}
+let _cachedWebsocket = null;
+async function andorraGetWebSocketConstructor(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 (typeof process !== "undefined" && process.versions?.bun) {
+        const AndorraWebSocketWithProxy = class extends WebSocket {
+            constructor(url, options) {
+                let _opts = {};
+                if (Array.isArray(options) || typeof options === "string") {
+                    _opts = { protocols: options };
+                }
+                else {
+                    _opts = { ...options };
+                }
+                const proxyUrl = andorraResolveHttpProxyUrlForTarget(url.toString().replace(/^wss:/, "https:").replace(/^ws:/, "http:"), env);
+                super(url, { ..._opts, ...(proxyUrl ? { proxy: proxyUrl.toString() } : {}) });
+            }
+        };
+        if (!env) {
+            _cachedWebsocket = AndorraWebSocketWithProxy;
+        }
+        return AndorraWebSocketWithProxy;
+    }
+    const ctor = globalThis.WebSocket;
+    if (typeof ctor !== "function")
+        return null;
+    return ctor;
+}
+class AndorraWebSocketCloseError extends Error {
+    code;
+    reason;
+    wasClean;
+    constructor(message, options) {
+        super(message);
+        this.name = "WebSocketCloseError";
+        this.code = options?.code;
+        this.reason = options?.reason;
+        this.wasClean = options?.wasClean;
+    }
+}
+function andorraGetWebSocketReadyState(socket) {
+    const readyState = socket.readyState;
+    return typeof readyState === "number" ? readyState : undefined;
+}
+function andorraIsWebSocketReusable(socket) {
+    const readyState = andorraGetWebSocketReadyState(socket);
+    // If readyState is unavailable, assume the runtime keeps it open/reusable.
+    return readyState === undefined || readyState === 1;
+}
+function andorraIsWebSocketSessionExpired(entry) {
+    return Date.now() - entry.createdAt >= SESSION_WEBSOCKET_MAX_AGE_MS;
+}
+function andorraCloseWebSocketSilently(socket, code = 1000, reason = "done") {
+    try {
+        socket.close(code, reason);
+    }
+    catch { }
+}
+function andorraScheduleSessionWebSocketExpiry(sessionId, accountId, entry) {
+    if (entry.idleTimer) {
+        clearTimeout(entry.idleTimer);
+    }
+    entry.idleTimer = setTimeout(() => {
+        if (entry.busy)
+            return;
+        andorraCloseWebSocketSilently(entry.socket, 1000, "idle_timeout");
+        const accountEntries = websocketSessionCache.get(sessionId);
+        if (accountEntries?.get(accountId) === entry)
+            accountEntries.delete(accountId);
+        if (accountEntries?.size === 0)
+            websocketSessionCache.delete(sessionId);
+    }, SESSION_WEBSOCKET_CACHE_TTL_MS);
+}
+async function andorraConnectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS, env) {
+    const WebSocketCtor = await andorraGetWebSocketConstructor(env);
+    if (!WebSocketCtor) {
+        throw new Error("WebSocket transport is not available in this runtime");
+    }
+    const wsHeaders = andorraHeadersToRecord(headers);
+    delete wsHeaders["OpenAI-Beta"];
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let timeout;
+        let socket;
+        try {
+            socket = new WebSocketCtor(url, { headers: wsHeaders });
+        }
+        catch (error) {
+            reject(error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        const andorraCleanup = () => {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = undefined;
+            }
+            socket.removeEventListener("open", andorraOnOpen);
+            socket.removeEventListener("error", andorraOnError);
+            socket.removeEventListener("close", andorraOnClose);
+            signal?.removeEventListener("abort", andorraOnAbort);
+        };
+        const andorraFail = (error, closeReason) => {
+            if (settled)
+                return;
+            settled = true;
+            andorraCleanup();
+            if (closeReason) {
+                andorraCloseWebSocketSilently(socket, 1000, closeReason);
+            }
+            reject(error);
+        };
+        const andorraOnOpen = () => {
+            if (settled)
+                return;
+            settled = true;
+            andorraCleanup();
+            resolve(socket);
+        };
+        const andorraOnError = (event) => {
+            andorraFail(andorraExtractWebSocketError(event));
+        };
+        const andorraOnClose = (event) => {
+            andorraFail(andorraExtractWebSocketCloseError(event));
+        };
+        const andorraOnAbort = () => {
+            andorraFail(new Error("Request was aborted"), "aborted");
+        };
+        socket.addEventListener("open", andorraOnOpen);
+        socket.addEventListener("error", andorraOnError);
+        socket.addEventListener("close", andorraOnClose);
+        signal?.addEventListener("abort", andorraOnAbort);
+        if (connectTimeoutMs > 0) {
+            timeout = setTimeout(() => {
+                andorraFail(new Error(`WebSocket connect timeout after ${connectTimeoutMs}ms`), "connect_timeout");
+            }, connectTimeoutMs);
+        }
+        if (signal?.aborted) {
+            andorraOnAbort();
+        }
+    });
+}
+async function andorraAcquireWebSocket(url, headers, sessionId, accountId, signal, connectTimeoutMs, env) {
+    if (!sessionId) {
+        const socket = await andorraConnectWebSocket(url, headers, signal, connectTimeoutMs, env);
+        return {
+            socket,
+            reused: false,
+            release: () => andorraCloseWebSocketSilently(socket),
+        };
+    }
+    let accountEntries = websocketSessionCache.get(sessionId);
+    const cached = accountEntries?.get(accountId);
+    if (cached) {
+        if (cached.idleTimer) {
+            clearTimeout(cached.idleTimer);
+            cached.idleTimer = undefined;
+        }
+        if (!cached.busy && andorraIsWebSocketSessionExpired(cached)) {
+            andorraCloseWebSocketSilently(cached.socket, 1000, "connection_age_limit");
+            accountEntries?.delete(accountId);
+            if (accountEntries?.size === 0)
+                websocketSessionCache.delete(sessionId);
+        }
+        else if (!cached.busy && andorraIsWebSocketReusable(cached.socket)) {
+            cached.busy = true;
+            return {
+                socket: cached.socket,
+                entry: cached,
+                reused: true,
+                release: ({ keep } = {}) => {
+                    if (!keep || !andorraIsWebSocketReusable(cached.socket)) {
+                        andorraCloseWebSocketSilently(cached.socket);
+                        const currentEntries = websocketSessionCache.get(sessionId);
+                        if (currentEntries?.get(accountId) === cached)
+                            currentEntries.delete(accountId);
+                        if (currentEntries?.size === 0)
+                            websocketSessionCache.delete(sessionId);
+                        return;
+                    }
+                    cached.busy = false;
+                    andorraScheduleSessionWebSocketExpiry(sessionId, accountId, cached);
+                },
+            };
+        }
+        if (cached.busy) {
+            const socket = await andorraConnectWebSocket(url, headers, signal, connectTimeoutMs, env);
+            return {
+                socket,
+                reused: false,
+                release: () => {
+                    andorraCloseWebSocketSilently(socket);
+                },
+            };
+        }
+        if (!andorraIsWebSocketReusable(cached.socket)) {
+            andorraCloseWebSocketSilently(cached.socket);
+            accountEntries?.delete(accountId);
+            if (accountEntries?.size === 0)
+                websocketSessionCache.delete(sessionId);
+        }
+    }
+    const socket = await andorraConnectWebSocket(url, headers, signal, connectTimeoutMs, env);
+    const entry = { socket, busy: true, createdAt: Date.now() };
+    accountEntries = websocketSessionCache.get(sessionId);
+    if (!accountEntries) {
+        accountEntries = new Map();
+        websocketSessionCache.set(sessionId, accountEntries);
+    }
+    accountEntries.set(accountId, entry);
+    return {
+        socket,
+        entry,
+        reused: false,
+        release: ({ keep } = {}) => {
+            if (!keep || !andorraIsWebSocketReusable(entry.socket)) {
+                andorraCloseWebSocketSilently(entry.socket);
+                if (entry.idleTimer)
+                    clearTimeout(entry.idleTimer);
+                const currentEntries = websocketSessionCache.get(sessionId);
+                if (currentEntries?.get(accountId) === entry)
+                    currentEntries.delete(accountId);
+                if (currentEntries?.size === 0)
+                    websocketSessionCache.delete(sessionId);
+                return;
+            }
+            entry.busy = false;
+            andorraScheduleSessionWebSocketExpiry(sessionId, accountId, entry);
+        },
+    };
+}
+function andorraExtractWebSocketError(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");
+}
+function andorraExtractWebSocketCloseError(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 AndorraWebSocketCloseError(`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");
+}
+async function andorraDecodeWebSocketData(data) {
+    if (typeof data === "string")
+        return data;
+    if (data instanceof ArrayBuffer) {
+        return new TextDecoder().decode(new Uint8Array(data));
+    }
+    if (ArrayBuffer.isView(data)) {
+        const view = data;
+        return new TextDecoder().decode(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+    }
+    if (data && typeof data === "object" && "arrayBuffer" in data) {
+        const blobLike = data;
+        const arrayBuffer = await blobLike.arrayBuffer();
+        return new TextDecoder().decode(new Uint8Array(arrayBuffer));
+    }
+    return null;
+}
+async function* andorraParseWebSocket(socket, signal, idleTimeoutMs) {
+    const queue = [];
+    let pending = null;
+    let done = false;
+    let failed = null;
+    let sawCompletion = false;
+    const andorraWake = () => {
+        if (!pending)
+            return;
+        const resolve = pending;
+        pending = null;
+        resolve();
+    };
+    const andorraOnMessage = (event) => {
+        void (async () => {
+            let text = null;
+            try {
+                if (!event || typeof event !== "object" || !("data" in event))
+                    return;
+                text = await andorraDecodeWebSocketData(event.data);
+                if (!text)
+                    return;
+                const parsed = JSON.parse(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);
+                andorraWake();
+            }
+            catch (cause) {
+                failed = new AndorraCodexProtocolError(`Invalid Codex WebSocket JSON: ${andorraFormatThrownValue(cause)}`, {
+                    cause,
+                    payload: text,
+                });
+                done = true;
+                andorraWake();
+            }
+        })();
+    };
+    const andorraOnError = (event) => {
+        failed = andorraExtractWebSocketError(event);
+        done = true;
+        andorraWake();
+    };
+    const andorraOnClose = (event) => {
+        if (sawCompletion) {
+            done = true;
+            andorraWake();
+            return;
+        }
+        if (!failed) {
+            failed = andorraExtractWebSocketCloseError(event);
+        }
+        done = true;
+        andorraWake();
+    };
+    const andorraOnAbort = () => {
+        failed = new Error("Request was aborted");
+        done = true;
+        andorraWake();
+    };
+    socket.addEventListener("message", andorraOnMessage);
+    socket.addEventListener("error", andorraOnError);
+    socket.addEventListener("close", andorraOnClose);
+    signal?.addEventListener("abort", andorraOnAbort);
+    try {
+        while (true) {
+            if (signal?.aborted) {
+                throw new Error("Request was aborted");
+            }
+            if (queue.length > 0) {
+                yield queue.shift();
+                continue;
+            }
+            if (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;
+                        andorraCloseWebSocketSilently(socket, 1000, "idle_timeout");
+                        reject(error);
+                    }, idleTimeoutMs);
+                }
+            }).finally(() => {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+            });
+        }
+        if (failed) {
+            throw failed;
+        }
+        if (!sawCompletion) {
+            throw new Error("WebSocket stream closed before response.completed");
+        }
+    }
+    finally {
+        socket.removeEventListener("message", andorraOnMessage);
+        socket.removeEventListener("error", andorraOnError);
+        socket.removeEventListener("close", andorraOnClose);
+        signal?.removeEventListener("abort", andorraOnAbort);
+    }
+}
+function andorraRequestBodyWithoutInput(body) {
+    const { input: _input, previous_response_id: _previousResponseId, ...rest } = body;
+    return rest;
+}
+function andorraResponseInputsEqual(a, b) {
+    return JSON.stringify(a ?? []) === JSON.stringify(b ?? []);
+}
+function andorraRequestBodiesMatchExceptInput(a, b) {
+    return JSON.stringify(andorraRequestBodyWithoutInput(a)) === JSON.stringify(andorraRequestBodyWithoutInput(b));
+}
+function andorraGetCachedWebSocketInputDelta(body, continuation) {
+    if (!andorraRequestBodiesMatchExceptInput(body, continuation.lastRequestBody)) {
+        return undefined;
+    }
+    const currentInput = body.input ?? [];
+    const baseline = [...(continuation.lastRequestBody.input ?? []), ...continuation.lastResponseItems];
+    if (currentInput.length < baseline.length) {
+        return undefined;
+    }
+    const prefix = currentInput.slice(0, baseline.length);
+    if (!andorraResponseInputsEqual(prefix, baseline)) {
+        return undefined;
+    }
+    return currentInput.slice(baseline.length);
+}
+function andorraBuildCachedWebSocketRequestBody(entry, body) {
+    const continuation = entry.continuation;
+    if (!continuation) {
+        return body;
+    }
+    const delta = andorraGetCachedWebSocketInputDelta(body, continuation);
+    if (!delta || !continuation.lastResponseId) {
+        entry.continuation = undefined;
+        return body;
+    }
+    return {
+        ...body,
+        previous_response_id: continuation.lastResponseId,
+        input: delta,
+    };
+}
+async function* andorraStartWebSocketOutputOnFirstEvent(events, onStart) {
+    let started = false;
+    for await (const event of events) {
+        if (!started) {
+            started = true;
+            onStart();
+        }
+        yield event;
+    }
+}
+async function andorraProcessWebSocketStream(url, body, headers, output, stream, model, onStart, idleTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, accountId, grammarToolInputProperties, options) {
+    const { socket, entry, reused, release } = await andorraAcquireWebSocket(url, headers, cacheSessionId, accountId, options?.signal, websocketConnectTimeoutMs, options?.env);
+    let keepConnection = true;
+    const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
+    // ChatGPT Codex Responses rejects `store: true` ("Store must be set to false").
+    // WebSocket continuation still works via connection-scoped previous_response_id state.
+    const fullBody = body;
+    const requestBody = useCachedContext && entry ? andorraBuildCachedWebSocketRequestBody(entry, fullBody) : fullBody;
+    const stats = cacheSessionId ? andorraGetOrCreateWebSocketDebugStats(cacheSessionId) : 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;
+        }
+    }
+    try {
+        socket.send(JSON.stringify({ type: "response.create", ...requestBody }));
+        await andorraProcessResponsesStream(andorraStartWebSocketOutputOnFirstEvent(andorraMapCodexEvents(andorraParseWebSocket(socket, options?.signal, idleTimeoutMs), output), onStart), output, stream, model, {
+            serviceTier: options?.serviceTier,
+            grammarToolInputProperties,
+            resolveServiceTier: andorraResolveCodexServiceTier,
+            applyServiceTierPricing: (usage, serviceTier) => andorraApplyServiceTierPricing(usage, serviceTier, model),
+        });
+        if (options?.signal?.aborted) {
+            keepConnection = false;
+        }
+        else if (useCachedContext && entry && output.responseId) {
+            const responseItems = andorraConvertResponsesMessages(model, andorraNormalizeContext({ messages: [output] }), CODEX_TOOL_CALL_PROVIDERS, {
+                includeSystemPrompt: false,
+                grammarToolInputProperties,
+            }).filter((item) => item.type !== "function_call_output" && item.type !== "custom_tool_call_output");
+            entry.continuation = {
+                lastRequestBody: fullBody,
+                lastResponseId: output.responseId,
+                lastResponseItems: responseItems,
+            };
+        }
+    }
+    catch (error) {
+        if (entry) {
+            entry.continuation = undefined;
+        }
+        keepConnection = false;
+        throw error;
+    }
+    finally {
+        release({ keep: keepConnection });
+    }
+}
+// ============================================================================
+// Error Handling
+// ============================================================================
+async function andorraParseErrorResponse(response) {
+    const raw = await response.text();
+    let message = raw || response.statusText || "Request failed";
+    let friendlyMessage;
+    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;
+        }
+    }
+    catch { }
+    return { message, friendlyMessage };
+}
+// ============================================================================
+// Auth & Headers
+// ============================================================================
+function andorraExtractAccountId(token) {
+    try {
+        const parts = token.split(".");
+        if (parts.length !== 3)
+            throw new Error("Invalid token");
+        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;
+    }
+    catch {
+        throw new Error("Failed to extract accountId from token");
+    }
+}
+function andorraBuildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token) {
+    const headers = new Headers(initHeaders);
+    for (const [key, value] of Object.entries(additionalHeaders || {})) {
+        if (value === null) {
+            headers.delete(key);
+        }
+        else {
+            headers.set(key, value);
+        }
+    }
+    headers.set("Authorization", `Bearer ${token}`);
+    headers.set("chatgpt-account-id", accountId);
+    headers.set("originator", "andorra");
+    headers.set("User-Agent", andorraGetAndorraUserAgent());
+    return headers;
+}
+function andorraBuildSSEHeaders(initHeaders, additionalHeaders, accountId, token, sessionId) {
+    const headers = andorraBuildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token);
+    headers.set("OpenAI-Beta", "responses=experimental");
+    headers.set("accept", "text/event-stream");
+    headers.set("content-type", "application/json");
+    if (sessionId) {
+        headers.set("session-id", sessionId);
+        headers.set("x-client-request-id", sessionId);
+    }
+    return headers;
+}
+function andorraBuildWebSocketHeaders(initHeaders, additionalHeaders, accountId, token, requestId) {
+    const headers = andorraBuildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token);
+    headers.delete("accept");
+    headers.delete("content-type");
+    headers.delete("OpenAI-Beta");
+    headers.delete("openai-beta");
+    headers.set("OpenAI-Beta", OPENAI_BETA_RESPONSES_WEBSOCKETS);
+    headers.set("x-client-request-id", requestId);
+    headers.set("session-id", requestId);
+    return headers;
+}