test(e2e): adding image test

Author: edelauna

apps/vscode-e2e/fixtures/openrouter.json

@@ -1,5 +1,19 @@
 {
 	"fixtures": [
+		{
+			"match": {
+				"userMessage": "openrouter-image-e2e"
+			},
+			"response": {
+				"toolCalls": [
+					{
+						"name": "attempt_completion",
+						"arguments": "{\"result\":\"Red\"}",
+						"id": "call_openrouter_image_001"
+					}
+				]
+			}
+		},
 		{
 			"match": {
 				"userMessage": "openrouter-identity-smoke"

apps/vscode-e2e/src/suite/providers/openrouter.test.ts

@@ -9,6 +9,7 @@ type CapturedOpenRouterRequest = {
 	xTitle: string | undefined
 	httpReferer: string | undefined
 	userAgent: string | undefined
+	userMessageContent?: unknown
 }
 
 function getRequestUrl(input: RequestInfo | URL): string {
@@ -40,10 +41,22 @@ function installOpenRouterRequestCapture(capture: CapturedOpenRouterRequest[], b
 			if (new URL(url).origin === targetOrigin) {
 				const xTitle = getHeaderValue(init, "X-Title") ?? getHeaderValue(init, "x-title")
 				if (xTitle !== undefined) {
+					let userMessageContent: unknown
+					if (init?.body && typeof init.body === "string") {
+						try {
+							const body = JSON.parse(init.body)
+							const messages: Array<{ role?: string; content?: unknown }> = body.messages ?? []
+							const lastUser = [...messages].reverse().find((m) => m.role === "user")
+							userMessageContent = lastUser?.content
+						} catch {
+							// ignore parse errors
+						}
+					}
 					capture.push({
 						xTitle,
 						httpReferer: getHeaderValue(init, "HTTP-Referer") ?? getHeaderValue(init, "http-referer"),
 						userAgent: getHeaderValue(init, "User-Agent") ?? getHeaderValue(init, "user-agent"),
+						userMessageContent,
 					})
 				}
 			}
@@ -82,7 +95,7 @@ suite("OpenRouter provider", function () {
 		await globalThis.api.setConfiguration({
 			apiProvider: "openrouter" as const,
 			openRouterApiKey: aimockUrl && !isRecord ? "mock-key" : OPENROUTER_API_KEY!,
-			openRouterModelId: "openai/gpt-4.1",
+			openRouterModelId: "anthropic/claude-haiku-4-5",
 			...(aimockUrl && { openRouterBaseUrl: `${aimockUrl}/v1` }),
 		})
 	})
@@ -92,6 +105,41 @@ suite("OpenRouter provider", function () {
 		restoreFetch = undefined
 	})
 
+	test("Should forward base64 images as image_url content parts in outbound request", async () => {
+		requests.length = 0
+
+		// 8x8 red PNG (1x1 is too small and rejected by Anthropic's vision API)
+		const base64Png =
+			"iVBORw0KGgoAAAANSUhEUgAAAAgAAAAICAIAAABLbSncAAAAEklEQVR4nGP4z8CAFWEXHbQSACj/P8Fu7N9hAAAAAElFTkSuQmCC"
+		const dataUri = `data:image/png;base64,${base64Png}`
+
+		const api = globalThis.api
+		const taskId = await api.startNewTask({
+			configuration: { mode: "ask", autoApprovalEnabled: true },
+			text: "openrouter-image-e2e: describe the image in one word.",
+			images: [dataUri],
+		})
+
+		await waitUntilCompleted({ api, taskId })
+
+		// Find the first request that contains the probe tag
+		const probeRequest = requests.find((r) => {
+			const content = r.userMessageContent
+			return Array.isArray(content) && JSON.stringify(content).includes("openrouter-image-e2e")
+		})
+
+		assert.ok(probeRequest, "Should have captured an outbound request containing the probe tag")
+
+		const content = probeRequest.userMessageContent as Array<{ type: string; image_url?: { url: string } }>
+		const imagePart = content.find((p) => p.type === "image_url")
+		assert.ok(imagePart, "User message should contain an image_url content part")
+		assert.strictEqual(
+			imagePart?.image_url?.url,
+			dataUri,
+			"image_url.url should be the original data URI passed via startNewTask",
+		)
+	})
+
 	test("Should identify as Zoo Code in outbound DEFAULT_HEADERS", async () => {
 		requests.length = 0
 

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

@@ -132,6 +132,46 @@ describe("NativeOllamaHandler", () => {
 			)
 		})
 
+		it("should drop unknown block types in tool_result content (empty string contribution)", async () => {
+			mockChat.mockImplementation(async function* () {
+				yield { message: { content: "ok" } }
+			})
+
+			const messages: Anthropic.Messages.MessageParam[] = [
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool-1",
+							content: [
+								{ type: "text", text: "before" },
+								{ type: "document" } as any,
+								{ type: "text", text: "after" },
+							],
+						},
+					],
+				},
+			]
+
+			const stream = handler.createMessage("System", messages)
+			for await (const _ of stream) {
+				// consume
+			}
+
+			// The unknown block contributes "" so the join produces "before\n\nafter"
+			expect(mockChat).toHaveBeenCalledWith(
+				expect.objectContaining({
+					messages: expect.arrayContaining([
+						expect.objectContaining({
+							role: "user",
+							content: "before\n\nafter",
+						}),
+					]),
+				}),
+			)
+		})
+
 		it("should not include num_ctx by default", async () => {
 			// Mock the chat response
 			mockChat.mockImplementation(async function* () {

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

@@ -94,4 +94,54 @@ describe("OpenAiCodexHandler.createMessage", () => {
 		expect(userMsg?.content).toEqual([{ type: "input_text", text: "Look at this:" }])
 		expect(JSON.stringify(capturedInput)).not.toContain("input_image")
 	})
+
+	it("should emit input_image for base64 images in formatFullConversation", async () => {
+		const handler = new OpenAiCodexHandler({ apiModelId: "gpt-5.1-codex" })
+
+		vitest.spyOn(openAiCodexOAuthManager, "getAccessToken").mockResolvedValue("test-token")
+		vitest.spyOn(openAiCodexOAuthManager, "getAccountId").mockResolvedValue("acct_test")
+
+		const capturedInput: any[] = []
+		;(handler as any).client = {
+			responses: {
+				create: vitest.fn().mockImplementation(async (body: any) => {
+					capturedInput.push(...(body.input ?? []))
+					return {
+						async *[Symbol.asyncIterator]() {
+							yield {
+								type: "response.completed",
+								response: {
+									id: "r1",
+									status: "completed",
+									output: [],
+									usage: { input_tokens: 1, output_tokens: 1 },
+								},
+							}
+						},
+					}
+				}),
+			},
+		}
+
+		const messages: Anthropic.Messages.MessageParam[] = [
+			{
+				role: "user",
+				content: [
+					{ type: "text", text: "Look at this:" },
+					{ type: "image", source: { type: "base64", media_type: "image/png", data: "abc123" } },
+				],
+			},
+		]
+
+		const stream = handler.createMessage("system", messages)
+		for await (const _ of stream) {
+			// consume
+		}
+
+		const userMsg = capturedInput.find((item: any) => item.role === "user")
+		expect(userMsg?.content).toContainEqual({
+			type: "input_image",
+			image_url: "data:image/png;base64,abc123",
+		})
+	})
 })

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

@@ -1894,5 +1894,51 @@ describe("GPT-5 streaming event coverage (additional)", () => {
 			expect(userMsg.content).toEqual([{ type: "input_text", text: "Look at this:" }])
 			expect(bodyStr).not.toContain("input_image")
 		})
+
+		it("should emit input_image for base64 images in formatFullConversation", async () => {
+			const mockFetch = vitest.fn().mockResolvedValue({
+				ok: true,
+				body: new ReadableStream({
+					start(controller) {
+						controller.enqueue(
+							new TextEncoder().encode('data: {"type":"response.output_text.delta","delta":"ok"}\n\n'),
+						)
+						controller.enqueue(new TextEncoder().encode("data: [DONE]\n\n"))
+						controller.close()
+					},
+				}),
+			})
+			global.fetch = mockFetch as any
+
+			mockResponsesCreate.mockRejectedValue(new Error("SDK not available"))
+
+			const localHandler = new OpenAiNativeHandler({
+				apiModelId: "gpt-4.1",
+				openAiNativeApiKey: "test-api-key",
+			})
+
+			const b64ImageMessages: Anthropic.Messages.MessageParam[] = [
+				{
+					role: "user",
+					content: [
+						{ type: "text", text: "Look at this:" },
+						{ type: "image", source: { type: "base64", media_type: "image/png", data: "abc123" } },
+					],
+				},
+			]
+
+			const stream = localHandler.createMessage("You are a helpful assistant.", b64ImageMessages)
+			for await (const _ of stream) {
+				// consume
+			}
+
+			const bodyStr = (mockFetch.mock.calls[0][1] as any).body as string
+			const parsedBody = JSON.parse(bodyStr)
+			const userMsg = parsedBody.input[0]
+			expect(userMsg.content).toContainEqual({
+				type: "input_image",
+				image_url: "data:image/png;base64,abc123",
+			})
+		})
 	})
 })

src/api/transform/mistral-format.ts

@@ -120,10 +120,7 @@ export function convertToMistralMessages(anthropicMessages: Anthropic.Messages.M
 								}
 								return { type: "text", text: "[Image]" }
 							}
-							if (part.type === "text") {
-								return { type: "text", text: part.text }
-							}
-							return { type: "text", text: "" }
+							return { type: "text", text: part.text }
 						}),
 					})
 				}

src/api/transform/openai-format.ts

@@ -444,10 +444,7 @@ export function convertToOpenAiMessages(
 									}
 									return { type: "text", text: "[Image]" }
 								}
-								if (part.type === "text") {
-									return { type: "text", text: part.text }
-								}
-								return { type: "text", text: "" }
+								return { type: "text", text: part.text }
 							}),
 						})
 					}

src/api/transform/vscode-lm-format.ts

@@ -102,10 +102,7 @@ export function convertToVsCodeLmMessages(
 								`[Image (${part.source.type}): not supported by VSCode LM API]`,
 							)
 						}
-						if (part.type === "text") {
-							return new vscode.LanguageModelTextPart(part.text)
-						}
-						return new vscode.LanguageModelTextPart("")
+						return new vscode.LanguageModelTextPart(part.text)
 					}),
 				]