@oai404iao/pi-codex-core 0.1.0-alpha.1

package/src/providers/openai-codex/reasoning.ts

@@ -0,0 +1,54 @@
+import { type Api, type Model, type ThinkingLevel } from "@earendil-works/pi-ai/compat";
+
+export function clampReasoningEffort(modelId: string, effort: string): string {
+	const id = modelId.includes("/") ? (modelId.split("/").pop() ?? modelId) : modelId;
+	const gpt5MinorMatch = /^gpt-5\.(\d+)/.exec(id);
+	const gpt5Minor = gpt5MinorMatch ? Number.parseInt(gpt5MinorMatch[1], 10) : undefined;
+	if (gpt5Minor !== undefined && gpt5Minor >= 2 && effort === "minimal") return "low";
+	if (id === "gpt-5.1" && effort === "xhigh") return "high";
+	if (id === "gpt-5.1-codex-mini") return effort === "high" || effort === "xhigh" ? "high" : "medium";
+	return effort;
+}
+
+const CODEX_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+
+type CodexThinkingLevel = (typeof CODEX_THINKING_LEVELS)[number];
+
+/**
+ * Keep this local instead of delegating to older Pi releases: Pi added `max`
+ * after this extension's original minimum version, and an old clamp silently
+ * turns it into `off`.
+ */
+export function clampCodexThinkingLevel(model: Model<Api>, level: ThinkingLevel): CodexThinkingLevel {
+	if (!model.reasoning) return "off";
+	const available = CODEX_THINKING_LEVELS.filter((candidate) => {
+		if (candidate === "off") return true;
+		const mapped = (model.thinkingLevelMap as Record<string, string | null | undefined> | undefined)?.[candidate];
+		if (mapped === null) return false;
+		if (candidate === "xhigh" || candidate === "max") return mapped !== undefined;
+		return true;
+	});
+	if (available.includes(level as CodexThinkingLevel)) return level as CodexThinkingLevel;
+	const requestedIndex = CODEX_THINKING_LEVELS.indexOf(level as CodexThinkingLevel);
+	if (requestedIndex < 0) return available[0] ?? "off";
+	for (let index = requestedIndex; index < CODEX_THINKING_LEVELS.length; index++) {
+		const candidate = CODEX_THINKING_LEVELS[index]!;
+		if (available.includes(candidate)) return candidate;
+	}
+	for (let index = requestedIndex - 1; index >= 0; index--) {
+		const candidate = CODEX_THINKING_LEVELS[index]!;
+		if (available.includes(candidate)) return candidate;
+	}
+	return available[0] ?? "off";
+}
+
+export function thinkingLevelFromUnknown(value: unknown): ThinkingLevel | undefined {
+	return value === "minimal"
+		|| value === "low"
+		|| value === "medium"
+		|| value === "high"
+		|| value === "xhigh"
+		|| value === "max"
+		? value
+		: undefined;
+}

package/src/providers/openai-codex/request-body.ts

@@ -0,0 +1,149 @@
+import { type Api, type Context, type Model, type SimpleStreamOptions } from "@earendil-works/pi-ai/compat";
+import { type CodexRequestProfile } from "@oai404iao/pi-codex-runtime/internal/codex-request-profile";
+import { createCodexReservedNamespaceTool } from "@oai404iao/pi-codex-runtime/internal/codex-reserved-tools";
+import { resolveCodexRequestIdentity } from "@oai404iao/pi-codex-runtime/internal/codex-wire-identity";
+import { type ReasoningSummary } from "@oai404iao/pi-codex-runtime/internal/model-catalog/types";
+import { createCodexApplyPatchCustomTool } from "../codex-apply-patch-tool.js";
+import { convertResponsesMessages } from "@oai404iao/pi-codex-runtime/internal/providers/responses/messages";
+import { convertResponsesTools } from "@oai404iao/pi-codex-runtime/internal/providers/responses/tools";
+import { CODEX_TOOL_CALL_PROVIDERS, WEB_SEARCH_RESULTS_INCLUDE, WEB_SEARCH_SOURCES_INCLUDE } from "./constants.js";
+import { stripResponsesLiteImageDetails } from "./lite.js";
+import { clampCodexThinkingLevel, clampReasoningEffort } from "./reasoning.js";
+import { type ResponsesBody, type NativeToolOwnership } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+
+function hasNativeWebSearchTool(body: ResponsesBody): boolean {
+	return Array.isArray(body.tools) && body.tools.some((tool) => Boolean(tool) && typeof tool === "object" && (tool as { type?: unknown }).type === "web_search");
+}
+
+export function ensureWebSearchDetailsIncluded(body: ResponsesBody): void {
+	if (!hasNativeWebSearchTool(body)) return;
+	const include = Array.isArray(body.include) ? body.include : [];
+	const missing = [WEB_SEARCH_SOURCES_INCLUDE, WEB_SEARCH_RESULTS_INCLUDE].filter((value) => !include.includes(value));
+	if (missing.length > 0) body.include = [...include, ...missing];
+}
+
+export function buildRequestBody<TApi extends Api>(model: Model<TApi>, context: Context, profile: CodexRequestProfile, options?: SimpleStreamOptions & { ownsNativeTool?: NativeToolOwnership }): ResponsesBody {
+	const requestIdentity = resolveCodexRequestIdentity(
+		options?.sessionId,
+		options?.metadata as Record<string, unknown> | undefined,
+		// Only the session-scoped prompt cache key is needed here. Do not
+		// synthesize a logical turn while constructing startup/prewarm bodies.
+		"prewarm",
+	);
+	const messages = convertResponsesMessages(model, context, new Set([...CODEX_TOOL_CALL_PROVIDERS, model.provider]), {
+		includeSystemPrompt: false,
+	});
+	const tools = context.tools && context.tools.length > 0
+		? convertResponsesTools(context.tools, { strict: null }).map((tool) =>
+			profile.patchTransport === "custom" && tool.type === "function" && tool.name === "apply_patch" ? createCodexApplyPatchCustomTool() : tool)
+		: [];
+	const lite = profile.responsesMode === "lite";
+	const liteTools = (): unknown[] => {
+		const namespaces = new Map<string, {
+			type: "namespace";
+			name: string;
+			description: string;
+			tools: unknown[];
+		}>();
+		for (const tool of tools as Array<Record<string, unknown>>) {
+			if (typeof tool.name !== "string") continue;
+			if ((tool.name === "web_search" || tool.name === "image_generation")
+				&& options?.ownsNativeTool?.(tool.name) !== false) {
+				const reserved = createCodexReservedNamespaceTool(tool.name);
+				namespaces.set(reserved.name, reserved);
+				continue;
+			}
+			let namespace = namespaces.get("functions");
+			if (!namespace) {
+				namespace = {
+					type: "namespace",
+					name: "functions",
+					description: "",
+					tools: [],
+				};
+				namespaces.set("functions", namespace);
+			}
+			const nestedTool: Record<string, unknown> = { ...tool };
+			if (nestedTool.type === "function" && typeof nestedTool.strict !== "boolean") {
+				nestedTool.strict = false;
+			}
+			namespace.tools.push(nestedTool);
+		}
+		return [...namespaces.values()].filter((namespace) => namespace.tools.length > 0);
+	};
+
+	const body: ResponsesBody = {
+		model: model.id,
+		store: false,
+		stream: true,
+		input: [],
+		text: { verbosity: ((options as { textVerbosity?: string } | undefined)?.textVerbosity ?? "low") as string },
+		include: ["reasoning.encrypted_content"],
+		prompt_cache_key: requestIdentity?.sessionId ?? options?.sessionId,
+		tool_choice: "auto",
+		parallel_tool_calls: profile.supportsParallelTools,
+	};
+	if (lite) {
+		stripResponsesLiteImageDetails(messages);
+		body.input = [
+			{ type: "additional_tools", role: "developer", tools: liteTools() },
+			...(context.systemPrompt
+				? [{ type: "message", role: "developer", content: [{ type: "input_text", text: context.systemPrompt }] }]
+				: []),
+			...messages,
+		];
+		body.reasoning = { context: "all_turns" };
+	} else {
+		if (profile.systemPromptPlacement === "instructions") {
+			body.instructions = context.systemPrompt;
+			body.input = messages;
+		} else {
+			body.input = [
+				...(context.systemPrompt
+					? [{ type: "message", role: "developer", content: [{ type: "input_text", text: context.systemPrompt }] }]
+					: []),
+				...messages,
+			];
+		}
+		if (tools.length > 0) body.tools = tools;
+	}
+
+	// The Codex ChatGPT-backed endpoint rejects output-token cap fields with
+	// `Unsupported parameter: max_output_tokens`. Pi's branch summarizer passes
+	// `maxTokens`, so forwarding it breaks `/tree` summaries and extensions that
+	// use `ctx.navigateTree(..., { summarize: true })`.
+
+	if ((options as { temperature?: number } | undefined)?.temperature !== undefined) {
+		body.temperature = (options as { temperature?: number }).temperature;
+	}
+
+	const serviceTier = (options as { serviceTier?: string } | undefined)?.serviceTier;
+	if (serviceTier !== undefined) {
+		body.service_tier = serviceTier;
+	}
+
+	const clampedReasoning = options?.reasoning
+		? clampCodexThinkingLevel(model as Model<Api>, options.reasoning)
+		: undefined;
+	const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
+	if (reasoningEffort !== undefined) {
+		const effort = model.thinkingLevelMap?.[reasoningEffort] ?? reasoningEffort;
+		if (effort === null) return body;
+		const reasoning = body.reasoning ?? {};
+		reasoning.effort = clampReasoningEffort(model.id, effort);
+		const summary = (options as { reasoningSummary?: ReasoningSummary | null } | undefined)?.reasoningSummary
+			?? profile.reasoningSummary;
+		if (summary && summary !== "none") reasoning.summary = summary;
+		body.reasoning = reasoning;
+	} else if (lite && clampedReasoning !== "off") {
+		// Match the Codex CLI default reasoning level for Lite models: the CLI
+		// always sends `reasoning.effort` (default "low") for gpt-5.6-* models.
+		const reasoning = body.reasoning ?? {};
+		if (reasoning.effort === undefined) {
+			reasoning.effort = model.thinkingLevelMap?.low ?? "low";
+		}
+		body.reasoning = reasoning;
+	}
+
+	return body;
+}

package/src/providers/openai-codex/request-context.ts

@@ -0,0 +1,20 @@
+import { type Context } from "@earendil-works/pi-ai/compat";
+
+export function getLatestUserText(context: Context): string | undefined {
+	for (let i = context.messages.length - 1; i >= 0; i--) {
+		const message = context.messages[i];
+		if (message.role !== "user") continue;
+		if (typeof message.content === "string") {
+			const trimmed = message.content.trim();
+			if (trimmed) return trimmed;
+			continue;
+		}
+		const text = message.content
+			.filter((item) => item.type === "text")
+			.map((item) => item.text)
+			.join("\n")
+			.trim();
+		if (text) return text;
+	}
+	return undefined;
+}

package/src/providers/openai-codex/request-metadata.ts

@@ -0,0 +1,137 @@
+import { isUuidV7, resolveCodexRequestIdentity, uuidV7, type CodexRequestIdentity } from "@oai404iao/pi-codex-runtime/internal/codex-wire-identity";
+import { WS_STREAM_REQUEST_START_MS_CLIENT_METADATA_KEY } from "./constants.js";
+import { type ResponsesBody, type WebSocketRequestMetadata } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+
+export function createCodexRequestId(): string {
+	if (typeof globalThis.crypto?.randomUUID === "function") {
+		return globalThis.crypto.randomUUID();
+	}
+	return `codex_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+
+export function createPiTurnId(): string {
+	return uuidV7();
+}
+
+/**
+ * Build the `x-codex-turn-metadata` compatibility blob the CLI sends inside
+ * `client_metadata` for every request kind. The gateway currently rewrites
+ * this blob (privacy normalization); once it honors client-supplied values,
+ * this keeps the shape identical to the CLI.
+ */
+export function buildCodexTurnMetadataJson(identity: CodexRequestIdentity): string {
+	const payload: Record<string, string | number> = {
+		installation_id: identity.installationId,
+		session_id: identity.sessionId,
+		thread_id: identity.threadId,
+		turn_id: identity.turnId,
+		window_id: identity.windowId,
+		request_kind: identity.requestKind,
+		...(identity.turnStartedAtMs !== undefined
+			? { turn_started_at_unix_ms: identity.turnStartedAtMs }
+			: {}),
+		...(identity.agentName ? { agent_name: identity.agentName } : {}),
+		...(identity.forkedFromThreadId
+			? { forked_from_thread_id: identity.forkedFromThreadId }
+			: {}),
+		...(identity.parentThreadId
+			? { parent_thread_id: identity.parentThreadId }
+			: {}),
+		...(identity.parentTurnId
+			? { parent_turn_id: identity.parentTurnId }
+			: {}),
+		...(identity.rootTurnId
+			? { root_turn_id: identity.rootTurnId }
+			: {}),
+		...(identity.subagentKind
+			? { subagent_kind: identity.subagentKind }
+			: {}),
+	};
+	return JSON.stringify(payload);
+}
+
+function identityForRequestMetadata(
+	metadata: WebSocketRequestMetadata,
+): CodexRequestIdentity | undefined {
+	if (metadata.identity) return metadata.identity;
+	const explicit: Record<string, unknown> = {
+		turn_id: metadata.turnId,
+	};
+	if (isUuidV7(metadata.threadId)) explicit.thread_id = metadata.threadId;
+	return resolveCodexRequestIdentity(
+		metadata.sessionId,
+		explicit,
+		metadata.requestKind ?? "turn",
+	);
+}
+
+/**
+ * Inject the Codex-compatible `client_metadata` for an SSE request, sourced
+ * from the same (session, thread, turn) metadata as the WebSocket path. The
+ * WebSocket-only fields (`x-codex-ws-stream-request-start-ms`, turn-state,
+ * Lite flag) stay out: SSE carries the Lite header and turn-state header.
+ */
+export function withSseRequestMetadata(body: ResponsesBody, metadata: WebSocketRequestMetadata): ResponsesBody {
+	const identity = identityForRequestMetadata(metadata);
+	if (!identity) return body;
+	const turnMetadata = buildCodexTurnMetadataJson(identity);
+	return {
+		...body,
+		client_metadata: {
+			...body.client_metadata,
+			session_id: identity.sessionId,
+			thread_id: identity.threadId,
+			"x-codex-window-id": identity.windowId,
+			turn_id: identity.turnId,
+			"x-codex-installation-id": identity.installationId,
+			...(identity.parentThreadId
+				? { "x-codex-parent-thread-id": identity.parentThreadId }
+				: {}),
+			...(identity.parentTurnId
+				? { parent_turn_id: identity.parentTurnId }
+				: {}),
+			...(identity.rootTurnId
+				? { root_turn_id: identity.rootTurnId }
+				: {}),
+			...(identity.subagentKind
+				? { "x-openai-subagent": identity.subagentKind }
+				: {}),
+			...(turnMetadata ? { "x-codex-turn-metadata": turnMetadata } : {}),
+		},
+	};
+}
+
+export function withWebSocketRequestMetadata(body: ResponsesBody, metadata: WebSocketRequestMetadata): ResponsesBody {
+	const identity = identityForRequestMetadata(metadata);
+	const turnMetadata = identity ? buildCodexTurnMetadataJson(identity) : "";
+	return {
+		...body,
+		client_metadata: {
+			...body.client_metadata,
+			...(identity ? { session_id: identity.sessionId } : {}),
+			...(identity ? { thread_id: identity.threadId } : {}),
+			...(identity ? { "x-codex-window-id": identity.windowId } : {}),
+			turn_id: identity?.turnId ?? metadata.turnId,
+			...(identity
+				? { "x-codex-installation-id": identity.installationId }
+				: {}),
+			...(identity?.parentThreadId
+				? { "x-codex-parent-thread-id": identity.parentThreadId }
+				: {}),
+			...(identity?.parentTurnId
+				? { parent_turn_id: identity.parentTurnId }
+				: {}),
+			...(identity?.rootTurnId
+				? { root_turn_id: identity.rootTurnId }
+				: {}),
+			...(identity?.subagentKind
+				? { "x-openai-subagent": identity.subagentKind }
+				: {}),
+			...(turnMetadata ? { "x-codex-turn-metadata": turnMetadata } : {}),
+			...(identity?.turnState
+				? { "x-codex-turn-state": identity.turnState }
+				: {}),
+			[WS_STREAM_REQUEST_START_MS_CLIENT_METADATA_KEY]: Date.now().toString(),
+		},
+	};
+}

package/src/providers/openai-codex/retry.ts

@@ -0,0 +1,154 @@
+import { type SimpleStreamOptions } from "@earendil-works/pi-ai/compat";
+import { DEFAULT_WEBSOCKET_STREAM_MAX_RETRIES, MAX_WEBSOCKET_STREAM_MAX_RETRIES, PREVIOUS_RESPONSE_NOT_FOUND_CODE, WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE, WEBSOCKET_RETRY_BASE_DELAY_MS, WEBSOCKET_RETRY_MAX_DELAY_MS } from "./constants.js";
+import { NonRetryableProviderError, ProviderProtocolError, ProviderResponseError, WebSocketHandshakeError, isRetryableError } from "./errors.js";
+
+export function sleep(ms: number, signal: AbortSignal | undefined): Promise<void> {
+	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"));
+			},
+			{ once: true },
+		);
+	});
+}
+
+export function isRetryableEarlyWebSocketError(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	return /^WebSocket (error|closed)(?:\s|$)/.test(message);
+}
+
+export function retryAfterMsFromHeaders(headers: Record<string, string> | undefined): number | undefined {
+	if (!headers) return undefined;
+	const retryAfterMs = Object.entries(headers).find(([name]) => name.toLowerCase() === "retry-after-ms")?.[1];
+	if (retryAfterMs) {
+		const parsed = Number.parseFloat(retryAfterMs);
+		if (Number.isFinite(parsed) && parsed >= 0) return parsed;
+	}
+	const retryAfter = Object.entries(headers).find(([name]) => name.toLowerCase() === "retry-after")?.[1];
+	if (!retryAfter) return undefined;
+	const seconds = Number.parseFloat(retryAfter);
+	if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000;
+	const date = Date.parse(retryAfter);
+	return Number.isFinite(date) ? Math.max(0, date - Date.now()) : undefined;
+}
+
+export function isRetryableWebSocketError(error: unknown): boolean {
+	if (error instanceof WebSocketHandshakeError) {
+		return isRetryableError(error.status, error.body ?? error.message);
+	}
+	if (error instanceof ProviderResponseError) {
+		if (
+			/usage_limit_reached|usage_not_included/i.test(`${error.code ?? ""} ${error.errorType ?? ""}`)
+		) {
+			return false;
+		}
+		if (typeof error.status === "number" && isRetryableError(error.status, error.message)) return true;
+		return /retry|rate.?limit|overloaded|service.?unavailable|connection.?limit/i.test(
+			`${error.code ?? ""} ${error.errorType ?? ""} ${error.message}`,
+		);
+	}
+	if (error instanceof ProviderProtocolError || error instanceof NonRetryableProviderError) return false;
+	const message = error instanceof Error ? error.message : String(error);
+	return /websocket|network|connection|socket|timed? out|timeout|fetch failed|terminated|closed before response\.completed|stream closed before response\.completed/i.test(
+		message,
+	);
+}
+
+function explicitWebSocketRetryDelayMs(error: unknown): number | undefined {
+	return error instanceof WebSocketHandshakeError
+		? retryAfterMsFromHeaders(error.headers)
+		: error instanceof ProviderResponseError
+			? error.retryAfterMs
+			: undefined;
+}
+
+function boundedWebSocketRetryDelayMs(
+	delayMs: number,
+	options: SimpleStreamOptions | undefined,
+): number {
+	const configuredMax = options?.maxRetryDelayMs;
+	const maxDelay = typeof configuredMax === "number" && Number.isFinite(configuredMax) && configuredMax >= 0
+		? configuredMax
+		: WEBSOCKET_RETRY_MAX_DELAY_MS;
+	if (maxDelay > 0 && delayMs > maxDelay) {
+		throw new NonRetryableProviderError(
+			`WebSocket retry delay ${Math.round(delayMs)}ms exceeds maxRetryDelayMs ${Math.round(maxDelay)}ms`,
+		);
+	}
+	return delayMs;
+}
+
+export function webSocketRetryDelayMs(
+	error: unknown,
+	retryCount: number,
+	options: SimpleStreamOptions | undefined,
+): number {
+	const explicit = explicitWebSocketRetryDelayMs(error);
+	const connectionFailure = !(
+		error instanceof WebSocketHandshakeError
+		|| error instanceof ProviderResponseError
+		|| error instanceof ProviderProtocolError
+	);
+	const base = explicit
+		?? (connectionFailure
+			? Math.min(WEBSOCKET_RETRY_MAX_DELAY_MS, 5_000 * 2 ** Math.max(0, retryCount - 1))
+			: WEBSOCKET_RETRY_BASE_DELAY_MS * 2 ** Math.max(0, retryCount - 1));
+	const jittered = explicit === undefined && !connectionFailure
+		? Math.round(base * (0.9 + Math.random() * 0.2))
+		: base;
+	return boundedWebSocketRetryDelayMs(jittered, options);
+}
+
+export function webSocketCompactionRetryDelayMs(
+	error: unknown,
+	retryCount: number,
+	options: SimpleStreamOptions | undefined,
+): number {
+	const explicit = explicitWebSocketRetryDelayMs(error);
+	const base = explicit ?? WEBSOCKET_RETRY_BASE_DELAY_MS * 2 ** Math.max(0, retryCount - 1);
+	const jittered = explicit === undefined
+		? Math.round(base * (0.9 + Math.random() * 0.2))
+		: base;
+	return boundedWebSocketRetryDelayMs(jittered, options);
+}
+
+export function webSocketStreamMaxRetries(options: SimpleStreamOptions | undefined): number {
+	const value = options?.maxRetries;
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+		return DEFAULT_WEBSOCKET_STREAM_MAX_RETRIES;
+	}
+	return Math.min(MAX_WEBSOCKET_STREAM_MAX_RETRIES, Math.floor(value));
+}
+
+export function isProviderNonTransportError(error: unknown): error is ProviderResponseError | ProviderProtocolError {
+	return error instanceof ProviderResponseError || error instanceof ProviderProtocolError;
+}
+
+export function isWebSocketUpgradeRejectedError(error: unknown): error is WebSocketHandshakeError {
+	// `auto` is capability negotiation, not a generic recovery path. HTTP 426
+	// explicitly tells the client that the WebSocket upgrade cannot be used.
+	// Model/request failures and transient connection errors must stay on the
+	// WebSocket path so an agent-level retry does not silently change transport.
+	return error instanceof WebSocketHandshakeError && error.status === 426;
+}
+
+export function isWebSocketConnectionLimitReachedError(error: unknown): boolean {
+	const candidate = error as { code?: unknown; message?: unknown };
+	if (candidate?.code === WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE) return true;
+	return typeof candidate?.message === "string" && candidate.message.includes(WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE);
+}
+
+export function isPreviousResponseNotFoundError(error: unknown): boolean {
+	const candidate = error as { code?: unknown; message?: unknown };
+	if (candidate?.code === PREVIOUS_RESPONSE_NOT_FOUND_CODE) return true;
+	return typeof candidate?.message === "string" && candidate.message.includes(PREVIOUS_RESPONSE_NOT_FOUND_CODE);
+}

package/src/providers/openai-codex/runtime.ts

@@ -0,0 +1 @@
+export const dynamicImport = (specifier: string) => import(specifier);

package/src/providers/openai-codex/sse.ts

@@ -0,0 +1,93 @@
+import { type SimpleStreamOptions } from "@earendil-works/pi-ai/compat";
+import { SSE_RESPONSE_HEADER_TIMEOUT_MS } from "./constants.js";
+import { type StreamEventShape } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+
+export function responseHeaderTimeoutMsFromOptions(options: SimpleStreamOptions | undefined): number {
+	const value = (options as { timeoutMs?: unknown } | undefined)?.timeoutMs;
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : SSE_RESPONSE_HEADER_TIMEOUT_MS;
+}
+
+export async function fetchWithResponseHeaderTimeout(
+	url: string,
+	init: RequestInit,
+	parentSignal: AbortSignal | undefined,
+	timeoutMs = SSE_RESPONSE_HEADER_TIMEOUT_MS,
+): Promise<Response> {
+	if (parentSignal?.aborted) throw new Error("Request was aborted");
+
+	const controller = new AbortController();
+	let timedOut = false;
+	let parentAborted = false;
+	const timeoutMessage = `Codex Responses SSE response headers timed out after ${timeoutMs}ms`;
+
+	const onParentAbort = () => {
+		parentAborted = true;
+		controller.abort(parentSignal?.reason);
+	};
+
+	if (parentSignal) parentSignal.addEventListener("abort", onParentAbort, { once: true });
+	const timeout = setTimeout(() => {
+		timedOut = true;
+		controller.abort(new Error(timeoutMessage));
+	}, Math.max(1, timeoutMs));
+
+	try {
+		return await fetch(url, { ...init, signal: controller.signal });
+	} catch (error) {
+		if (timedOut) throw new Error(timeoutMessage);
+		if (parentAborted || parentSignal?.aborted) throw new Error("Request was aborted");
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+		if (parentSignal) parentSignal.removeEventListener("abort", onParentAbort);
+	}
+}
+
+export async function* parseSSE(response: Response): AsyncIterable<StreamEventShape> {
+	if (!response.body) return;
+
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+
+			buffer += decoder.decode(value, { stream: true });
+			buffer = buffer.replace(/\r\n/g, "\n").replace(/\r/g, "\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((line) => line.startsWith("data:"))
+					.map((line) => line.slice(5).trim());
+				if (dataLines.length > 0) {
+					const data = dataLines.join("\n").trim();
+					if (data && data !== "[DONE]") {
+						try {
+							yield JSON.parse(data) as StreamEventShape;
+						} catch {
+							// Ignore malformed SSE chunks and continue consuming the stream.
+						}
+					}
+				}
+				idx = buffer.indexOf("\n\n");
+			}
+		}
+	} finally {
+		try {
+			await reader.cancel();
+		} catch {
+			// ignore cancellation errors
+		}
+		try {
+			reader.releaseLock();
+		} catch {
+			// ignore lock release errors
+		}
+	}
+}