refactor: use OpenAI SDK for codex-mini-latest responses endpoint

- Replace direct fetch calls with client.responses.create() from OpenAI SDK
- Simplify stream handling by leveraging SDK's async iterator
- Update tests to mock SDK responses methods instead of global fetch
- Add proper error handling with try-catch in handleCodexMiniMessage
- Remove ~80 lines of manual SSE parsing logic

This change improves maintainability by using the official SDK support
for the v1/responses endpoint while maintaining all existing functionality.

Author: MuriloFP

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

@@ -7,6 +7,7 @@ import { ApiHandlerOptions } from "../../../shared/api"
 
 // Mock OpenAI client
 const mockCreate = vitest.fn()
+const mockResponsesCreate = vitest.fn()
 const mockFetch = vitest.fn()
 
 // Mock global fetch
@@ -66,6 +67,9 @@ vitest.mock("openai", () => {
 					}),
 				},
 			},
+			responses: {
+				create: mockResponsesCreate,
+			},
 		})),
 	}
 })
@@ -88,6 +92,7 @@ describe("OpenAiNativeHandler", () => {
 		}
 		handler = new OpenAiNativeHandler(mockOptions)
 		mockCreate.mockClear()
+		mockResponsesCreate.mockClear()
 		mockFetch.mockClear()
 	})
 
