import { mkdtempSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import type { ResponseStreamEvent } from "openai/resources/responses/responses.js";
import { afterEach, describe, expect, it, vi } from "vitest";
import { supportsFastMode } from "../src/models.js";
import {
	getOpenAICodexWebSocketDebugStats,
	resetOpenAICodexWebSocketDebugStats,
	streamOpenAICodexResponses,
	streamSimpleOpenAICodexResponses,
} from "../src/providers/openai-codex-responses.js";
import { convertResponsesMessages, processResponsesStream } from "../src/providers/openai-responses-shared.js";
import { buildBaseOptions } from "../src/providers/simple-options.js";
import type { Api, AssistantMessage, Context, Model, ToolResultMessage } from "../src/types.js";
import { AssistantMessageEventStream } from "../src/utils/event-stream.js";

const originalFetch = global.fetch;
const originalWebSocket = globalThis.WebSocket;
const originalAgentDir = process.env.PI_CODING_AGENT_DIR;

afterEach(() => {
	global.fetch = originalFetch;
	globalThis.WebSocket = originalWebSocket;
	if (originalAgentDir === undefined) {
		delete process.env.PI_CODING_AGENT_DIR;
	} else {
		process.env.PI_CODING_AGENT_DIR = originalAgentDir;
	}
	resetOpenAICodexWebSocketDebugStats();
	vi.restoreAllMocks();
});

function mockToken(): string {
	const payload = Buffer.from(
		JSON.stringify({ "https://api.openai.com/auth": { chatgpt_account_id: "acc_test" } }),
		"utf8",
	).toString("base64");
	return `aaa.${payload}.bbb`;
}

function buildSSEPayload({
	status,
	includeDone = false,
}: {
	status: "completed" | "incomplete";
	includeDone?: boolean;
}): string {
	const terminalType = status === "incomplete" ? "response.incomplete" : "response.completed";
	const events = [
		`data: ${JSON.stringify({
			type: "response.output_item.added",
			item: { type: "message", id: "msg_1", role: "assistant", status: "in_progress", content: [] },
		})}`,
		`data: ${JSON.stringify({ type: "response.content_part.added", part: { type: "output_text", text: "" } })}`,
		`data: ${JSON.stringify({ type: "response.output_text.delta", delta: "Hello" })}`,
		`data: ${JSON.stringify({
			type: "response.output_item.done",
			item: {
				type: "message",
				id: "msg_1",
				role: "assistant",
				status: "completed",
				content: [{ type: "output_text", text: "Hello" }],
			},
		})}`,
		`data: ${JSON.stringify({
			type: terminalType,
			response: {
				status,
				incomplete_details: status === "incomplete" ? { reason: "max_output_tokens" } : null,
				usage: {
					input_tokens: 5,
					output_tokens: 3,
					total_tokens: 8,
					input_tokens_details: { cached_tokens: 0 },
				},
			},
		})}`,
	];

	if (includeDone) {
		events.push("data: [DONE]");
	}

	return `${events.join("\n\n")}\n\n`;
}

describe("openai-codex streaming", () => {
	it("streams SSE responses into AssistantMessageEventStream", async () => {
		const tempDir = mkdtempSync(join(tmpdir(), "pi-codex-stream-"));
		process.env.PI_CODING_AGENT_DIR = tempDir;

		const payload = Buffer.from(
			JSON.stringify({ "https://api.openai.com/auth": { chatgpt_account_id: "acc_test" } }),
			"utf8",
		).toString("base64");
		const token = `aaa.${payload}.bbb`;

		const sse = `${[
			`data: ${JSON.stringify({
				type: "response.output_item.added",
				item: { type: "message", id: "msg_1", role: "assistant", status: "in_progress", content: [] },
			})}`,
			`data: ${JSON.stringify({ type: "response.content_part.added", part: { type: "output_text", text: "" } })}`,
			`data: ${JSON.stringify({ type: "response.output_text.delta", delta: "Hello" })}`,
			`data: ${JSON.stringify({
				type: "response.output_item.done",
				item: {
					type: "message",
					id: "msg_1",
					role: "assistant",
					status: "completed",
					content: [{ type: "output_text", text: "Hello" }],
				},
			})}`,
			`data: ${JSON.stringify({
				type: "response.completed",
				response: {
					status: "completed",
					usage: {
						input_tokens: 5,
						output_tokens: 3,
						total_tokens: 8,
						input_tokens_details: { cached_tokens: 0 },
					},
				},
			})}`,
		].join("\n\n")}\n\n`;

		const encoder = new TextEncoder();
		const stream = new ReadableStream<Uint8Array>({
			start(controller) {
				controller.enqueue(encoder.encode(sse));
				controller.close();
			},
		});

		const fetchMock = vi.fn(async (input: string | URL, init?: RequestInit) => {
			const url = typeof input === "string" ? input : input.toString();
			if (url === "https://api.github.com/repos/openai/codex/releases/latest") {
				return new Response(JSON.stringify({ tag_name: "rust-v0.0.0" }), { status: 200 });
			}
			if (url.startsWith("https://raw.githubusercontent.com/openai/codex/")) {
				return new Response("PROMPT", { status: 200, headers: { etag: '"etag"' } });
			}
			if (url === "https://chatgpt.com/backend-api/codex/responses") {
				const headers = init?.headers instanceof Headers ? init.headers : undefined;
				expect(headers?.get("Authorization")).toBe(`Bearer ${token}`);
				expect(headers?.get("chatgpt-account-id")).toBe("acc_test");
				expect(headers?.get("OpenAI-Beta")).toBe("responses=experimental");
				expect(headers?.get("originator")).toBe("pi");
				expect(headers?.get("accept")).toBe("text/event-stream");
				expect(headers?.has("x-api-key")).toBe(false);
				return new Response(stream, {
					status: 200,
					headers: { "content-type": "text/event-stream" },
				});
			}
			return new Response("not found", { status: 404 });
		});

		global.fetch = fetchMock as typeof fetch;

		const model: Model<"openai-codex-responses"> = {
			id: "gpt-5.1-codex",
			name: "GPT-5.1 Codex",
			api: "openai-codex-responses",
			provider: "openai-codex",
			baseUrl: "https://chatgpt.com/backend-api",
			reasoning: true,
			input: ["text"],
			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
			contextWindow: 400000,
			maxTokens: 128000,
		};

		const context: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: Date.now() }],
		};

		const streamResult = streamOpenAICodexResponses(model, context, { apiKey: token });
		let sawTextDelta = false;
		let sawDone = false;

		for await (const event of streamResult) {
			if (event.type === "text_delta") {
				sawTextDelta = true;
			}
			if (event.type === "done") {
				sawDone = true;
				expect(event.message.content.find((c) => c.type === "text")?.text).toBe("Hello");
			}
		}

		expect(sawTextDelta).toBe(true);
		expect(sawDone).toBe(true);
	});

	it("completes after response.completed even when the SSE body stays open", async () => {
		const tempDir = mkdtempSync(join(tmpdir(), "pi-codex-stream-"));
		process.env.PI_CODING_AGENT_DIR = tempDir;
		const token = mockToken();
		const encoder = new TextEncoder();
		const sse = buildSSEPayload({ status: "completed", includeDone: true });

		const stream = new ReadableStream<Uint8Array>({
			start(controller) {
				controller.enqueue(encoder.encode(sse));
			},
		});

		global.fetch = vi.fn(async (input: string | URL) => {
			const url = typeof input === "string" ? input : input.toString();
			if (url === "https://api.github.com/repos/openai/codex/releases/latest") {
				return new Response(JSON.stringify({ tag_name: "rust-v0.0.0" }), { status: 200 });
			}
			if (url.startsWith("https://raw.githubusercontent.com/openai/codex/")) {
				return new Response("PROMPT", { status: 200, headers: { etag: '"etag"' } });
			}
			if (url === "https://chatgpt.com/backend-api/codex/responses") {
				return new Response(stream, {
					status: 200,
					headers: { "content-type": "text/event-stream" },
				});
			}
			return new Response("not found", { status: 404 });
		}) as typeof fetch;

		const model: Model<"openai-codex-responses"> = {
			id: "gpt-5.1-codex",
			name: "GPT-5.1 Codex",
			api: "openai-codex-responses",
			provider: "openai-codex",
			baseUrl: "https://chatgpt.com/backend-api",
			reasoning: true,
			input: ["text"],
			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
			contextWindow: 400000,
			maxTokens: 128000,
		};

		const context: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: Date.now() }],
		};

		const result = await Promise.race([
			streamOpenAICodexResponses(model, context, { apiKey: token, transport: "sse" }).result(),
			new Promise<never>((_, reject) => {
				setTimeout(() => reject(new Error("Timed out waiting for completed SSE stream")), 1000);
			}),
		]);

		expect(result.content.find((c) => c.type === "text")?.text).toBe("Hello");
		expect(result.stopReason).toBe("stop");
	});

	it("maps response.incomplete to stopReason length even when the SSE body stays open", async () => {
		const tempDir = mkdtempSync(join(tmpdir(), "pi-codex-stream-"));
		process.env.PI_CODING_AGENT_DIR = tempDir;
		const token = mockToken();
		const encoder = new TextEncoder();
		const sse = buildSSEPayload({ status: "incomplete" });

		const stream = new ReadableStream<Uint8Array>({
			start(controller) {
				controller.enqueue(encoder.encode(sse));
			},
		});

		global.fetch = vi.fn(async (input: string | URL) => {
			const url = typeof input === "string" ? input : input.toString();
			if (url === "https://api.github.com/repos/openai/codex/releases/latest") {
				return new Response(JSON.stringify({ tag_name: "rust-v0.0.0" }), { status: 200 });
			}
			if (url.startsWith("https://raw.githubusercontent.com/openai/codex/")) {
				return new Response("PROMPT", { status: 200, headers: { etag: '"etag"' } });
			}
			if (url === "https://chatgpt.com/backend-api/codex/responses") {
				return new Response(stream, {
					status: 200,
					headers: { "content-type": "text/event-stream" },
				});
			}
			return new Response("not found", { status: 404 });
		}) as typeof fetch;

		const model: Model<"openai-codex-responses"> = {
			id: "gpt-5.1-codex",
			name: "GPT-5.1 Codex",
			api: "openai-codex-responses",
			provider: "openai-codex",
			baseUrl: "https://chatgpt.com/backend-api",
			reasoning: true,
			input: ["text"],
			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
			contextWindow: 400000,
			maxTokens: 128000,
		};

		const context: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: Date.now() }],
		};

		const result = await Promise.race([
			streamOpenAICodexResponses(model, context, { apiKey: token, transport: "sse" }).result(),
			new Promise<never>((_, reject) => {
				setTimeout(() => reject(new Error("Timed out waiting for incomplete SSE stream")), 1000);
			}),
		]);

		expect(result.content.find((c) => c.type === "text")?.text).toBe("Hello");
		expect(result.stopReason).toBe("length");
	});

	it("sets session_id/x-client-request-id headers and prompt_cache_key when sessionId is provided", async () => {
		const tempDir = mkdtempSync(join(tmpdir(), "pi-codex-stream-"));
		process.env.PI_CODING_AGENT_DIR = tempDir;

		const payload = Buffer.from(
			JSON.stringify({ "https://api.openai.com/auth": { chatgpt_account_id: "acc_test" } }),
			"utf8",
		).toString("base64");
		const token = `aaa.${payload}.bbb`;

		const sse = `${[
			`data: ${JSON.stringify({
				type: "response.output_item.added",
				item: { type: "message", id: "msg_1", role: "assistant", status: "in_progress", content: [] },
			})}`,
			`data: ${JSON.stringify({ type: "response.content_part.added", part: { type: "output_text", text: "" } })}`,
			`data: ${JSON.stringify({ type: "response.output_text.delta", delta: "Hello" })}`,
			`data: ${JSON.stringify({
				type: "response.output_item.done",
				item: {
					type: "message",
					id: "msg_1",
					role: "assistant",
					status: "completed",
					content: [{ type: "output_text", text: "Hello" }],
				},
			})}`,
			`data: ${JSON.stringify({
				type: "response.completed",
				response: {
					status: "completed",
					usage: {
						input_tokens: 5,
						output_tokens: 3,
						total_tokens: 8,
						input_tokens_details: { cached_tokens: 0 },
					},
				},
			})}`,
		].join("\n\n")}\n\n`;

		const encoder = new TextEncoder();
		const stream = new ReadableStream<Uint8Array>({
			start(controller) {
				controller.enqueue(encoder.encode(sse));
				controller.close();
			},
		});

		const sessionId = "test-session-123";
		const fetchMock = vi.fn(async (input: string | URL, init?: RequestInit) => {
			const url = typeof input === "string" ? input : input.toString();
			if (url === "https://api.github.com/repos/openai/codex/releases/latest") {
				return new Response(JSON.stringify({ tag_name: "rust-v0.0.0" }), { status: 200 });
			}
			if (url.startsWith("https://raw.githubusercontent.com/openai/codex/")) {
				return new Response("PROMPT", { status: 200, headers: { etag: '"etag"' } });
			}
			if (url === "https://chatgpt.com/backend-api/codex/responses") {
				const headers = init?.headers instanceof Headers ? init.headers : undefined;
				expect(headers?.get("session_id")).toBe(sessionId);
				expect(headers?.get("x-client-request-id")).toBe(sessionId);

				const body = typeof init?.body === "string" ? (JSON.parse(init.body) as Record<string, unknown>) : null;
				expect(body?.prompt_cache_key).toBe(sessionId);

				return new Response(stream, {
					status: 200,
					headers: { "content-type": "text/event-stream" },
				});
			}
			return new Response("not found", { status: 404 });
		});

		global.fetch = fetchMock as typeof fetch;

		const model: Model<"openai-codex-responses"> = {
			id: "gpt-5.1-codex",
			name: "GPT-5.1 Codex",
			api: "openai-codex-responses",
			provider: "openai-codex",
			baseUrl: "https://chatgpt.com/backend-api",
			reasoning: true,
			input: ["text"],
			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
			contextWindow: 400000,
			maxTokens: 128000,
		};

		const context: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: Date.now() }],
		};

		const streamResult = streamOpenAICodexResponses(model, context, { apiKey: token, sessionId });
		await streamResult.result();
	});

	it("preserves gpt-5.5 xhigh reasoning effort from simple options", async () => {
		const tempDir = mkdtempSync(join(tmpdir(), "pi-codex-stream-"));
		process.env.PI_CODING_AGENT_DIR = tempDir;
		const token = mockToken();
		const sse = buildSSEPayload({ status: "completed" });
		const encoder = new TextEncoder();
		const stream = new ReadableStream<Uint8Array>({
			start(controller) {
				controller.enqueue(encoder.encode(sse));
				controller.close();
			},
		});
		let requestedReasoning: unknown;

		global.fetch = vi.fn(async (input: string | URL, init?: RequestInit) => {
			const url = typeof input === "string" ? input : input.toString();
			if (url === "https://api.github.com/repos/openai/codex/releases/latest") {
				return new Response(JSON.stringify({ tag_name: "rust-v0.0.0" }), { status: 200 });
			}
			if (url.startsWith("https://raw.githubusercontent.com/openai/codex/")) {
				return new Response("PROMPT", { status: 200, headers: { etag: '"etag"' } });
			}
			if (url === "https://chatgpt.com/backend-api/codex/responses") {
				const body = typeof init?.body === "string" ? (JSON.parse(init.body) as Record<string, unknown>) : null;
				requestedReasoning = body?.reasoning;
				return new Response(stream, {
					status: 200,
					headers: { "content-type": "text/event-stream" },
				});
			}
			return new Response("not found", { status: 404 });
		}) as typeof fetch;

		const model: Model<"openai-codex-responses"> = {
			id: "gpt-5.5",
			name: "GPT-5.5",
			api: "openai-codex-responses",
			provider: "openai-codex",
			baseUrl: "https://chatgpt.com/backend-api",
			reasoning: true,
			thinkingLevelMap: { xhigh: "xhigh" },
			input: ["text"],
			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
			contextWindow: 400000,
			maxTokens: 128000,
		};
		const context: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: Date.now() }],
		};

		await streamSimpleOpenAICodexResponses(model, context, { apiKey: token, reasoning: "xhigh" }).result();

		expect(requestedReasoning).toEqual({ effort: "xhigh", summary: "auto" });
	});

	it.each(["gpt-5.3-codex", "gpt-5.4", "gpt-5.5"])("clamps %s minimal reasoning effort to low", async (modelId) => {
		const tempDir = mkdtempSync(join(tmpdir(), "pi-codex-stream-"));
		process.env.PI_CODING_AGENT_DIR = tempDir;

		const payload = Buffer.from(
			JSON.stringify({ "https://api.openai.com/auth": { chatgpt_account_id: "acc_test" } }),
			"utf8",
		).toString("base64");
		const token = `aaa.${payload}.bbb`;

		const sse = `${[
			`data: ${JSON.stringify({
				type: "response.output_item.added",
				item: { type: "message", id: "msg_1", role: "assistant", status: "in_progress", content: [] },
			})}`,
			`data: ${JSON.stringify({ type: "response.content_part.added", part: { type: "output_text", text: "" } })}`,
			`data: ${JSON.stringify({ type: "response.output_text.delta", delta: "Hello" })}`,
			`data: ${JSON.stringify({
				type: "response.output_item.done",
				item: {
					type: "message",
					id: "msg_1",
					role: "assistant",
					status: "completed",
					content: [{ type: "output_text", text: "Hello" }],
				},
			})}`,
			`data: ${JSON.stringify({
				type: "response.completed",
				response: {
					status: "completed",
					usage: {
						input_tokens: 5,
						output_tokens: 3,
						total_tokens: 8,
						input_tokens_details: { cached_tokens: 0 },
					},
				},
			})}`,
		].join("\n\n")}\n\n`;

		const encoder = new TextEncoder();
		const stream = new ReadableStream<Uint8Array>({
			start(controller) {
				controller.enqueue(encoder.encode(sse));
				controller.close();
			},
		});

		const fetchMock = vi.fn(async (input: string | URL, init?: RequestInit) => {
			const url = typeof input === "string" ? input : input.toString();
			if (url === "https://api.github.com/repos/openai/codex/releases/latest") {
				return new Response(JSON.stringify({ tag_name: "rust-v0.0.0" }), { status: 200 });
			}
			if (url.startsWith("https://raw.githubusercontent.com/openai/codex/")) {
				return new Response("PROMPT", { status: 200, headers: { etag: '"etag"' } });
			}
			if (url === "https://chatgpt.com/backend-api/codex/responses") {
				const body = typeof init?.body === "string" ? (JSON.parse(init.body) as Record<string, unknown>) : null;
				expect(body?.reasoning).toEqual({ effort: "low", summary: "auto" });

				return new Response(stream, {
					status: 200,
					headers: { "content-type": "text/event-stream" },
				});
			}
			return new Response("not found", { status: 404 });
		});

		global.fetch = fetchMock as typeof fetch;

		const model: Model<"openai-codex-responses"> = {
			id: modelId,
			name: modelId,
			api: "openai-codex-responses",
			provider: "openai-codex",
			baseUrl: "https://chatgpt.com/backend-api",
			reasoning: true,
			input: ["text"],
			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
			contextWindow: 400000,
			maxTokens: 128000,
		};

		const context: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: Date.now() }],
		};

		const streamResult = streamOpenAICodexResponses(model, context, {
			apiKey: token,
			reasoningEffort: "minimal",
		});
		await streamResult.result();
	});

	it.each([
		// "default" must stay on the wire: absence means "auto" (the project tier).
		["gpt-5.1-codex", "default", 1],
		["gpt-5.1-codex", "flex", 0.5],
		["gpt-5.1-codex", "priority", 2],
		["gpt-5.4", "priority", 2],
		["gpt-5.5", "flex", 0.5],
		["gpt-5.5", "priority", 2.5],
		["gpt-5.6-sol", "priority", 2],
	] as const)(
		"uses the client-sent %s service tier for %s when Codex echoes default",
		async (modelId, serviceTier, multiplier) => {
			const tempDir = mkdtempSync(join(tmpdir(), "pi-codex-stream-"));
			process.env.PI_CODING_AGENT_DIR = tempDir;
			const token = mockToken();
			const sse = `${[
				`data: ${JSON.stringify({
					type: "response.output_item.added",
					item: { type: "message", id: "msg_1", role: "assistant", status: "in_progress", content: [] },
				})}`,
				`data: ${JSON.stringify({ type: "response.content_part.added", part: { type: "output_text", text: "" } })}`,
				`data: ${JSON.stringify({ type: "response.output_text.delta", delta: "Hello" })}`,
				`data: ${JSON.stringify({
					type: "response.output_item.done",
					item: {
						type: "message",
						id: "msg_1",
						role: "assistant",
						status: "completed",
						content: [{ type: "output_text", text: "Hello" }],
					},
				})}`,
				`data: ${JSON.stringify({
					type: "response.completed",
					response: {
						status: "completed",
						service_tier: "default",
						usage: {
							input_tokens: 1000000,
							output_tokens: 1000000,
							total_tokens: 2000000,
							input_tokens_details: { cached_tokens: 0 },
						},
					},
				})}`,
			].join("\n\n")}\n\n`;

			const encoder = new TextEncoder();
			const stream = new ReadableStream<Uint8Array>({
				start(controller) {
					controller.enqueue(encoder.encode(sse));
					controller.close();
				},
			});

			global.fetch = vi.fn(async (input: string | URL, init?: RequestInit) => {
				const url = typeof input === "string" ? input : input.toString();
				if (url === "https://api.github.com/repos/openai/codex/releases/latest") {
					return new Response(JSON.stringify({ tag_name: "rust-v0.0.0" }), { status: 200 });
				}
				if (url.startsWith("https://raw.githubusercontent.com/openai/codex/")) {
					return new Response("PROMPT", { status: 200, headers: { etag: '"etag"' } });
				}
				if (url === "https://chatgpt.com/backend-api/codex/responses") {
					const body = JSON.parse(String(init?.body)) as { service_tier?: string };
					expect(body.service_tier).toBe(serviceTier);
					return new Response(stream, {
						status: 200,
						headers: { "content-type": "text/event-stream" },
					});
				}
				return new Response("not found", { status: 404 });
			}) as typeof fetch;

			const model: Model<"openai-codex-responses"> = {
				id: modelId,
				name: modelId === "gpt-5.5" ? "GPT-5.5" : "GPT-5.1 Codex",
				api: "openai-codex-responses",
				provider: "openai-codex",
				baseUrl: "https://chatgpt.com/backend-api",
				reasoning: true,
				input: ["text"],
				cost: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 },
				contextWindow: 400000,
				maxTokens: 128000,
			};

			const context: Context = {
				systemPrompt: "You are a helpful assistant.",
				messages: [{ role: "user", content: "Say hello", timestamp: Date.now() }],
			};

			const result = await streamOpenAICodexResponses(model, context, { apiKey: token, serviceTier }).result();

			expect(result.usage.cost.input).toBe(1 * multiplier);
			expect(result.usage.cost.output).toBe(2 * multiplier);
			expect(result.usage.cost.total).toBe(3 * multiplier);
		},
	);

	it("does not set session_id/x-client-request-id headers when sessionId is not provided", async () => {
		const tempDir = mkdtempSync(join(tmpdir(), "pi-codex-stream-"));
		process.env.PI_CODING_AGENT_DIR = tempDir;

		const payload = Buffer.from(
			JSON.stringify({ "https://api.openai.com/auth": { chatgpt_account_id: "acc_test" } }),
			"utf8",
		).toString("base64");
		const token = `aaa.${payload}.bbb`;

		const sse = `${[
			`data: ${JSON.stringify({
				type: "response.output_item.added",
				item: { type: "message", id: "msg_1", role: "assistant", status: "in_progress", content: [] },
			})}`,
			`data: ${JSON.stringify({ type: "response.content_part.added", part: { type: "output_text", text: "" } })}`,
			`data: ${JSON.stringify({ type: "response.output_text.delta", delta: "Hello" })}`,
			`data: ${JSON.stringify({
				type: "response.output_item.done",
				item: {
					type: "message",
					id: "msg_1",
					role: "assistant",
					status: "completed",
					content: [{ type: "output_text", text: "Hello" }],
				},
			})}`,
			`data: ${JSON.stringify({
				type: "response.completed",
				response: {
					status: "completed",
					usage: {
						input_tokens: 5,
						output_tokens: 3,
						total_tokens: 8,
						input_tokens_details: { cached_tokens: 0 },
					},
				},
			})}`,
		].join("\n\n")}\n\n`;

		const encoder = new TextEncoder();
		const stream = new ReadableStream<Uint8Array>({
			start(controller) {
				controller.enqueue(encoder.encode(sse));
				controller.close();
			},
		});

		const fetchMock = vi.fn(async (input: string | URL, init?: RequestInit) => {
			const url = typeof input === "string" ? input : input.toString();
			if (url === "https://api.github.com/repos/openai/codex/releases/latest") {
				return new Response(JSON.stringify({ tag_name: "rust-v0.0.0" }), { status: 200 });
			}
			if (url.startsWith("https://raw.githubusercontent.com/openai/codex/")) {
				return new Response("PROMPT", { status: 200, headers: { etag: '"etag"' } });
			}
			if (url === "https://chatgpt.com/backend-api/codex/responses") {
				const headers = init?.headers instanceof Headers ? init.headers : undefined;
				expect(headers?.has("session_id")).toBe(false);
				expect(headers?.has("x-client-request-id")).toBe(false);

				return new Response(stream, {
					status: 200,
					headers: { "content-type": "text/event-stream" },
				});
			}
			return new Response("not found", { status: 404 });
		});

		global.fetch = fetchMock as typeof fetch;

		const model: Model<"openai-codex-responses"> = {
			id: "gpt-5.1-codex",
			name: "GPT-5.1 Codex",
			api: "openai-codex-responses",
			provider: "openai-codex",
			baseUrl: "https://chatgpt.com/backend-api",
			reasoning: true,
			input: ["text"],
			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
			contextWindow: 400000,
			maxTokens: 128000,
		};

		const context: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: Date.now() }],
		};

		const streamResult = streamOpenAICodexResponses(model, context, { apiKey: token });
		await streamResult.result();
	});
	it("forwards auto transport from streamSimple options and uses cached websocket context", async () => {
		const token = mockToken();
		const sentBodies: unknown[] = [];

		global.fetch = vi.fn(async () => new Response("unexpected fetch", { status: 500 })) as typeof fetch;

		class MockWebSocket {
			private listeners = new Map<string, Set<(event: unknown) => void>>();

			constructor(_url: string, _protocols?: string | string[] | { headers?: Record<string, string> }) {
				queueMicrotask(() => this.dispatch("open", {}));
			}

			addEventListener(type: string, listener: (event: unknown) => void): void {
				let listeners = this.listeners.get(type);
				if (!listeners) {
					listeners = new Set();
					this.listeners.set(type, listeners);
				}
				listeners.add(listener);
			}

			removeEventListener(type: string, listener: (event: unknown) => void): void {
				this.listeners.get(type)?.delete(listener);
			}

			send(data: string): void {
				sentBodies.push(JSON.parse(data));
				const events = [
					{
						type: "response.output_item.added",
						item: { type: "message", id: "msg_1", role: "assistant", status: "in_progress", content: [] },
					},
					{ type: "response.content_part.added", part: { type: "output_text", text: "" } },
					{ type: "response.output_text.delta", delta: "Hello" },
					{
						type: "response.output_item.done",
						item: {
							type: "message",
							id: "msg_1",
							role: "assistant",
							status: "completed",
							content: [{ type: "output_text", text: "Hello" }],
						},
					},
					{
						type: "response.completed",
						response: {
							status: "completed",
							usage: {
								input_tokens: 5,
								output_tokens: 3,
								total_tokens: 8,
								input_tokens_details: { cached_tokens: 0 },
							},
						},
					},
				];
				queueMicrotask(() => {
					for (const event of events) {
						this.dispatch("message", { data: JSON.stringify(event) });
					}
				});
			}

			close(): void {}

			private dispatch(type: string, event: unknown): void {
				for (const listener of this.listeners.get(type) ?? []) {
					listener(event);
				}
			}
		}

		globalThis.WebSocket = MockWebSocket as unknown as typeof WebSocket;

		const model: Model<"openai-codex-responses"> = {
			id: "gpt-5.1-codex",
			name: "GPT-5.1 Codex",
			api: "openai-codex-responses",
			provider: "openai-codex",
			baseUrl: "https://chatgpt.com/backend-api",
			reasoning: true,
			input: ["text"],
			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
			contextWindow: 400000,
			maxTokens: 128000,
		};
		const context: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: 1 }],
		};

		await streamSimpleOpenAICodexResponses(model, context, {
			apiKey: token,
			sessionId: "session-auto",
			transport: "auto",
		}).result();

		expect(sentBodies).toHaveLength(1);
		expect(global.fetch).not.toHaveBeenCalled();
		expect(getOpenAICodexWebSocketDebugStats("session-auto")).toMatchObject({
			cachedContextRequests: 1,
			fullContextRequests: 1,
		});
	});

	it("uses SSE on the next turn after a WebSocket response is terminated", async () => {
		class TerminatedWebSocket {
			private listeners = new Map<string, Set<(event: unknown) => void>>();

			constructor() {
				queueMicrotask(() => this.dispatch("open", {}));
			}

			addEventListener(type: string, listener: (event: unknown) => void): void {
				const listeners = this.listeners.get(type) ?? new Set();
				listeners.add(listener);
				this.listeners.set(type, listeners);
			}

			removeEventListener(type: string, listener: (event: unknown) => void): void {
				this.listeners.get(type)?.delete(listener);
			}

			send(): void {
				queueMicrotask(() => {
					this.dispatch("message", {
						data: JSON.stringify({ type: "response.created", response: { id: "response-1" } }),
					});
					this.dispatch("message", {
						data: JSON.stringify({
							type: "response.failed",
							response: { error: { code: "terminated", message: "terminated" } },
						}),
					});
				});
			}

			close(): void {}

			private dispatch(type: string, event: unknown): void {
				for (const listener of this.listeners.get(type) ?? []) listener(event);
			}
		}

		globalThis.WebSocket = TerminatedWebSocket as unknown as typeof WebSocket;
		const fetchCounter = stubCodexFetch(
			() =>
				new Response(buildSSEPayload({ status: "completed" }), {
					status: 200,
					headers: { "content-type": "text/event-stream" },
				}),
		);
		const context: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: 1 }],
		};
		const options = { apiKey: mockToken(), sessionId: "terminated-session", transport: "auto" as const };

		const failed = await streamOpenAICodexResponses(codexTestModel(), context, options).result();
		expect(failed.stopReason).toBe("error");
		expect(failureDetails(failed)).toMatchObject({ kind: "server_error", providerErrorType: "terminated" });
		expect(getOpenAICodexWebSocketDebugStats("terminated-session")).toMatchObject({
			websocketFailures: 1,
			websocketFallbackActive: true,
		});

		const recovered = await streamOpenAICodexResponses(codexTestModel(), context, options).result();
		expect(recovered.stopReason).toBe("stop");
		expect(fetchCounter.responsesRequests).toBe(1);

		const explicitWebSocket = await streamOpenAICodexResponses(codexTestModel(), context, {
			...options,
			transport: "websocket",
		}).result();
		expect(explicitWebSocket.stopReason).toBe("error");
		expect(fetchCounter.responsesRequests).toBe(1);
		expect(getOpenAICodexWebSocketDebugStats("terminated-session")?.websocketFailures).toBe(2);
	});

	it("sends only response input deltas in websocket-cached mode", async () => {
		const token = mockToken();
		const sentBodies: unknown[] = [];
		const responses = [
			{ responseId: "resp_1", messageId: "msg_1", text: "Hello" },
			{ responseId: "resp_2", messageId: "msg_2", text: "Done" },
		];

		class MockWebSocket {
			static OPEN = 1;
			readyState = MockWebSocket.OPEN;
			private listeners = new Map<string, Set<(event: unknown) => void>>();

			constructor(_url: string, _protocols?: string | string[] | { headers?: Record<string, string> }) {
				queueMicrotask(() => this.dispatch("open", {}));
			}

			addEventListener(type: string, listener: (event: unknown) => void): void {
				let listeners = this.listeners.get(type);
				if (!listeners) {
					listeners = new Set();
					this.listeners.set(type, listeners);
				}
				listeners.add(listener);
			}

			removeEventListener(type: string, listener: (event: unknown) => void): void {
				this.listeners.get(type)?.delete(listener);
			}

			send(data: string): void {
				sentBodies.push(JSON.parse(data));
				const response = responses.shift();
				if (!response) throw new Error("unexpected websocket request");
				const events = [
					{ type: "response.created", response: { id: response.responseId } },
					{
						type: "response.output_item.added",
						item: {
							type: "message",
							id: response.messageId,
							role: "assistant",
							status: "in_progress",
							content: [],
						},
					},
					{ type: "response.content_part.added", part: { type: "output_text", text: "" } },
					{ type: "response.output_text.delta", delta: response.text },
					{
						type: "response.output_item.done",
						item: {
							type: "message",
							id: response.messageId,
							role: "assistant",
							status: "completed",
							content: [{ type: "output_text", text: response.text }],
						},
					},
					{
						type: "response.completed",
						response: {
							id: response.responseId,
							status: "completed",
							usage: {
								input_tokens: 5,
								output_tokens: 3,
								total_tokens: 8,
								input_tokens_details: { cached_tokens: 0 },
							},
						},
					},
				];
				queueMicrotask(() => {
					for (const event of events) {
						this.dispatch("message", { data: JSON.stringify(event) });
					}
				});
			}

			close(): void {
				this.readyState = 3;
			}

			private dispatch(type: string, event: unknown): void {
				for (const listener of this.listeners.get(type) ?? []) {
					listener(event);
				}
			}
		}

		globalThis.WebSocket = MockWebSocket as unknown as typeof WebSocket;

		const model: Model<"openai-codex-responses"> = {
			id: "gpt-5.1-codex",
			name: "GPT-5.1 Codex",
			api: "openai-codex-responses",
			provider: "openai-codex",
			baseUrl: "https://chatgpt.com/backend-api",
			reasoning: true,
			input: ["text"],
			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
			contextWindow: 400000,
			maxTokens: 128000,
		};
		const firstContext: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: 1 }],
		};

		const first = await streamOpenAICodexResponses(model, firstContext, {
			apiKey: token,
			sessionId: "session-1",
			transport: "websocket-cached",
		}).result();

		const secondContext: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [...firstContext.messages, first, { role: "user", content: "Now finish", timestamp: 2 }],
		};
		await streamOpenAICodexResponses(model, secondContext, {
			apiKey: token,
			sessionId: "session-1",
			transport: "websocket-cached",
		}).result();

		expect(sentBodies).toHaveLength(2);
		const firstBody = sentBodies[0] as { input: unknown[]; previous_response_id?: string; store?: boolean };
		const secondBody = sentBodies[1] as { input: unknown[]; previous_response_id?: string; store?: boolean };
		expect(firstBody.store).toBe(false);
		expect(firstBody.previous_response_id).toBeUndefined();
		expect(firstBody.input).toEqual([{ role: "user", content: [{ type: "input_text", text: "Say hello" }] }]);
		expect(secondBody.store).toBe(false);
		expect(secondBody.previous_response_id).toBe("resp_1");
		expect(secondBody.input).toEqual([{ role: "user", content: [{ type: "input_text", text: "Now finish" }] }]);
		expect(getOpenAICodexWebSocketDebugStats("session-1")).toMatchObject({
			requests: 2,
			connectionsCreated: 1,
			connectionsReused: 1,
			cachedContextRequests: 2,
			storeTrueRequests: 0,
			fullContextRequests: 1,
			deltaRequests: 1,
			lastDeltaInputItems: 1,
			lastPreviousResponseId: "resp_1",
		});
	});

	it("sends full context without a stale previous_response_id after a reconnect and re-anchors", async () => {
		const token = mockToken();
		let firstSocket: ScriptedWebSocketHandle | undefined;
		const sentBodies = installScriptedCodexWebSocket([
			(socket) => {
				firstSocket = socket;
				socket.emit(codexResponseEvents({ responseId: "resp_1", messageId: "msg_1", text: "Hello" }));
			},
			(socket) => socket.emit(codexResponseEvents({ responseId: "resp_2", messageId: "msg_2", text: "Done" })),
			(socket) => socket.emit(codexResponseEvents({ responseId: "resp_3", messageId: "msg_3", text: "Again" })),
		]);

		const model = codexTestModel();
		const firstContext: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: 1 }],
		};
		const first = await streamOpenAICodexResponses(model, firstContext, {
			apiKey: token,
			sessionId: "session-reconnect",
			transport: "websocket-cached",
		}).result();

		// The server dropped the connection during the idle gap between turns.
		firstSocket?.drop();

		const secondContext: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [...firstContext.messages, first, { role: "user", content: "Now finish", timestamp: 2 }],
		};
		const second = await streamOpenAICodexResponses(model, secondContext, {
			apiKey: token,
			sessionId: "session-reconnect",
			transport: "websocket-cached",
		}).result();

		expect(second.stopReason).toBe("stop");

		const thirdContext: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [...secondContext.messages, second, { role: "user", content: "And again", timestamp: 3 }],
		};
		await streamOpenAICodexResponses(model, thirdContext, {
			apiKey: token,
			sessionId: "session-reconnect",
			transport: "websocket-cached",
		}).result();

		expect(sentBodies).toHaveLength(3);
		const reconnectedBody = sentBodies[1] as { previous_response_id?: string; input: unknown[] };
		const resumedBody = sentBodies[2] as { previous_response_id?: string; input: unknown[] };
		// The reconnected connection starts from the full context, never the dead
		// connection's previous_response_id.
		expect(reconnectedBody.previous_response_id).toBeUndefined();
		expect(reconnectedBody.input).toEqual([
			{ role: "user", content: [{ type: "input_text", text: "Say hello" }] },
			{
				type: "message",
				role: "assistant",
				content: [{ type: "output_text", text: "Hello", annotations: [] }],
				status: "completed",
				id: "msg_1",
			},
			{ role: "user", content: [{ type: "input_text", text: "Now finish" }] },
		]);
		// The chain re-anchors on the reconnected connection's response.
		expect(resumedBody.previous_response_id).toBe("resp_2");
		expect(resumedBody.input).toEqual([{ role: "user", content: [{ type: "input_text", text: "And again" }] }]);
		expect(global.fetch).not.toHaveBeenCalled();
		expect(getOpenAICodexWebSocketDebugStats("session-reconnect")).toMatchObject({
			requests: 3,
			connectionsCreated: 2,
			connectionsReused: 1,
			fullContextRequests: 2,
			deltaRequests: 1,
			lastPreviousResponseId: "resp_2",
		});
	});

	it("recovers a stale previous_response_id with one full-context chain-reset retry", async () => {
		const token = mockToken();
		const sentBodies = installScriptedCodexWebSocket([
			(socket) => socket.emit(codexResponseEvents({ responseId: "resp_1", messageId: "msg_1", text: "Hello" })),
			(socket) =>
				socket.emit(
					codexErrorEvents("previous_response_not_found", "Previous response with id 'resp_1' not found"),
				),
			(socket) => socket.emit(codexResponseEvents({ responseId: "resp_2", messageId: "msg_2", text: "Done" })),
			(socket) => socket.emit(codexResponseEvents({ responseId: "resp_3", messageId: "msg_3", text: "Again" })),
		]);

		const model = codexTestModel();
		const firstContext: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: 1 }],
		};

		const first = await streamOpenAICodexResponses(model, firstContext, {
			apiKey: token,
			sessionId: "session-chain-reset",
			transport: "websocket-cached",
		}).result();

		const secondContext: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [...firstContext.messages, first, { role: "user", content: "Now finish", timestamp: 2 }],
		};
		const second = await streamOpenAICodexResponses(model, secondContext, {
			apiKey: token,
			sessionId: "session-chain-reset",
			transport: "websocket-cached",
		}).result();

		// The stale continuation was recovered within the same turn.
		expect(second.stopReason).toBe("stop");
		expect(second.content[0]).toMatchObject({ type: "text", text: "Done" });

		// A later turn proves the chain resumed from the retried response.
		const thirdContext: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [...secondContext.messages, second, { role: "user", content: "And again", timestamp: 3 }],
		};
		await streamOpenAICodexResponses(model, thirdContext, {
			apiKey: token,
			sessionId: "session-chain-reset",
			transport: "websocket-cached",
		}).result();

		expect(sentBodies).toHaveLength(4);
		const deltaBody = sentBodies[1] as { previous_response_id?: string; input: unknown[] };
		const retryBody = sentBodies[2] as { previous_response_id?: string; input: unknown[] };
		const resumedBody = sentBodies[3] as { previous_response_id?: string; input: unknown[] };
		expect(deltaBody.previous_response_id).toBe("resp_1");
		expect(deltaBody.input).toEqual([{ role: "user", content: [{ type: "input_text", text: "Now finish" }] }]);
		// The chain reset resends the full request body without previous_response_id.
		expect(retryBody.previous_response_id).toBeUndefined();
		expect(retryBody.input).toEqual([
			{ role: "user", content: [{ type: "input_text", text: "Say hello" }] },
			{
				type: "message",
				role: "assistant",
				content: [{ type: "output_text", text: "Hello", annotations: [] }],
				status: "completed",
				id: "msg_1",
			},
			{ role: "user", content: [{ type: "input_text", text: "Now finish" }] },
		]);
		expect(resumedBody.previous_response_id).toBe("resp_2");
		expect(resumedBody.input).toEqual([{ role: "user", content: [{ type: "input_text", text: "And again" }] }]);
		expect(global.fetch).not.toHaveBeenCalled();
		expect(getOpenAICodexWebSocketDebugStats("session-chain-reset")).toMatchObject({
			requests: 4,
			connectionsCreated: 2,
			connectionsReused: 2,
			cachedContextRequests: 4,
			fullContextRequests: 2,
			deltaRequests: 2,
			websocketFailures: 0,
			sseFallbacks: 0,
		});
	});

	it("surfaces the error without further retries when the chain-reset retry fails again", async () => {
		const token = mockToken();
		const sentBodies = installScriptedCodexWebSocket([
			(socket) => socket.emit(codexResponseEvents({ responseId: "resp_1", messageId: "msg_1", text: "Hello" })),
			(socket) =>
				socket.emit(
					codexErrorEvents("previous_response_not_found", "Previous response with id 'resp_1' not found"),
				),
			(socket) =>
				socket.emit(
					codexErrorEvents("previous_response_not_found", "Previous response with id 'resp_9' not found"),
				),
		]);

		const model = codexTestModel();
		const firstContext: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: 1 }],
		};
		const first = await streamOpenAICodexResponses(model, firstContext, {
			apiKey: token,
			sessionId: "session-chain-reset-fail",
			transport: "websocket-cached",
		}).result();

		const secondContext: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [...firstContext.messages, first, { role: "user", content: "Now finish", timestamp: 2 }],
		};
		const second = await streamOpenAICodexResponses(model, secondContext, {
			apiKey: token,
			sessionId: "session-chain-reset-fail",
			transport: "websocket-cached",
		}).result();

		expect(second.stopReason).toBe("error");
		expect(second.errorMessage).toBe("Codex error: Previous response with id 'resp_9' not found");
		// Exactly one chain-reset retry, then the error surfaces unchanged.
		expect(sentBodies).toHaveLength(3);
		const retryBody = sentBodies[2] as { previous_response_id?: string };
		expect(retryBody.previous_response_id).toBeUndefined();
		expect(global.fetch).not.toHaveBeenCalled();
		expect(failureDetails(second)).toMatchObject({ providerErrorType: "previous_response_not_found" });
	});

	it("does not chain-reset retry other codex api errors", async () => {
		const token = mockToken();
		const sentBodies = installScriptedCodexWebSocket([
			(socket) => socket.emit(codexResponseEvents({ responseId: "resp_1", messageId: "msg_1", text: "Hello" })),
			(socket) => socket.emit(codexErrorEvents("invalid_request", "Invalid request")),
		]);

		const model = codexTestModel();
		const firstContext: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: 1 }],
		};
		const first = await streamOpenAICodexResponses(model, firstContext, {
			apiKey: token,
			sessionId: "session-chain-reset-other",
			transport: "websocket-cached",
		}).result();

		const secondContext: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [...firstContext.messages, first, { role: "user", content: "Now finish", timestamp: 2 }],
		};
		const second = await streamOpenAICodexResponses(model, secondContext, {
			apiKey: token,
			sessionId: "session-chain-reset-other",
			transport: "websocket-cached",
		}).result();

		expect(second.stopReason).toBe("error");
		expect(second.errorMessage).toBe("Codex error: Invalid request");
		expect(sentBodies).toHaveLength(2);
		expect(global.fetch).not.toHaveBeenCalled();
	});

	function codexTestModel(): Model<"openai-codex-responses"> {
		return {
			id: "gpt-5.1-codex",
			name: "GPT-5.1 Codex",
			api: "openai-codex-responses",
			provider: "openai-codex",
			baseUrl: "https://chatgpt.com/backend-api",
			reasoning: true,
			input: ["text"],
			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
			contextWindow: 400000,
			maxTokens: 128000,
		};
	}

	/** Stub prompt-cache URLs plus a custom /codex/responses handler; returns the request counter. */
	function stubCodexFetch(respond: () => Response): { responsesRequests: number } {
		process.env.PI_CODING_AGENT_DIR = mkdtempSync(join(tmpdir(), "pi-codex-stream-"));
		const counter = { responsesRequests: 0 };
		global.fetch = vi.fn(async (input: string | URL) => {
			const url = typeof input === "string" ? input : input.toString();
			if (url === "https://api.github.com/repos/openai/codex/releases/latest") {
				return new Response(JSON.stringify({ tag_name: "rust-v0.0.0" }), { status: 200 });
			}
			if (url.startsWith("https://raw.githubusercontent.com/openai/codex/")) {
				return new Response("PROMPT", { status: 200, headers: { etag: '"etag"' } });
			}
			if (url === "https://chatgpt.com/backend-api/codex/responses") {
				counter.responsesRequests++;
				return respond();
			}
			return new Response("not found", { status: 404 });
		}) as typeof fetch;
		return counter;
	}

	async function runCodexErrorTurn(): Promise<AssistantMessage> {
		const context: Context = {
			systemPrompt: "You are a helpful assistant.",
			messages: [{ role: "user", content: "Say hello", timestamp: Date.now() }],
		};
		return streamOpenAICodexResponses(codexTestModel(), context, { apiKey: mockToken(), transport: "sse" }).result();
	}

	function failureDetails(result: AssistantMessage): { kind?: string; retryAfterMs?: number } | undefined {
		const last = result.diagnostics?.at(-1);
		return last?.type === "provider_stream_failure"
			? (last as { details?: { kind?: string; retryAfterMs?: number } }).details
			: undefined;
	}

	/** Handle the send scripts use to drive a mocked websocket connection. */
	interface ScriptedWebSocketHandle {
		emit: (events: unknown[]) => void;
		/** Simulate the server dropping the connection between turns. */
		drop: () => void;
	}

	/**
	 * Install a scripted WebSocket mock: every websocket send consumes one
	 * script entry (across socket instances, so reconnects stay scripted) and
	 * fetch is stubbed so an unexpected SSE fallback fails fast.
	 */
	function installScriptedCodexWebSocket(
		scripts: Array<(socket: ScriptedWebSocketHandle) => void>,
	): Record<string, unknown>[] {
		const sentBodies: Record<string, unknown>[] = [];

		class MockWebSocket {
			static OPEN = 1;
			readyState = MockWebSocket.OPEN;
			private listeners = new Map<string, Set<(event: unknown) => void>>();

			constructor(_url: string, _protocols?: string | string[] | { headers?: Record<string, string> }) {
				queueMicrotask(() => this.dispatch("open", {}));
			}

			addEventListener(type: string, listener: (event: unknown) => void): void {
				let listeners = this.listeners.get(type);
				if (!listeners) {
					listeners = new Set();
					this.listeners.set(type, listeners);
				}
				listeners.add(listener);
			}

			removeEventListener(type: string, listener: (event: unknown) => void): void {
				this.listeners.get(type)?.delete(listener);
			}

			send(data: string): void {
				sentBodies.push(JSON.parse(data) as Record<string, unknown>);
				const script = scripts.shift();
				if (!script) throw new Error("unexpected websocket request");
				queueMicrotask(() =>
					script({
						emit: (events: unknown[]) => this.emit(events),
						drop: () => {
							this.readyState = 3;
						},
					}),
				);
			}

			close(): void {
				this.readyState = 3;
			}

			emit(events: unknown[]): void {
				for (const event of events) {
					this.dispatch("message", { data: JSON.stringify(event) });
				}
			}

			private dispatch(type: string, event: unknown): void {
				for (const listener of this.listeners.get(type) ?? []) {
					listener(event);
				}
			}
		}

		global.fetch = vi.fn(async () => new Response("unexpected fetch", { status: 500 })) as typeof fetch;
		globalThis.WebSocket = MockWebSocket as unknown as typeof WebSocket;
		return sentBodies;
	}

	function codexResponseEvents({
		responseId,
		messageId,
		text,
	}: {
		responseId: string;
		messageId: string;
		text: string;
	}): unknown[] {
		return [
			{ type: "response.created", response: { id: responseId } },
			{
				type: "response.output_item.added",
				item: { type: "message", id: messageId, role: "assistant", status: "in_progress", content: [] },
			},
			{ type: "response.content_part.added", part: { type: "output_text", text: "" } },
			{ type: "response.output_text.delta", delta: text },
			{
				type: "response.output_item.done",
				item: {
					type: "message",
					id: messageId,
					role: "assistant",
					status: "completed",
					content: [{ type: "output_text", text }],
				},
			},
			{
				type: "response.completed",
				response: {
					id: responseId,
					status: "completed",
					usage: {
						input_tokens: 5,
						output_tokens: 3,
						total_tokens: 8,
						input_tokens_details: { cached_tokens: 0 },
					},
				},
			},
		];
	}

	function codexErrorEvents(code: string, message: string): unknown[] {
		return [{ type: "error", code, message }];
	}

	it("throws a structured failure after a single attempt on HTTP 500", async () => {
		const counter = stubCodexFetch(
			() => new Response(JSON.stringify({ error: { type: "server_error", message: "boom" } }), { status: 500 }),
		);

		const result = await runCodexErrorTurn();

		expect(counter.responsesRequests).toBe(1);
		expect(result.stopReason).toBe("error");
		expect(result.errorMessage).toBe("boom");
		expect(failureDetails(result)).toMatchObject({ kind: "server_error", status: 500 });
	});

	it("maps nested streaming usage-limit error payloads to a friendly rate-limit failure", async () => {
		const resetsAt = Math.round(Date.now() / 1000) + 2 * 3600;
		const sse = `data: ${JSON.stringify({
			type: "error",
			status_code: 429,
			error: { type: "usage_limit_reached", message: "Usage limit reached", plan_type: "Plus", resets_at: resetsAt },
		})}\n\n`;
		stubCodexFetch(() => new Response(sse, { status: 200, headers: { "content-type": "text/event-stream" } }));

		const result = await runCodexErrorTurn();

		expect(result.stopReason).toBe("error");
		expect(result.errorMessage).toContain(
			"You have hit your ChatGPT usage limit (plus plan). Try again in ~120 min.",
		);
		const details = failureDetails(result);
		expect(details?.kind).toBe("rate_limit");
		expect(details?.retryAfterMs).toBeGreaterThan(0);
		// resets_at has second granularity, so allow the rounding slack.
		expect(details?.retryAfterMs).toBeLessThanOrEqual(2 * 3600 * 1000 + 1000);
	});

	it("maps flat streaming usage-limit payloads", async () => {
		const resetsAt = Math.round(Date.now() / 1000) + 2 * 3600;
		const sse = `data: ${JSON.stringify({
			type: "error",
			status_code: 429,
			code: "usage_limit_reached",
			message: "Usage limit reached",
			plan_type: "Team",
			resets_at: resetsAt,
		})}\n\n`;
		stubCodexFetch(() => new Response(sse, { status: 200, headers: { "content-type": "text/event-stream" } }));

		const result = await runCodexErrorTurn();

		expect(result.errorMessage).toContain("You have hit your ChatGPT usage limit (team plan).");
		expect(failureDetails(result)).toMatchObject({ kind: "rate_limit" });
	});

	it("preserves structured exhausted-quota details from response.failed", async () => {
		const resetsAt = Math.round(Date.now() / 1000) + 2 * 3600;
		const sse = `data: ${JSON.stringify({
			type: "response.failed",
			response: {
				status_code: 429,
				error: {
					type: "insufficient_quota",
					message: "Quota exhausted",
					plan_type: "Plus",
					resets_at: resetsAt,
				},
			},
		})}\n\n`;
		stubCodexFetch(() => new Response(sse, { status: 200, headers: { "content-type": "text/event-stream" } }));

		const result = await runCodexErrorTurn();

		expect(result.errorMessage).toContain("You have hit your ChatGPT usage limit (plus plan).");
		expect(failureDetails(result)).toMatchObject({ kind: "quota_exhausted", status: 429 });
	});

	it("maps flat HTTP exhausted-quota payloads", async () => {
		stubCodexFetch(
			() =>
				new Response(JSON.stringify({ code: "insufficient_quota", message: "Quota exhausted" }), {
					status: 429,
					headers: { "retry-after": "60" },
				}),
		);

		const result = await runCodexErrorTurn();

		expect(result.errorMessage).toBe("You have hit your ChatGPT usage limit.");
		expect(failureDetails(result)).toMatchObject({ kind: "quota_exhausted", status: 429, retryAfterMs: 60000 });
	});

	it("waits for the longer of Retry-After header and usage-limit reset", async () => {
		const resetsAt = Math.round(Date.now() / 1000) + 10;
		stubCodexFetch(
			() =>
				new Response(
					JSON.stringify({
						error: { type: "usage_limit_reached", message: "Usage limit reached", resets_at: resetsAt },
					}),
					{ status: 429, headers: { "retry-after": "60" } },
				),
		);

		const result = await runCodexErrorTurn();

		expect(result.stopReason).toBe("error");
		expect(failureDetails(result)?.retryAfterMs).toBe(60000);
	});
});

