@raybase/openai-subscription 0.0.2 → 0.1.0

package/dist/transport.js

@@ -0,0 +1,1115 @@
+import { RaybaseInferenceProviderError } from "@raybase/core";
+const authOrigin = "https://auth.openai.com";
+const codexOrigin = "https://chatgpt.com";
+const localRelaySecretHeader = "x-raybase-local-codex-relay-secret";
+const clientId = "app_EMoamEEZ73f0CkXaXp7hrann";
+/**
+ * The complete set of headers the module authors on an outbound request.
+ *
+ * chatgpt.com is itself behind Cloudflare, and its front door refuses any
+ * request carrying Cloudflare's own hop metadata — `cf-worker`, which workerd
+ * stamps on every outbound subrequest, and `cf-connecting-ip`/`cf-visitor`. It
+ * answers `403` with an HTML blocked page before the Codex API is reached, so
+ * no `x-oai-request-id` ever exists. `raybase dev`'s relay strips that class of
+ * header at its own boundary, but the deployed `cloudflare-vpc` lane hands the
+ * request straight to `binding.fetch()` with no boundary of its own. Pinning
+ * the header set here gives every egress strategy the same guarantee.
+ *
+ * This is not a fingerprint disguise: the module still identifies itself with
+ * `originator: raybase_openai_subscription`. It is the removal of intermediary
+ * metadata the module never authored, in the same spirit as dropping `host`.
+ *
+ * Residual risk this cannot cover: anything the runtime appends after `fetch()`
+ * leaves the module's hands. Only one real turn through `CODEX_EGRESS` on a
+ * deployed Worker can rule that out — see README "Live Worker verification".
+ */
+const outboundHeaderAllowlist = new Set([
+    "content-type",
+    "authorization",
+    "chatgpt-account-id",
+    "originator",
+    "accept"
+]);
+const maxJsonBytes = 256 * 1024;
+const maxSseBytes = 4 * 1024 * 1024;
+const maxSseEventBytes = 256 * 1024;
+const codex400JsonShapeErrorCodes = new Set([
+    "protocol:invalid_json",
+    "protocol:json_size_limit",
+    "protocol:expected_object"
+]);
+export class OpenAISubscriptionTransportHttpError extends Error {
+    status;
+    code;
+    retryAt;
+    contentType;
+    cfRay;
+    oaiRequestId;
+    param;
+    constructor(status, code, retryAt, contentType, cfRay, oaiRequestId, 
+    /**
+     * The upstream `error.param` when it names a structural part of the request
+     * the app itself controls — `tools[7].parameters.draft`. It is the app's own
+     * schema path, never user or account data, and it is the difference between
+     * "one of your tools is wrong" and knowing which one.
+     */
+    param) {
+        super(`OpenAI subscription transport failed (${status})`);
+        this.status = status;
+        this.code = code;
+        this.retryAt = retryAt;
+        this.contentType = contentType;
+        this.cfRay = cfRay;
+        this.oaiRequestId = oaiRequestId;
+        this.param = param;
+        this.name = "OpenAISubscriptionTransportHttpError";
+    }
+}
+export class OpenAISubscriptionCodexRequestError extends RaybaseInferenceProviderError {
+    status = 400;
+    contentType;
+    oaiRequestId;
+    constructor(token, metadata = {}) {
+        super({
+            code: `protocol:codex_400_${token}`,
+            message: "The OpenAI subscription request was rejected."
+        });
+        this.name = "OpenAISubscriptionCodexRequestError";
+        this.contentType = metadata.contentType;
+        this.oaiRequestId = metadata.oaiRequestId;
+    }
+}
+export class OpenAISubscriptionTransportProtocolError extends RaybaseInferenceProviderError {
+    status;
+    contentType;
+    cfRayPresent;
+    redirected;
+    oaiRequestId;
+    constructor(fingerprint, metadata = {}) {
+        super({
+            code: `protocol:${fingerprint}`,
+            health: "protocol_update_required",
+            actionHref: "/admin/openai-subscription",
+            message: "The OpenAI subscription protocol changed. Update the Raybase module."
+        });
+        this.name = "OpenAISubscriptionTransportProtocolError";
+        this.status = metadata.status;
+        this.contentType = metadata.contentType;
+        this.cfRayPresent = metadata.cfRayPresent;
+        this.redirected = metadata.redirected;
+        this.oaiRequestId = metadata.oaiRequestId;
+    }
+}
+export class CodexSubscriptionTransport {
+    #authFetch;
+    #codexFetch;
+    #now;
+    #authOrigin;
+    #codexOrigin;
+    #requestTimeoutMs;
+    constructor(options = {}) {
+        const sharedFetch = options.fetch ?? fetch;
+        this.#authFetch = options.authFetch ?? sharedFetch;
+        this.#codexFetch = options.codexFetch ?? sharedFetch;
+        this.#now = options.now ?? (() => new Date());
+        this.#authOrigin = normalizeOrigin(options.endpoints?.authOrigin ?? authOrigin, "auth origin");
+        this.#codexOrigin = normalizeOrigin(options.endpoints?.codexOrigin ?? codexOrigin, "Codex origin");
+        this.#requestTimeoutMs = options.requestTimeoutMs ?? 45_000;
+        if (!Number.isFinite(this.#requestTimeoutMs) || this.#requestTimeoutMs <= 0) {
+            throw new Error("OpenAI subscription request timeout must be positive");
+        }
+    }
+    async startDeviceAuth(signal) {
+        const payload = await this.#json(endpoint(this.#authOrigin, "/api/accounts/deviceauth/usercode"), { client_id: clientId }, {}, signal);
+        const deviceAuthId = requiredString(payload, "device_auth_id");
+        const userCode = requiredString(payload, "user_code");
+        const intervalSeconds = boundedInteger(payload.interval, 1, 60, "device interval");
+        return {
+            deviceAuthId,
+            userCode,
+            verificationUrl: endpoint(this.#authOrigin, "/codex/device"),
+            intervalSeconds,
+            expiresAt: new Date(this.#now().getTime() + 15 * 60_000).toISOString()
+        };
+    }
+    async pollDeviceAuth(deviceAuthId, userCode, intervalSeconds, signal) {
+        const request = await this.#request(endpoint(this.#authOrigin, "/api/accounts/deviceauth/token"), { device_auth_id: deviceAuthId, user_code: userCode }, {}, signal);
+        try {
+            if (request.response.status === 403 || request.response.status === 404) {
+                return { status: "pending", intervalSeconds };
+            }
+            if (request.response.status === 429) {
+                return { status: "pending", intervalSeconds: Math.min(intervalSeconds + 5, 60) };
+            }
+            if (!request.response.ok)
+                throw statusError(request.response);
+            const payload = await strictJsonResponse(request.response, request.signal);
+            return {
+                status: "authorized",
+                authorizationCode: requiredString(payload, "authorization_code"),
+                codeVerifier: requiredString(payload, "code_verifier"),
+                codeChallenge: requiredString(payload, "code_challenge")
+            };
+        }
+        finally {
+            request.cleanup();
+        }
+    }
+    async exchangeDeviceCode(result, signal) {
+        return this.#tokenRequest({
+            grant_type: "authorization_code",
+            client_id: clientId,
+            code: result.authorizationCode,
+            code_verifier: result.codeVerifier,
+            redirect_uri: endpoint(this.#authOrigin, "/deviceauth/callback")
+        }, signal);
+    }
+    async refresh(refreshToken, signal) {
+        return this.#tokenRequest({
+            grant_type: "refresh_token",
+            client_id: clientId,
+            refresh_token: refreshToken
+        }, signal);
+    }
+    async chat(tokens, input, signal) {
+        let text = "";
+        const toolCalls = [];
+        let result = {};
+        for await (const event of await this.chatStream(tokens, input, signal)) {
+            if (event.type === "text-delta")
+                text += event.text;
+            if (event.type === "tool-call")
+                toolCalls.push(event.toolCall);
+            if (event.type === "done")
+                result = event.result ?? {};
+        }
+        return {
+            text: typeof result.text === "string" ? result.text : text,
+            toolCalls: result.toolCalls ?? toolCalls,
+            finishReason: result.finishReason ?? "stop",
+            usage: result.usage,
+            provider: result.provider
+        };
+    }
+    async chatStream(tokens, input, signal) {
+        const request = await this.#streamRequest(endpoint(this.#codexOrigin, "/backend-api/codex/responses"), toResponsesRequest(input), {
+            authorization: `Bearer ${tokens.accessToken}`,
+            ...(tokens.accountId ? { "chatgpt-account-id": tokens.accountId } : {}),
+            originator: "raybase_openai_subscription",
+            accept: "text/event-stream"
+        }, signal);
+        if (!request.response.ok) {
+            try {
+                throw await codexStatusError(request.response, request.signal);
+            }
+            finally {
+                void request.response.body?.cancel().catch(() => undefined);
+                request.cleanup();
+            }
+        }
+        const contentType = normalizedContentType(request.response);
+        if (contentType && contentType !== "text/event-stream") {
+            void request.response.body?.cancel().catch(() => undefined);
+            request.cleanup();
+            throw protocolError("unexpected_sse_content_type", {
+                status: request.response.status,
+                contentType,
+                cfRayPresent: Boolean(request.response.headers.get("cf-ray")?.trim()),
+                redirected: request.response.redirected
+            });
+        }
+        if (!request.response.body) {
+            request.cleanup();
+            throw protocolError("missing_sse_body");
+        }
+        return parseResponsesSse(request.response.body, request.signal, request.cleanup);
+    }
+    async #tokenRequest(body, signal) {
+        const request = await this.#request(endpoint(this.#authOrigin, "/oauth/token"), body, {}, signal);
+        try {
+            if (!request.response.ok) {
+                if (request.response.status === 400) {
+                    const payload = await strictJsonResponse(request.response, request.signal);
+                    if (payload.error === "invalid_grant") {
+                        throw new OpenAISubscriptionTransportHttpError(400, "invalid_grant");
+                    }
+                }
+                throw statusError(request.response);
+            }
+            const payload = await strictJsonResponse(request.response, request.signal);
+            const accessToken = requiredString(payload, "access_token");
+            const refreshToken = typeof payload.refresh_token === "string" && payload.refresh_token
+                ? payload.refresh_token
+                : body.refresh_token;
+            if (!refreshToken)
+                throw protocolError("missing_refresh_token");
+            const expiresIn = boundedInteger(payload.expires_in, 60, 31_536_000, "token expiry");
+            const idToken = typeof payload.id_token === "string" ? payload.id_token : undefined;
+            const claims = idToken ? decodeJwtPayload(idToken) : {};
+            return {
+                accessToken,
+                refreshToken,
+                ...(idToken ? { idToken } : {}),
+                expiresAt: new Date(this.#now().getTime() + expiresIn * 1000).toISOString(),
+                ...safeIdentityProjection(claims)
+            };
+        }
+        finally {
+            request.cleanup();
+        }
+    }
+    async #json(url, body, headers, signal) {
+        const request = await this.#request(url, body, headers, signal);
+        try {
+            if (!request.response.ok)
+                throw statusError(request.response);
+            return await strictJsonResponse(request.response, request.signal);
+        }
+        finally {
+            request.cleanup();
+        }
+    }
+    async #request(url, body, headers, signal) {
+        const request = this.#requestContext(signal);
+        try {
+            return {
+                response: await this.#performRequest(url, body, headers, request.controller.signal),
+                signal: request.controller.signal,
+                cleanup: request.cleanup
+            };
+        }
+        catch (error) {
+            request.cleanup();
+            throw requestError(error, request.controller.signal);
+        }
+    }
+    async #streamRequest(url, body, headers, signal) {
+        const request = this.#requestContext(signal);
+        try {
+            return {
+                response: await this.#performRequest(url, body, headers, request.controller.signal),
+                signal: request.controller.signal,
+                cleanup: request.cleanup
+            };
+        }
+        catch (error) {
+            request.cleanup();
+            throw requestError(error, request.controller.signal);
+        }
+    }
+    async #performRequest(url, body, headers, signal) {
+        const parsed = new URL(url);
+        const destination = assertAllowedUrl(parsed, this.#authOrigin, this.#codexOrigin, "POST");
+        const selectedFetch = destination === "auth" ? this.#authFetch : this.#codexFetch;
+        return selectedFetch(parsed, {
+            method: "POST",
+            redirect: "manual",
+            headers: allowlistedOutboundHeaders({
+                "content-type": "application/json",
+                ...headers
+            }),
+            body: JSON.stringify(body),
+            signal
+        });
+    }
+    #requestContext(signal) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.#requestTimeoutMs);
+        const abort = () => controller.abort();
+        if (signal?.aborted)
+            controller.abort();
+        else
+            signal?.addEventListener("abort", abort, { once: true });
+        let cleaned = false;
+        return {
+            controller,
+            cleanup: () => {
+                if (cleaned)
+                    return;
+                cleaned = true;
+                clearTimeout(timer);
+                signal?.removeEventListener("abort", abort);
+            }
+        };
+    }
+}
+export function createOpenAISubscriptionTransport(options, env) {
+    return createOpenAISubscriptionTransportInternal(options, env);
+}
+export function createOpenAISubscriptionTransportInternal(options, env, testingOptions) {
+    if (testingOptions)
+        return new CodexSubscriptionTransport(testingOptions);
+    if (!options.codexEgress || options.codexEgress.strategy === "direct") {
+        return new CodexSubscriptionTransport();
+    }
+    if (options.codexEgress.strategy === "local-relay") {
+        return new CodexSubscriptionTransport({
+            codexFetch: localRelayFetch(env)
+        });
+    }
+    const candidate = env[options.codexEgress.binding];
+    if (!candidate || typeof candidate !== "object" || typeof candidate.fetch !== "function") {
+        throw new RaybaseInferenceProviderError({
+            code: "codex_egress_binding_missing",
+            health: "disconnected",
+            actionHref: "/admin/openai-subscription",
+            message: "The configured OpenAI subscription Codex egress binding is unavailable."
+        });
+    }
+    const fetcher = candidate;
+    return new CodexSubscriptionTransport({
+        codexFetch: (input, init) => fetcher.fetch(input, init)
+    });
+}
+function localRelayFetch(env) {
+    if (env.RAYBASE_ENV !== "local") {
+        throw new RaybaseInferenceProviderError({
+            code: "codex_local_relay_not_local",
+            health: "disconnected",
+            actionHref: "/admin/openai-subscription",
+            message: "OpenAI subscription local-relay egress is available only under raybase dev. Use cloudflare-vpc for deploy targets."
+        });
+    }
+    const relayOrigin = normalizeLocalRelayOrigin(env.RAYBASE_LOCAL_CODEX_RELAY_URL);
+    const relaySecret = env.RAYBASE_LOCAL_CODEX_RELAY_SECRET?.trim();
+    if (!relayOrigin || !relaySecret || !/^[A-Za-z0-9_-]{43,}$/.test(relaySecret)) {
+        throw new RaybaseInferenceProviderError({
+            code: "codex_local_relay_unavailable",
+            health: "disconnected",
+            actionHref: "/admin/openai-subscription",
+            message: "The raybase dev Codex relay is unavailable. Restart raybase dev."
+        });
+    }
+    return (input, init) => {
+        const target = requestUrl(input);
+        if (target.origin !== codexOrigin || target.pathname !== "/backend-api/codex/responses" || target.search || target.hash) {
+            throw new Error("OpenAI subscription local relay target is not allowlisted");
+        }
+        const headers = new Headers(init?.headers);
+        headers.set(localRelaySecretHeader, relaySecret);
+        return fetch(new URL(target.pathname, relayOrigin), { ...init, headers, redirect: "manual" });
+    };
+}
+function normalizeLocalRelayOrigin(value) {
+    if (!value)
+        return null;
+    try {
+        const parsed = new URL(value);
+        if (parsed.protocol !== "http:" ||
+            parsed.hostname !== "127.0.0.1" ||
+            !parsed.port ||
+            parsed.username ||
+            parsed.password ||
+            parsed.pathname !== "/" ||
+            parsed.search ||
+            parsed.hash)
+            return null;
+        return parsed.origin;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Drops rather than throws: an unexpected header is a module-side mistake that
+ * tests catch, and a live subscription lane should not fail closed over one.
+ * Any header the module genuinely needs must be added to the allowlist above.
+ */
+export function allowlistedOutboundHeaders(source) {
+    const headers = {};
+    for (const [name, value] of Object.entries(source)) {
+        if (!outboundHeaderAllowlist.has(name.toLowerCase()))
+            continue;
+        headers[name] = value;
+    }
+    return headers;
+}
+function requestUrl(input) {
+    if (input instanceof URL)
+        return input;
+    if (typeof input === "string")
+        return new URL(input);
+    return new URL(input.url);
+}
+function requestError(error, signal) {
+    if (signal.aborted) {
+        return new RaybaseInferenceProviderError({
+            code: "aborted",
+            message: "OpenAI subscription request was cancelled."
+        });
+    }
+    if (error instanceof RaybaseInferenceProviderError)
+        return error;
+    return new RaybaseInferenceProviderError({ code: "transport_error" });
+}
+async function readStreamChunk(reader, signal) {
+    if (!signal)
+        return reader.read();
+    if (signal.aborted)
+        throw requestError(undefined, signal);
+    let onAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        onAbort = () => {
+            reject(requestError(undefined, signal));
+            void reader.cancel().catch(() => undefined);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+        return await Promise.race([reader.read(), aborted]);
+    }
+    finally {
+        if (onAbort)
+            signal.removeEventListener("abort", onAbort);
+    }
+}
+export function toResponsesRequest(input) {
+    validateChatRequest(input);
+    const instructions = input.messages
+        .filter((message) => message.role === "system")
+        .map((message) => message.content)
+        .join("\n\n");
+    const messages = input.messages
+        .filter((message) => message.role !== "system")
+        .flatMap((message) => {
+        if (message.role === "tool") {
+            return [{ type: "function_call_output", call_id: message.toolCallId, output: message.content }];
+        }
+        const content = message.role === "user"
+            ? (typeof message.content === "string"
+                ? [{ type: "input_text", text: message.content }]
+                : message.content.map(toResponsesUserContentPart))
+            : [{ type: "output_text", text: message.content }];
+        return [
+            { role: message.role, content },
+            ...(message.role === "assistant"
+                ? (message.toolCalls ?? []).map((call) => ({
+                    type: "function_call",
+                    call_id: call.id,
+                    name: call.name,
+                    arguments: JSON.stringify(call.arguments ?? {})
+                }))
+                : [])
+        ];
+    });
+    return {
+        model: input.model,
+        instructions,
+        input: messages,
+        tools: (input.tools ?? []).map((tool) => ({
+            type: "function",
+            name: tool.name,
+            description: tool.description ?? "",
+            parameters: tool.parameters ?? { type: "object", properties: {} },
+            strict: true
+        })),
+        tool_choice: input.tools?.length ? "auto" : "none",
+        parallel_tool_calls: true,
+        stream: true,
+        store: false,
+        ...(input.responseFormat ? { text: { format: responseFormat(input.responseFormat) } } : {})
+    };
+}
+/**
+ * Verified against the private Codex Responses endpoint on 2026-08-11:
+ * `input_image.image_url` accepts HTTPS/data URIs and PNG, JPEG, WEBP, and
+ * non-animated GIF. Omitted/auto/low/high/original `detail` completed;
+ * `quality` was rejected. Valid PNG requests completed through 19,573,864
+ * encoded request bytes, a lower bound rather than an endpoint limit. See the
+ * compatibility note; Raybase deliberately omits both knobs.
+ */
+function toResponsesUserContentPart(part) {
+    if (part.type === "text")
+        return { type: "input_text", text: part.text };
+    if (part.type === "image") {
+        return { type: "input_image", image_url: `data:${part.mediaType};base64,${part.data}` };
+    }
+    return { type: "input_image", image_url: part.url };
+}
+export async function* parseResponsesSse(body, signal, cleanup = () => undefined) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let buffered = "";
+    let total = 0;
+    let completed = false;
+    const toolArguments = new Map();
+    try {
+        while (true) {
+            if (signal?.aborted)
+                throw new RaybaseInferenceProviderError({ code: "aborted", message: "OpenAI subscription stream was cancelled." });
+            const { done, value } = await readStreamChunk(reader, signal);
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > maxSseBytes)
+                throw protocolError("sse_size_limit");
+            buffered += decoder.decode(value, { stream: true });
+            let boundary;
+            while ((boundary = buffered.search(/\r?\n\r?\n/)) >= 0) {
+                const raw = buffered.slice(0, boundary);
+                const match = buffered.slice(boundary).match(/^\r?\n\r?\n/);
+                buffered = buffered.slice(boundary + (match?.[0].length ?? 2));
+                if (raw.length > maxSseEventBytes)
+                    throw protocolError("sse_event_size_limit");
+                const parsed = parseSseEvent(raw);
+                if (!parsed)
+                    continue;
+                const event = parseEventJson(parsed.data);
+                const kind = requiredString(event, "type");
+                if (kind === "response.created" || kind === "response.in_progress")
+                    continue;
+                if (kind === "response.output_item.added") {
+                    const item = record(event.item);
+                    if (!["message", "reasoning", "function_call"].includes(requiredString(item, "type"))) {
+                        throw protocolError("unknown_output_item");
+                    }
+                    continue;
+                }
+                if (kind === "response.output_text.delta") {
+                    yield { type: "text-delta", text: requiredString(event, "delta", true) };
+                    continue;
+                }
+                if (kind === "response.function_call_arguments.delta") {
+                    const id = optionalString(event.call_id) ?? optionalString(event.item_id);
+                    if (!id)
+                        throw protocolError("missing_tool_call_id");
+                    const current = toolArguments.get(id) ?? { name: optionalString(event.name) ?? "", value: "" };
+                    current.value += requiredString(event, "delta", true);
+                    if (current.value.length > maxSseEventBytes)
+                        throw protocolError("tool_arguments_size_limit");
+                    toolArguments.set(id, current);
+                    continue;
+                }
+                if (kind === "response.output_item.done") {
+                    const item = record(event.item);
+                    if (item.type === "message" || item.type === "reasoning")
+                        continue;
+                    if (item.type !== "function_call")
+                        throw protocolError("unknown_output_item");
+                    const id = optionalString(item.call_id) ?? optionalString(item.id);
+                    const name = optionalString(item.name);
+                    if (!id || !name)
+                        throw protocolError("malformed_tool_call");
+                    const rawArguments = optionalString(item.arguments) ?? toolArguments.get(id)?.value ?? "{}";
+                    let args;
+                    try {
+                        args = JSON.parse(rawArguments);
+                    }
+                    catch {
+                        throw protocolError("invalid_tool_arguments");
+                    }
+                    yield { type: "tool-call", toolCall: { id, name, arguments: args } };
+                    continue;
+                }
+                if (kind === "response.completed") {
+                    const response = record(event.response);
+                    const usage = record(response.usage);
+                    const incompleteDetails = response.incomplete_details && typeof response.incomplete_details === "object"
+                        ? record(response.incomplete_details)
+                        : {};
+                    completed = true;
+                    yield {
+                        type: "done",
+                        result: {
+                            finishReason: incompleteDetails.reason === "max_output_tokens" ? "length" : "stop",
+                            usage: {
+                                inputTokens: optionalNonNegativeInteger(usage.input_tokens),
+                                outputTokens: optionalNonNegativeInteger(usage.output_tokens)
+                            },
+                            provider: {
+                                id: "openai-codex-subscription",
+                                requestId: optionalString(response.id)
+                            }
+                        }
+                    };
+                    continue;
+                }
+                if (kind === "response.failed" || kind === "error") {
+                    throw upstreamFailedError(event);
+                }
+                if (kind === "response.reasoning_summary_text.delta"
+                    || kind === "response.reasoning_summary_part.added"
+                    || kind === "response.reasoning_summary_text.done"
+                    || kind === "response.content_part.added"
+                    || kind === "response.content_part.done"
+                    || kind === "response.output_text.done"
+                    // The terminator for a tool call's streamed arguments. It repeats
+                    // what the deltas already accumulated, and `response.output_item.done`
+                    // carries the authoritative `item.arguments`, so there is nothing to
+                    // read here. Without this branch every tool-using turn dies on a
+                    // complete, successful HTTP 200 stream.
+                    || kind === "response.function_call_arguments.done")
+                    continue;
+                throw protocolError("unknown_event");
+            }
+        }
+        buffered += decoder.decode();
+        if (buffered.trim())
+            throw protocolError("unterminated_sse_event");
+        if (!completed)
+            throw protocolError("stream_ended_without_completion");
+    }
+    catch (error) {
+        if (error instanceof RaybaseInferenceProviderError)
+            throw error;
+        throw protocolError("invalid_sse");
+    }
+    finally {
+        cleanup();
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // An abort-driven cancel may still be settling; cleanup has already run.
+        }
+    }
+}
+function validateChatRequest(input) {
+    if (!input.model.trim())
+        throw protocolError("missing_model");
+    if (!input.messages.length)
+        throw protocolError("missing_messages");
+    const callIds = new Set();
+    for (const [index, message] of input.messages.entries()) {
+        if (!message || typeof message !== "object" || !["system", "user", "assistant", "tool"].includes(message.role)) {
+            throw protocolError("invalid_message_role");
+        }
+        if (message.role === "user") {
+            if (typeof message.content !== "string")
+                validateUserContentParts(message.content);
+        }
+        else if (typeof message.content !== "string") {
+            throw callerContentError("invalid_message_content", `OpenAI subscription ${message.role} message content must be a string.`);
+        }
+        if (message.role === "system" && index > 0 && input.messages[index - 1]?.role !== "system") {
+            throw protocolError("system_message_order");
+        }
+        if (message.role === "assistant") {
+            for (const call of message.toolCalls ?? []) {
+                if (!call.id || callIds.has(call.id) || !/^[A-Za-z_][A-Za-z0-9_-]{0,63}$/.test(call.name)) {
+                    throw protocolError("invalid_tool_call");
+                }
+                callIds.add(call.id);
+                try {
+                    JSON.stringify(call.arguments ?? {});
+                }
+                catch {
+                    throw protocolError("invalid_tool_arguments");
+                }
+            }
+        }
+        if (message.role === "tool" && (!message.toolCallId || !callIds.has(message.toolCallId))) {
+            throw protocolError("orphan_tool_result");
+        }
+    }
+    const names = new Set();
+    for (const tool of input.tools ?? []) {
+        if (!/^[A-Za-z_][A-Za-z0-9_-]{0,63}$/.test(tool.name) || names.has(tool.name))
+            throw protocolError("invalid_tool_name");
+        names.add(tool.name);
+        if (tool.parameters !== undefined && (!tool.parameters || typeof tool.parameters !== "object" || Array.isArray(tool.parameters))) {
+            throw protocolError("invalid_tool_schema");
+        }
+    }
+    if (input.responseFormat?.type === "json_schema") {
+        if (!/^[A-Za-z_][A-Za-z0-9_-]{0,63}$/.test(input.responseFormat.name)) {
+            throw protocolError("invalid_response_schema_name");
+        }
+        if (!input.responseFormat.schema || typeof input.responseFormat.schema !== "object" || Array.isArray(input.responseFormat.schema)) {
+            throw protocolError("invalid_response_schema");
+        }
+    }
+}
+const supportedImageMediaTypes = new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
+const supportedUserContentKinds = ["text", "image", "image_url"];
+function validateUserContentParts(content) {
+    if (!Array.isArray(content)) {
+        throw callerContentError("invalid_message_content", "OpenAI subscription user message content must be a string or an array of content parts.");
+    }
+    for (const part of content)
+        validateUserContentPart(part);
+}
+function validateUserContentPart(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw callerContentError("invalid_message_content", "OpenAI subscription user content parts must be objects with a string type.");
+    }
+    const part = value;
+    if (typeof part.type !== "string" || !part.type) {
+        throw callerContentError("invalid_message_content", "OpenAI subscription user content parts must have a non-empty string type.");
+    }
+    if (!supportedUserContentKinds.includes(part.type)) {
+        throw callerContentError("unsupported_message_content", `OpenAI subscription does not support user content part "${part.type}"; supported kinds: ${supportedUserContentKinds.join(", ")}.`);
+    }
+    if (part.type === "text") {
+        assertExactContentFields(part, ["type", "text"]);
+        if (typeof part.text !== "string") {
+            throw callerContentError("invalid_message_content", "OpenAI subscription text content requires a string text field.");
+        }
+        return;
+    }
+    if (part.type === "image") {
+        assertExactContentFields(part, ["type", "mediaType", "data"]);
+        const mediaType = validateImageMediaType(part.mediaType, "image mediaType");
+        if (typeof part.data !== "string" || !isStandardBase64(part.data)) {
+            const suffix = typeof part.data === "string" && /[-_]/.test(part.data)
+                ? " URL-safe base64 is not supported; normalize it to standard base64 first."
+                : "";
+            throw callerContentError("invalid_message_content", `OpenAI subscription inline ${mediaType} image data must be non-empty standard base64.${suffix}`);
+        }
+        return;
+    }
+    assertExactContentFields(part, ["type", "url", "mediaType"]);
+    if (part.mediaType !== undefined)
+        validateImageMediaType(part.mediaType, "image_url mediaType");
+    if (typeof part.url !== "string" || !part.url) {
+        throw callerContentError("invalid_message_content", "OpenAI subscription image_url content requires a non-empty URL string.");
+    }
+    const dataUri = parseImageDataUri(part.url);
+    if (dataUri) {
+        if (part.mediaType !== undefined && part.mediaType !== dataUri.mediaType) {
+            throw callerContentError("invalid_message_content", `OpenAI subscription image_url mediaType "${part.mediaType}" does not match data URI media type "${dataUri.mediaType}".`);
+        }
+        if (!isStandardBase64(dataUri.data)) {
+            const suffix = /[-_]/.test(dataUri.data)
+                ? " URL-safe base64 is not supported; normalize it to standard base64 first."
+                : "";
+            throw callerContentError("invalid_message_content", `OpenAI subscription ${dataUri.mediaType} data URI must contain non-empty standard base64.${suffix}`);
+        }
+        return;
+    }
+    let url;
+    try {
+        url = new URL(part.url);
+    }
+    catch {
+        throw callerContentError("invalid_message_content", "OpenAI subscription image_url must be an absolute HTTPS URL or a supported image data URI.");
+    }
+    if (url.protocol !== "https:" || url.username || url.password) {
+        throw callerContentError("invalid_message_content", "OpenAI subscription image_url must be an absolute HTTPS URL without embedded credentials or a supported image data URI.");
+    }
+}
+function assertExactContentFields(part, allowed) {
+    const extra = Object.keys(part).find((field) => !allowed.includes(field));
+    if (extra) {
+        throw callerContentError("unsupported_message_content_field", `OpenAI subscription user content part "${String(part.type)}" does not support field "${extra}".`);
+    }
+}
+function validateImageMediaType(value, label) {
+    if (typeof value !== "string" || !supportedImageMediaTypes.has(value)) {
+        throw callerContentError("invalid_message_content", `OpenAI subscription ${label} "${String(value)}" is unsupported; expected one of: ${[...supportedImageMediaTypes].join(", ")}.`);
+    }
+    return value;
+}
+function parseImageDataUri(value) {
+    if (!value.startsWith("data:"))
+        return undefined;
+    const match = /^data:(image\/[a-z0-9.+-]+);base64,(.*)$/.exec(value);
+    if (!match) {
+        throw callerContentError("invalid_message_content", "OpenAI subscription image data URIs must use data:<supported-image-mime>;base64,<standard-base64>.");
+    }
+    const mediaType = validateImageMediaType(match[1], "data URI media type");
+    return { mediaType, data: match[2] };
+}
+function isStandardBase64(value) {
+    if (!value || !/^[A-Za-z0-9+/]+={0,2}$/.test(value))
+        return false;
+    const paddingLength = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+    const coreLength = value.length - paddingLength;
+    if (coreLength % 4 === 1)
+        return false;
+    if (paddingLength && value.length % 4 !== 0)
+        return false;
+    return paddingLength !== 2 || coreLength % 4 === 2;
+}
+function callerContentError(code, message) {
+    return new RaybaseInferenceProviderError({ code, message });
+}
+function responseFormat(format) {
+    if (!format)
+        return {};
+    if (format.type === "json_object")
+        return { type: "json_object" };
+    return {
+        type: "json_schema",
+        name: format.name,
+        schema: format.schema,
+        strict: format.strict ?? true,
+        ...(format.description ? { description: format.description } : {})
+    };
+}
+export function normalizeOrigin(value, label = "origin") {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new Error(`OpenAI subscription ${label} is invalid`);
+    }
+    if (parsed.protocol !== "https:"
+        || parsed.username
+        || parsed.password
+        || parsed.search
+        || parsed.hash
+        || parsed.pathname !== "/"
+        || !parsed.hostname
+        || parsed.hostname.endsWith(".")
+        || parsed.hostname.includes("%")
+        || parsed.hostname.split(".").some((labelPart) => !labelPart || !/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(labelPart))) {
+        throw new Error(`OpenAI subscription ${label} must be a bare HTTPS origin`);
+    }
+    return parsed.origin;
+}
+function endpoint(origin, path) {
+    return new URL(path, `${origin}/`).href;
+}
+function assertAllowedUrl(url, expectedAuthOrigin, expectedCodexOrigin, method) {
+    if (method !== "POST"
+        ||
+            url.protocol !== "https:"
+        || url.username
+        || url.password
+        || url.search
+        || url.hash)
+        throw new Error("OpenAI subscription transport URL is not allowlisted");
+    if (url.origin === expectedAuthOrigin && [
+        "/api/accounts/deviceauth/usercode",
+        "/api/accounts/deviceauth/token",
+        "/oauth/token",
+    ].includes(url.pathname))
+        return "auth";
+    if (url.origin === expectedCodexOrigin && url.pathname === "/backend-api/codex/responses")
+        return "codex";
+    throw new Error("OpenAI subscription transport URL is not allowlisted");
+}
+export function assertOpenAISubscriptionUrlForTesting(value, origins = {}, method = "POST") {
+    return assertAllowedUrl(new URL(value), normalizeOrigin(origins.authOrigin ?? authOrigin, "auth origin"), normalizeOrigin(origins.codexOrigin ?? codexOrigin, "Codex origin"), method);
+}
+async function strictJsonResponse(response, signal) {
+    const length = Number(response.headers.get("content-length") ?? "0");
+    if (length > maxJsonBytes) {
+        void response.body?.cancel().catch(() => undefined);
+        throw protocolError("json_size_limit");
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw protocolError("invalid_json");
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    const chunks = [];
+    let total = 0;
+    let complete = false;
+    try {
+        while (true) {
+            const { done, value } = await readStreamChunk(reader, signal);
+            if (done) {
+                complete = true;
+                break;
+            }
+            total += value.byteLength;
+            if (total > maxJsonBytes)
+                throw protocolError("json_size_limit");
+            try {
+                chunks.push(decoder.decode(value, { stream: true }));
+            }
+            catch {
+                throw protocolError("invalid_json");
+            }
+        }
+        try {
+            chunks.push(decoder.decode());
+            return record(JSON.parse(chunks.join("")));
+        }
+        catch (error) {
+            if (error instanceof RaybaseInferenceProviderError)
+                throw error;
+            throw protocolError("invalid_json");
+        }
+    }
+    finally {
+        if (!complete)
+            void reader.cancel().catch(() => undefined);
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // Abort-driven cancellation may still be settling.
+        }
+    }
+}
+function normalizedContentType(response) {
+    return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() || undefined;
+}
+function statusError(response, destination = "auth") {
+    const contentType = normalizedContentType(response);
+    const cfRay = response.headers.get("cf-ray")?.trim() || undefined;
+    if (response.status === 401)
+        return new OpenAISubscriptionTransportHttpError(401, "unauthorized", undefined, contentType, cfRay);
+    if (response.status === 403 && destination === "codex") {
+        // Two unrelated failures share this status. The Codex API answers with
+        // JSON and always stamps `x-oai-request-id`; Cloudflare's front door
+        // answers with the HTML blocked page and never reaches the API, so no
+        // request id exists. Only the second is an egress problem, and telling an
+        // operator to relink for it sends them to a control that cannot help.
+        const servedByApi = Boolean(response.headers.get("x-oai-request-id")?.trim())
+            || contentType === "application/json";
+        return new OpenAISubscriptionTransportHttpError(403, servedByApi ? "account_forbidden" : "egress_forbidden", undefined, contentType, cfRay);
+    }
+    if (response.status === 429) {
+        const retryAfter = Number(response.headers.get("retry-after"));
+        const retryAt = Number.isFinite(retryAfter) ? new Date(Date.now() + retryAfter * 1000).toISOString() : undefined;
+        return new OpenAISubscriptionTransportHttpError(429, "rate_limited", retryAt, contentType, cfRay);
+    }
+    if (response.status >= 300 && response.status < 400)
+        return protocolError("redirect_rejected");
+    return protocolError(`unexpected_http_status_${response.status}`);
+}
+async function codexStatusError(response, signal) {
+    if (response.status !== 400)
+        return statusError(response, "codex");
+    const metadata = {
+        status: 400,
+        contentType: normalizedContentType(response),
+        oaiRequestId: boundedOaiRequestId(response)
+    };
+    let payload;
+    try {
+        payload = await strictJsonResponse(response, signal);
+    }
+    catch (error) {
+        if (error instanceof OpenAISubscriptionTransportProtocolError
+            && codex400JsonShapeErrorCodes.has(error.code)) {
+            return protocolError("unexpected_http_status_400", metadata);
+        }
+        throw error;
+    }
+    const upstream = payload.error && typeof payload.error === "object" && !Array.isArray(payload.error)
+        ? record(payload.error)
+        : {};
+    const code = typeof upstream.code === "string" ? upstream.code : undefined;
+    const type = typeof upstream.type === "string" ? upstream.type : undefined;
+    const param = optionalString(upstream.param);
+    if (code === "invalid_function_parameters"
+        && param
+        && /^tools\[\d+\]\.parameters(?:\.|$)/.test(param)) {
+        return new OpenAISubscriptionTransportHttpError(400, "invalid_function_parameters", undefined, metadata.contentType, response.headers.get("cf-ray")?.trim() || undefined, metadata.oaiRequestId, param);
+    }
+    const token = normalizeCodex400Token(code) ?? normalizeCodex400Token(type);
+    if (token)
+        return new OpenAISubscriptionCodexRequestError(token, metadata);
+    return protocolError("unexpected_http_status_400", metadata);
+}
+/**
+ * A `response.failed` or `error` stream event, classified with what the
+ * upstream actually said.
+ *
+ * A bare `upstream_failed` makes a 5xx, a rate limit, a timeout, and a quota
+ * exhaustion indistinguishable everywhere downstream — the safe-error scrub
+ * keeps only the code, so the code is the one channel that reaches an app's
+ * health row. The upstream code or type rides in the code's suffix, normalized
+ * to a bounded token; the upstream message rides on the error itself for logs
+ * that print raw errors, and is never shown to members (the scrub replaces it).
+ */
+function upstreamFailedError(event) {
+    const response = record(event.response);
+    const nested = record(response.error);
+    const direct = record(event.error);
+    const upstream = Object.keys(nested).length ? nested : direct;
+    const token = normalizeCodex400Token(optionalString(upstream.code))
+        ?? normalizeCodex400Token(optionalString(upstream.type));
+    const detail = optionalString(upstream.message);
+    return new RaybaseInferenceProviderError({
+        code: token ? `upstream_failed:${token}` : "upstream_failed",
+        ...(detail ? { message: `OpenAI subscription upstream failure: ${detail.slice(0, 300)}` } : {})
+    });
+}
+function normalizeCodex400Token(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value
+        .toLowerCase()
+        .replace(/[^a-z0-9_]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .slice(0, 32);
+    return normalized || undefined;
+}
+function boundedOaiRequestId(response) {
+    const requestId = response.headers.get("x-oai-request-id")?.trim();
+    return requestId && requestId.length <= 128 ? requestId : undefined;
+}
+function protocolError(fingerprint, metadata) {
+    return new OpenAISubscriptionTransportProtocolError(fingerprint, metadata);
+}
+function requiredString(value, key, allowEmpty = false) {
+    const found = value[key];
+    if (typeof found !== "string" || (!allowEmpty && !found))
+        throw protocolError(`missing_${key}`);
+    return found;
+}
+function optionalString(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function boundedInteger(value, min, max, label) {
+    const parsed = typeof value === "string" ? Number(value) : value;
+    if (!Number.isInteger(parsed) || Number(parsed) < min || Number(parsed) > max)
+        throw protocolError(`invalid_${label.replace(/\W+/g, "_")}`);
+    return Number(parsed);
+}
+function optionalNonNegativeInteger(value) {
+    return Number.isInteger(value) && Number(value) >= 0 ? Number(value) : undefined;
+}
+function record(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw protocolError("expected_object");
+    return value;
+}
+function parseSseEvent(raw) {
+    let event;
+    const data = [];
+    for (const line of raw.split(/\r?\n/)) {
+        if (!line || line.startsWith(":"))
+            continue;
+        if (line.startsWith("event:"))
+            event = line.slice(6).trim();
+        else if (line.startsWith("data:"))
+            data.push(line.slice(5).trimStart());
+        else
+            throw protocolError("invalid_sse_field");
+    }
+    if (!data.length)
+        return null;
+    return { event, data: data.join("\n") };
+}
+function parseEventJson(value) {
+    if (value === "[DONE]")
+        throw protocolError("unexpected_done_sentinel");
+    try {
+        return record(JSON.parse(value));
+    }
+    catch {
+        throw protocolError("invalid_sse_json");
+    }
+}
+function decodeJwtPayload(token) {
+    try {
+        const payload = token.split(".")[1];
+        if (!payload)
+            return {};
+        const decoded = atob(payload.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(payload.length / 4) * 4, "="));
+        return record(JSON.parse(decoded));
+    }
+    catch {
+        return {};
+    }
+}
+function safeIdentityProjection(claims) {
+    const auth = claims["https://api.openai.com/auth"];
+    const nested = auth && typeof auth === "object" && !Array.isArray(auth) ? auth : {};
+    const accountId = optionalString(nested.chatgpt_account_id) ?? optionalString(claims.chatgpt_account_id);
+    const workspaceId = optionalString(nested.chatgpt_workspace_id) ?? optionalString(claims.chatgpt_workspace_id);
+    const plan = optionalString(nested.chatgpt_plan_type) ?? optionalString(claims.chatgpt_plan_type);
+    return {
+        ...(accountId ? { accountId } : {}),
+        ...(workspaceId ? { workspaceId } : {}),
+        ...(plan ? { plan } : {})
+    };
+}
+//# sourceMappingURL=transport.js.map