@@ -455,27 +460,17 @@ describe("OpenAiNativeHandler", () => {
 		})
 
 		it("should handle streaming responses via v1/responses", async () => {
-			const mockStreamData = [
-				'data: {"type": "response.output_text.delta", "delta": "Hello"}\n',
-				'data: {"type": "response.output_text.delta", "delta": " world"}\n',
-				'data: {"type": "response.completed"}\n',
-				"data: [DONE]\n",
-			]
-
-			const encoder = new TextEncoder()
-			const stream = new ReadableStream({
-				start(controller) {
-					for (const data of mockStreamData) {
-						controller.enqueue(encoder.encode(data))
-					}
-					controller.close()
-				},
-			})
-
-			mockFetch.mockResolvedValueOnce({
-				ok: true,
-				status: 200,
-				body: stream,
+			// Mock the responses.create method to return an async iterable
+			mockResponsesCreate.mockImplementation(async (options) => {
+				expect(options.stream).toBe(true)
+
+				return {
+					[Symbol.asyncIterator]: async function* () {
+						yield { type: "response.output_text.delta", delta: "Hello" }
+						yield { type: "response.output_text.delta", delta: " world" }
+						yield { type: "response.completed" }
+					},
+				}
 			})
 
 			const responseStream = handler.createMessage(systemPrompt, messages)
@@ -484,18 +479,11 @@ describe("OpenAiNativeHandler", () => {
 				chunks.push(chunk)
 			}
 
-			expect(mockFetch).toHaveBeenCalledWith("https://api.openai.com/v1/responses", {
-				method: "POST",
-				headers: {
-					"Content-Type": "application/json",
-					Authorization: "Bearer test-api-key",
-				},
-				body: JSON.stringify({
-					model: "codex-mini-latest",
-					instructions: systemPrompt,
-					input: "Hello!",
-					stream: true,
-				}),
+			expect(mockResponsesCreate).toHaveBeenCalledWith({
+				model: "codex-mini-latest",
+				instructions: systemPrompt,
+				input: "Hello!",
+				stream: true,
 			})
 
 			const textChunks = chunks.filter((chunk) => chunk.type === "text")
@@ -505,47 +493,31 @@ describe("OpenAiNativeHandler", () => {
 		})
 
 		it("should handle non-streaming completion via v1/responses", async () => {
-			mockFetch.mockResolvedValueOnce({
-				ok: true,
-				status: 200,
-				json: async () => ({ output_text: "Test response" }),
+			mockResponsesCreate.mockResolvedValueOnce({
+				output_text: "Test response",
 			})
 
 			const result = await handler.completePrompt("Test prompt")
 
-			expect(mockFetch).toHaveBeenCalledWith("https://api.openai.com/v1/responses", {
-				method: "POST",
-				headers: {
-					"Content-Type": "application/json",
-					Authorization: "Bearer test-api-key",
-				},
-				body: JSON.stringify({
-					model: "codex-mini-latest",
-					instructions: "Complete the following prompt:",
-					input: "Test prompt",
-					stream: false,
-				}),
+			expect(mockResponsesCreate).toHaveBeenCalledWith({
+				model: "codex-mini-latest",
+				instructions: "Complete the following prompt:",
+				input: "Test prompt",
+				stream: false,
 			})
 
 			expect(result).toBe("Test response")
 		})
 
 		it("should handle API errors", async () => {
-			mockFetch.mockResolvedValueOnce({
-				ok: false,
-				status: 404,
-				statusText: "Not Found",
-				text: async () => "This model is only supported in v1/responses",
-			})
+			mockResponsesCreate.mockRejectedValueOnce(new Error("This model is only supported in v1/responses"))
 
 			const stream = handler.createMessage(systemPrompt, messages)
 			await expect(async () => {
 				for await (const _chunk of stream) {
 					// Should not reach here
 				}
-			}).rejects.toThrow(
-				"OpenAI Responses API error: 404 Not Found - This model is only supported in v1/responses",
-			)
+			}).rejects.toThrow("OpenAI Responses API error: This model is only supported in v1/responses")
 		})
 	})
 

src/api/providers/openai-native.ts

@@ -125,68 +125,32 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
 		yield* this.handleStreamResponse(stream, model)
 	}
 
-	/**
-	 * Makes a request to the OpenAI Responses API endpoint
-	 * Used by codex-mini-latest model which requires the v1/responses endpoint
-	 */
-	private async makeResponsesApiRequest(
-		modelId: string,
-		instructions: string,
-		input: string,
-		stream: boolean = true,
-	): Promise<Response> {
-		// Note: Using fetch() instead of OpenAI client because the OpenAI SDK v5.0.0
-		// does not support the v1/responses endpoint used by codex-mini-latest model.
-		// This is a special endpoint that requires a different request/response format.
-		const apiKey = this.options.openAiNativeApiKey ?? "not-provided"
-		const baseURL = this.options.openAiNativeBaseUrl ?? "https://api.openai.com/v1"
+	private async *handleCodexMiniMessage(
+		model: OpenAiNativeModel,
+		systemPrompt: string,
+		messages: Anthropic.Messages.MessageParam[],
+	): ApiStream {
+		// Convert messages to a single input string
+		const input = this.convertMessagesToInput(messages)
 
 		try {
-			const response = await fetch(`${baseURL}/responses`, {
-				method: "POST",
-				headers: {
-					"Content-Type": "application/json",
-					Authorization: `Bearer ${apiKey}`,
-				},
-				body: JSON.stringify({
-					model: modelId,
-					instructions: instructions,
-					input: input,
-					stream: stream,
-				}),
+			// Use the OpenAI SDK's responses endpoint
+			const stream = await this.client.responses.create({
+				model: model.id,
+				instructions: systemPrompt,
+				input: input,
+				stream: true,
 			})
 
-			if (!response.ok) {
-				const errorText = await response.text()
-				throw new Error(`OpenAI Responses API error: ${response.status} ${response.statusText} - ${errorText}`)
-			}
-
-			return response
+			yield* this.handleResponsesStreamResponse(stream, model, systemPrompt, input)
 		} catch (error) {
-			// Handle network failures and other errors
-			if (error instanceof TypeError && error.message.includes("fetch")) {
-				throw new Error(`Network error while calling OpenAI Responses API: ${error.message}`)
-			}
 			if (error instanceof Error) {
 				throw new Error(`OpenAI Responses API error: ${error.message}`)
 			}
-			throw new Error("Unknown error occurred while calling OpenAI Responses API")
+			throw error
 		}
 	}
 
-	private async *handleCodexMiniMessage(
-		model: OpenAiNativeModel,
-		systemPrompt: string,
-		messages: Anthropic.Messages.MessageParam[],
-	): ApiStream {
-		// Convert messages to a single input string
-		const input = this.convertMessagesToInput(messages)
-
-		// Make API call using shared helper
-		const response = await this.makeResponsesApiRequest(model.id, systemPrompt, input, true)
-		yield* this.handleResponsesStreamResponse(response.body, model, systemPrompt, input)
-	}
-
 	private convertMessagesToInput(messages: Anthropic.Messages.MessageParam[]): string {
 		return messages
 			.map((msg) => {
@@ -207,80 +171,45 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
 	}
 
 	private async *handleResponsesStreamResponse(
-		stream: ReadableStream<Uint8Array> | null,
+		stream: AsyncIterable<any>,
 		model: OpenAiNativeModel,
 		systemPrompt: string,
 		userInput: string,
 	): ApiStream {
-		if (!stream) {
-			throw new Error("No response stream available")
-		}
-
 		let totalText = ""
-		const reader = stream.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 })
-				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") {
-								// 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)
-								yield* this.yieldUsage(model.info, {
-									prompt_tokens: promptTokens,
-									completion_tokens: completionTokens,
-									total_tokens: promptTokens + completionTokens,
-								})
-							} else if (event.type === "response.error") {
-								// Handle error events from the API
-								throw new Error(
-									`OpenAI Responses API stream error: ${event.error?.message || "Unknown error"}`,
-								)
-							} else {
-								// Log unknown event types for debugging and future compatibility
-								console.debug(
-									`OpenAI Responses API: Unknown event type '${event.type}' received`,
-									event,
-								)
-							}
-						} catch (e) {
-							// Only skip if it's a JSON parsing error
-							if (e instanceof SyntaxError) {
-								console.debug("OpenAI Responses API: Failed to parse SSE data", data)
-							} else {
-								// Re-throw other errors (like API errors)
-								throw e
-							}
-						}
+			for await (const event of stream) {
+				// 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") {
+					// 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)
+					yield* this.yieldUsage(model.info, {
+						prompt_tokens: promptTokens,
+						completion_tokens: completionTokens,
+						total_tokens: promptTokens + completionTokens,
+					})
+				} else if (event.type === "response.error") {
+					// Handle error events from the API
+					throw new Error(`OpenAI Responses API stream error: ${event.error?.message || "Unknown error"}`)
+				} else {
+					// Log unknown event types for debugging and future compatibility
+					console.debug(`OpenAI Responses API: Unknown event type '${event.type}' received`, event)
 				}
 			}
-		} finally {
-			reader.releaseLock()
+		} catch (error) {
+			if (error instanceof Error) {
+				throw new Error(`OpenAI Responses API error: ${error.message}`)
+			}
+			throw error
 		}
 	}
 
@@ -348,10 +277,14 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
 			const { id, temperature, reasoning } = this.getModel()
 
 			if (id === "codex-mini-latest") {
-				// Make API call using shared helper
-				const response = await this.makeResponsesApiRequest(id, "Complete the following prompt:", prompt, false)
-				const data = await response.json()
-				return data.output_text || ""
+				// Use the OpenAI SDK's responses endpoint
+				const response = await this.client.responses.create({
+					model: id,
+					instructions: "Complete the following prompt:",
+					input: prompt,
+					stream: false,
+				})
+				return response.output_text || ""
 			}
 
 			const params: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming = {