feat: add Codex Mini support using existing GPT-5 infrastructure

- Add codex-mini-latest model definition with pricing (.5/M input, /M output)
- Reuse existing v1/responses endpoint infrastructure (same as GPT-5)
- Add isResponsesApiModel() method to identify models using responses endpoint
- Rename handleGpt5Message to handleResponsesApiMessage for clarity
- Add comprehensive test coverage for Codex Mini
- Fix error handling in GPT-5 stream handler to properly re-throw API errors
- Use generic 'Responses API' error messages since both models share the endpoint

The implementation keeps the GPT-5 path completely unchanged while allowing
Codex Mini to reuse the same infrastructure with minimal code changes.

Author: daniel-lxs

src/api/providers/__tests__/openai-native.spec.ts

@@ -1545,7 +1545,11 @@ describe("GPT-5 streaming event coverage (additional)", () => {
 								'data: {"type":"response.output_text.delta","delta":" Mini!"}\n\n',
 							),
 						)
-						controller.enqueue(new TextEncoder().encode('data: {"type":"response.completed"}\n\n'))
+						controller.enqueue(
+							new TextEncoder().encode(
+								'data: {"type":"response.done","response":{"usage":{"prompt_tokens":50,"completion_tokens":10}}}\n\n',
+							),
+						)
 						controller.enqueue(new TextEncoder().encode("data: [DONE]\n\n"))
 						controller.close()
 					},
@@ -1574,18 +1578,19 @@ describe("GPT-5 streaming event coverage (additional)", () => {
 			expect(textChunks).toHaveLength(4)
 			expect(textChunks.map((c) => c.text).join("")).toBe("Hello from Codex Mini!")
 
-			// Verify usage estimation (based on character count)
+			// Verify usage data from API
 			const usageChunks = chunks.filter((c) => c.type === "usage")
 			expect(usageChunks).toHaveLength(1)
 			expect(usageChunks[0]).toMatchObject({
 				type: "usage",
-				inputTokens: expect.any(Number),
-				outputTokens: expect.any(Number),
+				inputTokens: 50,
+				outputTokens: 10,
 				totalCost: expect.any(Number), // Codex Mini has pricing: $1.5/M input, $6/M output
 			})
 
-			// Verify cost is calculated correctly
-			expect(usageChunks[0].totalCost).toBeGreaterThan(0)
+			// Verify cost is calculated correctly based on API usage data
+			const expectedCost = (50 / 1_000_000) * 1.5 + (10 / 1_000_000) * 6
+			expect(usageChunks[0].totalCost).toBeCloseTo(expectedCost, 10)
 
 			// Verify the request was made with correct parameters
 			expect(mockFetch).toHaveBeenCalledWith(
@@ -1677,12 +1682,12 @@ describe("GPT-5 streaming event coverage (additional)", () => {
 
 			const stream = handler.createMessage(systemPrompt, messages)
 
-			// Should throw an error
+			// Should throw an error (using the same error format as GPT-5)
 			await expect(async () => {
 				for await (const chunk of stream) {
 					// consume stream
 				}
-			}).rejects.toThrow("Codex Mini API request failed (429): Rate limit exceeded")
+			}).rejects.toThrow("Rate limit exceeded")
 
 			// Clean up
 			delete (global as any).fetch
@@ -1750,6 +1755,7 @@ describe("GPT-5 streaming event coverage (additional)", () => {
 								'data: {"type":"response.error","error":{"message":"Model overloaded"}}\n\n',
 							),
 						)
+						// The error handler will throw, but we still need to close the stream
 						controller.close()
 					},
 				}),
@@ -1772,7 +1778,7 @@ describe("GPT-5 streaming event coverage (additional)", () => {
 				for await (const chunk of stream) {
 					chunks.push(chunk)
 				}
-			}).rejects.toThrow("Codex Mini stream error: Model overloaded")
+			}).rejects.toThrow("Responses API error: Model overloaded")
 
 			// Clean up
 			delete (global as any).fetch

src/api/providers/openai-native.ts

@@ -893,7 +893,7 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
 								// Error event from the API
 								if (parsed.error || parsed.message) {
 									throw new Error(
-										`GPT-5 API error: ${parsed.error?.message || parsed.message || "Unknown error"}`,
+										`Responses API error: ${parsed.error?.message || parsed.message || "Unknown error"}`,
 									)
 								}
 							}
@@ -1000,7 +1000,10 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
 								}
 							}
 						} catch (e) {
-							// Silently ignore parsing errors for non-critical SSE data
+							// Only ignore JSON parsing errors, re-throw actual API errors
+							if (!(e instanceof SyntaxError)) {
+								throw e
+							}
 						}
 					}
 					// Also try to parse non-SSE formatted lines
@@ -1148,7 +1151,6 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
 		systemPrompt: string,
 		messages: Anthropic.Messages.MessageParam[],
 	): ApiStream {
-		// Convert messages to a simple input format for Codex Mini
 		const input = messages
 			.filter((msg) => msg.role === "user")
 			.map((msg) => {
@@ -1173,130 +1175,7 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
 			stream: true,
 		}
 
-		// Use the existing responses API infrastructure
-		const apiKey = this.options.openAiNativeApiKey ?? "not-provided"
-		const baseUrl = this.options.openAiNativeBaseUrl || "https://api.openai.com"
-		const url = `${baseUrl}/v1/responses`
-
-		try {
-			const response = await fetch(url, {
-				method: "POST",
-				headers: {
-					"Content-Type": "application/json",
-					Authorization: `Bearer ${apiKey}`,
-					Accept: "text/event-stream",
-				},
-				body: JSON.stringify(requestBody),
-			})
-
-			if (!response.ok) {
-				const errorText = await response.text()
-				let errorMessage = `Codex Mini API request failed (${response.status})`
-
-				try {
-					const errorJson = JSON.parse(errorText)
-					if (errorJson.error?.message) {
-						errorMessage += `: ${errorJson.error.message}`
-					} else if (errorJson.message) {
-						errorMessage += `: ${errorJson.message}`
-					} else {
-						errorMessage += `: ${errorText}`
-					}
-				} catch {
-					errorMessage += `: ${errorText}`
-				}
-
-				throw new Error(errorMessage)
-			}
-
-			if (!response.body) {
-				throw new Error("Codex Mini Responses API error: No response body")
-			}
-
-			// Handle the streaming response for Codex Mini
-			yield* this.handleCodexMiniStreamResponse(response.body, model, systemPrompt, input)
-		} catch (error) {
-			if (error instanceof Error) {
-				throw error
-			}
-			throw new Error(`Unexpected error connecting to Codex Mini API`)
-		}
-	}
-
-	private async *handleCodexMiniStreamResponse(
-		body: ReadableStream<Uint8Array>,
-		model: OpenAiNativeModel,
-		systemPrompt: string,
-		userInput: string,
-	): ApiStream {
-		const reader = body.getReader()
-		const decoder = new TextDecoder()
-		let buffer = ""
-		let totalText = ""
-
-		try {
-			while (true) {
-				const { done, value } = await reader.read()
-				if (done) break
-
-				buffer += decoder.decode(value, { stream: true })
-				const lines = buffer.split("\n")
-				buffer = lines.pop() || ""
-
-				for (const line of lines) {
-					if (line.trim() === "") continue
-					if (line.startsWith("data: ")) {
-						const data = line.slice(6)
-						if (data === "[DONE]") continue
-
-						try {
-							const event = JSON.parse(data)
-
-							// Handle different event types from responses API
-							if (event.type === "response.output_text.delta") {
-								yield {
-									type: "text",
-									text: event.delta,
-								}
-								totalText += event.delta
-							} else if (event.type === "response.completed" || event.type === "response.done") {
-								// Calculate usage based on text length (approximate)
-								// Estimate tokens: ~1 token per 4 characters
-								const promptTokens = Math.ceil((systemPrompt.length + userInput.length) / 4)
-								const completionTokens = Math.ceil(totalText.length / 4)
-
-								const totalCost = calculateApiCostOpenAI(
-									model.info,
-									promptTokens,
-									completionTokens,
-									0,
-									0,
-								)
-
-								yield {
-									type: "usage",
-									inputTokens: promptTokens,
-									outputTokens: completionTokens,
-									cacheWriteTokens: 0,
-									cacheReadTokens: 0,
-									totalCost,
-								}
-							} else if (event.type === "response.error") {
-								throw new Error(`Codex Mini stream error: ${event.error?.message || "Unknown error"}`)
-							}
-						} catch (e) {
-							if (e instanceof SyntaxError) {
-								console.debug("Codex Mini: Failed to parse SSE data", data)
-							} else {
-								throw e
-							}
-						}
-					}
-				}
-			}
-		} finally {
-			reader.releaseLock()
-		}
+		yield* this.makeGpt5ResponsesAPIRequest(requestBody, model)
 	}
 
 	private async *handleStreamResponse(