describe("openai-responses shared conversions", () => {
	const responsesModel: Model<"openai-responses"> = {
		id: "gpt-5-mini",
		name: "GPT-5 Mini",
		api: "openai-responses",
		provider: "openai",
		baseUrl: "https://api.openai.com/v1",
		reasoning: true,
		input: ["text", "image"],
		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
		contextWindow: 400000,
		maxTokens: 128000,
	};

	const emptyUsage = {
		input: 0,
		output: 0,
		cacheRead: 0,
		cacheWrite: 0,
		totalTokens: 0,
		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
	};

	function toolResultContext(toolResult: ToolResultMessage): Context {
		return {
			messages: [
				{ role: "user", content: "Run it", timestamp: 1 },
				{
					role: "assistant",
					content: [{ type: "toolCall", id: "tool-1", name: toolResult.toolName, arguments: {} }],
					api: "openai-responses",
					provider: "openai",
					model: responsesModel.id,
					usage: emptyUsage,
					stopReason: "toolUse",
					timestamp: 2,
				} satisfies AssistantMessage,
				toolResult,
			],
		};
	}

	function toolResult(toolName: string, content: ToolResultMessage["content"]): ToolResultMessage {
		return { role: "toolResult", toolCallId: "tool-1", toolName, content, isError: false, timestamp: 3 };
	}

	it("removes partialJson from persisted tool-call blocks at output_item.done", async () => {
		const argumentsJson = '{"path":"README.md","content":"updated"}';
		async function* events(): AsyncIterable<ResponseStreamEvent> {
			const item = { type: "function_call", id: "fc_test", call_id: "call_test", name: "edit" };
			yield { type: "response.output_item.added", item: { ...item, arguments: "" } } as ResponseStreamEvent;
			yield { type: "response.function_call_arguments.delta", delta: '{"path":"README.md"' } as ResponseStreamEvent;
			yield {
				type: "response.function_call_arguments.delta",
				delta: ',"content":"updated"}',
			} as ResponseStreamEvent;
			yield { type: "response.function_call_arguments.done", arguments: argumentsJson } as ResponseStreamEvent;
			yield {
				type: "response.output_item.done",
				item: { ...item, arguments: argumentsJson },
			} as ResponseStreamEvent;
		}

		const output: AssistantMessage = {
			role: "assistant",
			content: [],
			api: responsesModel.api,
			provider: responsesModel.provider,
			model: responsesModel.id,
			usage: emptyUsage,
			stopReason: "stop",
			timestamp: 1,
		};
		const stream = new AssistantMessageEventStream();

		await processResponsesStream(events(), output, stream, responsesModel);

		expect(output.content).toHaveLength(1);
		const persisted = output.content[0];
		if (persisted?.type !== "toolCall") throw new Error("Expected toolCall block");
		expect(persisted.arguments).toEqual({ path: "README.md", content: "updated" });
		expect("partialJson" in persisted).toBe(false);
	});

	it("does not emit the image placeholder for empty-text tool results with no image", () => {
		const messages = convertResponsesMessages(
			responsesModel,
			toolResultContext(toolResult("bash", [{ type: "text", text: "" }])),
			new Set(["openai"]),
		);

		expect(messages.find((message) => message.type === "function_call_output")?.output).toBe("");
	});

	it("still attaches images for tool results that contain an image", () => {
		const messages = convertResponsesMessages(
			responsesModel,
			toolResultContext(toolResult("read", [{ type: "image", data: "ZmFrZQ==", mimeType: "image/png" }])),
			new Set(["openai"]),
		);

		const output = messages.find((message) => message.type === "function_call_output")?.output;
		expect(Array.isArray(output)).toBe(true);
		expect((output as Array<{ type?: string }>).some((part) => part.type === "input_image")).toBe(true);
	});
});

describe("fast mode", () => {
	function fastModeModel(provider: string, id: string, api: Api): Model<Api> {
		return {
			id,
			name: id,
			api,
			provider,
			baseUrl: "https://example.com",
			reasoning: true,
			input: ["text"],
			cost: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0 },
			contextWindow: 1000,
			maxTokens: 100,
		};
	}

	it.each([
		{ provider: "openai-codex", id: "gpt-5.4", api: "openai-codex-responses" as Api, supported: true },
		{ provider: "openai-codex", id: "gpt-5.5", api: "openai-codex-responses" as Api, supported: true },
		{ provider: "openai-codex", id: "gpt-5.6-luna", api: "openai-codex-responses" as Api, supported: true },
		{ provider: "openai-codex", id: "gpt-5.3-codex", api: "openai-codex-responses" as Api, supported: false },
		{ provider: "openai-codex", id: "gpt-5.4-mini", api: "openai-codex-responses" as Api, supported: false },
		{ provider: "openai", id: "gpt-5.1", api: "openai-responses" as Api, supported: false },
		{ provider: "openai", id: "gpt-5.5", api: "openai-responses" as Api, supported: true },
		{ provider: "github-copilot", id: "gpt-5.5", api: "openai-responses" as Api, supported: false },
	])("gates $provider/$id at $supported", ({ provider, id, api, supported }) => {
		expect(supportsFastMode(fastModeModel(provider, id, api))).toBe(supported);
	});

	it.each(["openai-codex", "openai"])("forwards priority service tier for %s models", (provider) => {
		const api: Api = provider === "openai-codex" ? "openai-codex-responses" : "openai-responses";
		expect(buildBaseOptions(fastModeModel(provider, "gpt-5.5", api), { serviceTier: "priority" }).serviceTier).toBe(
			"priority",
		);
	});
});