fix(api): fix abort signal propagation across all providers

Fix 6 major issues and 6 nitpick inconsistencies from CodeRabbit review:

Major fixes (Stop functionality broken for some providers):
- openai-codex.ts: Pass full metadata in retry loop, not just taskId
- openai-native.ts: Reuse existing controller signal in fallback path
- vscode-lm.ts: Bridge external abortSignal to VSCode CancellationToken
- bedrock.ts: Handle pre-aborted signals + use {once: true} listener
- gemini.ts: Move abortSignal to config.abortSignal for both streaming and non-streaming calls
- native-ollama.ts: Use per-request client with abort() method

Nitpick fixes (consistent signal forwarding pattern):
- openai.ts, unbound.ts, qwen-code.ts, xai.ts, vercel-ai-gateway.ts, zoo-gateway.ts:
  Normalize all completePrompt methods to use {signal: metadata?.abortSignal}

Test fixes:
- gemini.spec.ts: Check config.abortSignal for both streaming and non-streaming tests
- native-ollama.spec.ts: Mock Ollama client with abort() method, assert no signal in options (per-request client pattern)
- deepseek.spec.ts: Move abortSignal suite out of parent test, assert from request options (2nd arg)
- vercel-ai-gateway.spec.ts: Add second argument assertion to completePrompt tests
- zoo-gateway.spec.ts: Add second argument assertion to completePrompt tests

Capture per-request client's abort() spy and add tests for:
- controller.abort() triggering the captured abort spy
- pre-aborted signals calling abort() immediately
- no abortSignal provided not calling abort()

Author: easonliang28

src/api/providers/__tests__/deepseek.spec.ts

@@ -637,48 +637,46 @@ describe("DeepSeekHandler", () => {
 			const toolCallChunks = chunks.filter((chunk) => chunk.type === "tool_call_partial")
 			expect(toolCallChunks.length).toBeGreaterThan(0)
 			expect(toolCallChunks[0].name).toBe("get_weather")
+		})
+	})
 
-			describe("abortSignal support", () => {
-				it("should pass abortSignal to chat.completions.create when provided in metadata", async () => {
-					const handler = new DeepSeekHandler({ ...mockOptions, apiKey: "test-key" })
-					const systemPrompt = "You are a helpful assistant."
-					const messages: Anthropic.Messages.MessageParam[] = [
-						{ role: "user", content: [{ type: "text" as const, text: "Hello!" }] },
-					]
-
-					const controller = new AbortController()
-					const mockAbortSignal = controller.signal
-
-					await handler.createMessage(systemPrompt, messages, {
-						taskId: "test",
-						abortSignal: mockAbortSignal,
-					})
-					for await (const _chunk of handler.createMessage(systemPrompt, messages)) {
-						break
-					}
-
-					expect(mockCreate).toHaveBeenCalled()
-					const callArgs = mockCreate.mock.calls[0][0]
-					expect(callArgs.signal).toBe(mockAbortSignal)
-				})
+	describe("abortSignal support", () => {
+		it("should pass abortSignal to chat.completions.create when provided in metadata", async () => {
+			const handler = new DeepSeekHandler({ ...mockOptions, apiKey: "test-key" })
+			const systemPrompt = "You are a helpful assistant."
+			const messages: Anthropic.Messages.MessageParam[] = [
+				{ role: "user", content: [{ type: "text" as const, text: "Hello!" }] },
+			]
 
-				it("should not include signal when abortSignal is not provided", async () => {
-					const handler = new DeepSeekHandler({ ...mockOptions, apiKey: "test-key" })
-					const systemPrompt = "You are a helpful assistant."
-					const messages: Anthropic.Messages.MessageParam[] = [
-						{ role: "user", content: [{ type: "text" as const, text: "Hello!" }] },
-					]
-
-					await handler.createMessage(systemPrompt, messages)
-					for await (const _chunk of handler.createMessage(systemPrompt, messages)) {
-						break
-					}
-
-					expect(mockCreate).toHaveBeenCalled()
-					const callArgs = mockCreate.mock.calls[0][0]
-					expect(callArgs.signal).toBeUndefined()
-				})
-			})
+			const controller = new AbortController()
+			const mockAbortSignal = controller.signal
+
+			for await (const _chunk of handler.createMessage(systemPrompt, messages, {
+				taskId: "test",
+				abortSignal: mockAbortSignal,
+			})) {
+				break
+			}
+
+			expect(mockCreate).toHaveBeenCalled()
+			const requestOptions = mockCreate.mock.calls[0][1]
+			expect(requestOptions?.signal).toBe(mockAbortSignal)
+		})
+
+		it("should not include signal when abortSignal is not provided", async () => {
+			const handler = new DeepSeekHandler({ ...mockOptions, apiKey: "test-key" })
+			const systemPrompt = "You are a helpful assistant."
+			const messages: Anthropic.Messages.MessageParam[] = [
+				{ role: "user", content: [{ type: "text" as const, text: "Hello!" }] },
+			]
+
+			for await (const _chunk of handler.createMessage(systemPrompt, messages)) {
+				break
+			}
+
+			expect(mockCreate).toHaveBeenCalled()
+			const requestOptions = mockCreate.mock.calls[0][1]
+			expect(requestOptions?.signal).toBeUndefined()
 		})
 	})
 })

src/api/providers/__tests__/gemini.spec.ts

@@ -169,7 +169,7 @@ describe("GeminiHandler", () => {
 			await handler.completePrompt("Test prompt", { taskId: "test", abortSignal: mockAbortSignal })
 
 			const callArgs = mockGenerateContent.mock.calls[0][0]
-			expect(callArgs.signal).toBe(mockAbortSignal)
+			expect(callArgs.config?.abortSignal).toBe(mockAbortSignal)
 		})
 
 		it("should pass undefined signal when abortSignal is not provided", async () => {
@@ -181,7 +181,7 @@ describe("GeminiHandler", () => {
 			await handler.completePrompt("Test prompt")
 
 			const callArgs = mockGenerateContent.mock.calls[0][0]
-			expect(callArgs.signal).toBeUndefined()
+			expect(callArgs.config?.abortSignal).toBeUndefined()
 		})
 	})
 
@@ -416,7 +416,7 @@ describe("GeminiHandler", () => {
 
 			expect(mockGenerateContentStream).toHaveBeenCalled()
 			const callArgs = mockGenerateContentStream.mock.calls[0][0]
-			expect(callArgs.signal).toBe(mockAbortSignal)
+			expect(callArgs.config?.abortSignal).toBe(mockAbortSignal)
 		})
 
 		it("should pass undefined signal when abortSignal is not provided", async () => {
@@ -434,7 +434,7 @@ describe("GeminiHandler", () => {
 
 			expect(mockGenerateContentStream).toHaveBeenCalled()
 			const callArgs = mockGenerateContentStream.mock.calls[0][0]
-			expect(callArgs.signal).toBeUndefined()
+			expect(callArgs.config?.abortSignal).toBeUndefined()
 		})
 	})
 })

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

@@ -7,14 +7,20 @@ import { ApiHandlerOptions } from "../../../shared/api"
 const mockedData = vi.hoisted(() => ({
 	mockChat: vi.fn(),
 	mockGetOllamaModels: vi.fn(),
+	capturedAbortSpies: [] as ReturnType<typeof vi.fn>[],
 }))
 
-// Mock the ollama package
+// Mock the ollama package - capture each Ollama instance's abort spy for verification
 vi.mock("ollama", () => {
 	return {
-		Ollama: vi.fn().mockImplementation(() => ({
-			chat: mockedData.mockChat,
-		})),
+		Ollama: vi.fn().mockImplementation(function () {
+			const abortSpy = vi.fn()
+			mockedData.capturedAbortSpies.push(abortSpy)
+			return {
+				chat: mockedData.mockChat,
+				abort: abortSpy,
+			}
+		}),
 		Message: vi.fn(),
 	}
 })
@@ -232,7 +238,7 @@ describe("NativeOllamaHandler", () => {
 			)
 		})
 
-		it("should pass abortSignal to chat when provided in metadata", async () => {
+		it("should wire abortSignal to per-request client's abort() method", async () => {
 			const controller = new AbortController()
 			const mockAbortSignal = controller.signal
 
@@ -242,11 +248,12 @@ describe("NativeOllamaHandler", () => {
 
 			await handler.completePrompt("Test prompt", { taskId: "test", abortSignal: mockAbortSignal })
 
+			// The chat call should NOT have signal in options (we use per-request client instead)
 			const callArgs = mockedData.mockChat.mock.calls[0][0]
-			expect(callArgs.signal).toBe(mockAbortSignal)
+			expect(callArgs.signal).toBeUndefined()
 		})
 
-		it("should pass undefined signal when abortSignal is not provided", async () => {
+		it("should not pass signal in options when abortSignal is not provided", async () => {
 			mockedData.mockChat.mockResolvedValue({
 				message: { content: "Test response" },
 			})
@@ -639,10 +646,9 @@ describe("NativeOllamaHandler", () => {
 	})
 
 	describe("abortSignal support", () => {
-		it("should pass abortSignal to chat when provided in metadata", async () => {
+		it("should wire abortSignal to per-request client's abort() method", async () => {
 			vitest.clearAllMocks()
-			const mockAbortController: any = { signal: Symbol("abort") }
-
+			mockedData.capturedAbortSpies.length = 0
 			;(mockGetOllamaModels as any).mockImplementationOnce(async () => ({
 				llama2: { contextWindow: 4096, maxTokens: 4096, supportsImages: false, supportsPromptCache: false },
 			}))
@@ -657,20 +663,96 @@ describe("NativeOllamaHandler", () => {
 				ollamaBaseUrl: "http://localhost:11434",
 			})
 
+			const controller = new AbortController()
+
+			const stream = handlerWithSignal.createMessage("system", [{ role: "user", content: "Hello!" }], {
+				taskId: "test",
+				abortSignal: controller.signal,
+			})
+
+			// Start iteration and break early to test abort behavior
+			for await (const _chunk of stream) {
+				break
+			}
+
+			// Verify chat was called without signal in options
+			expect(mockedData.mockChat).toHaveBeenCalled()
+			const callArgs = mockedData.mockChat.mock.calls[0][0]
+			expect(callArgs.signal).toBeUndefined()
+
+			// Now abort and verify the per-request client's abort() was called
+			const abortSpyBeforeAbort = mockedData.capturedAbortSpies[mockedData.capturedAbortSpies.length - 1]
+			expect(abortSpyBeforeAbort).toBeDefined()
+			expect(abortSpyBeforeAbort!).toHaveBeenCalledTimes(0)
+
+			controller.abort()
+			// Give event loop time for the abort listener to fire
+			await new Promise((r) => setTimeout(r, 0))
+			expect(abortSpyBeforeAbort!).toHaveBeenCalled()
+		})
+
+		it("should call abort() immediately when signal is already aborted", async () => {
+			vitest.clearAllMocks()
+			mockedData.capturedAbortSpies.length = 0
+			;(mockGetOllamaModels as any).mockImplementationOnce(async () => ({
+				llama2: { contextWindow: 4096, maxTokens: 4096, supportsImages: false, supportsPromptCache: false },
+			}))
+
+			mockedData.mockChat.mockImplementation(async function* () {
+				yield { message: { content: "Hello" } }
+			})
+
+			const controller = new AbortController()
+			controller.abort() // Pre-abort the signal
+
+			const handlerWithSignal = new NativeOllamaHandler({
+				apiModelId: "llama2",
+				ollamaModelId: "llama2",
+				ollamaBaseUrl: "http://localhost:11434",
+			})
+
 			for await (const _chunk of handlerWithSignal.createMessage(
 				"system",
 				[{ role: "user", content: "Hello!" }],
-				{ taskId: "test", abortSignal: mockAbortController.signal },
+				{ taskId: "test", abortSignal: controller.signal },
 			)) {
 				break
 			}
 
-			expect(mockedData.mockChat).toHaveBeenCalled()
-			const callArgs = mockedData.mockChat.mock.calls[0][0]
-			expect(callArgs.signal).toBe(mockAbortController.signal)
+			// Verify abort was called immediately (before any iteration)
+			const abortSpyBeforeAbort = mockedData.capturedAbortSpies[mockedData.capturedAbortSpies.length - 1]
+			expect(abortSpyBeforeAbort).toBeDefined()
+			expect(abortSpyBeforeAbort!).toHaveBeenCalled()
+		})
+
+		it("should not call abort when no abortSignal is provided", async () => {
+			vitest.clearAllMocks()
+			mockedData.capturedAbortSpies.length = 0
+			;(mockGetOllamaModels as any).mockImplementationOnce(async () => ({
+				llama2: { contextWindow: 4096, maxTokens: 4096, supportsImages: false, supportsPromptCache: false },
+			}))
+
+			mockedData.mockChat.mockImplementation(async function* () {
+				yield { message: { content: "Hello" } }
+			})
+
+			const handlerNoSignal = new NativeOllamaHandler({
+				apiModelId: "llama2",
+				ollamaModelId: "llama2",
+				ollamaBaseUrl: "http://localhost:11434",
+			})
+
+			for await (const _chunk of handlerNoSignal.createMessage("system", [{ role: "user", content: "Hello!" }])) {
+				break
+			}
+
+			// Verify abort was NOT called when no signal provided
+			const abortSpy = mockedData.capturedAbortSpies[mockedData.capturedAbortSpies.length - 1]
+			expect(abortSpy).toBeDefined()
+			expect(abortSpy!).toHaveBeenCalledTimes(0)
 		})
 
-		it("should pass undefined signal when abortSignal is not provided", async () => {
+		it("should not pass signal in options when abortSignal is not provided", async () => {
 			vitest.clearAllMocks()
 			;(mockGetOllamaModels as any).mockImplementationOnce(async () => ({
 				llama2: { contextWindow: 4096, maxTokens: 4096, supportsImages: false, supportsPromptCache: false },

src/api/providers/__tests__/vercel-ai-gateway.spec.ts

@@ -586,13 +586,16 @@ describe("VercelAiGatewayHandler", () => {
 			const result = await handler.completePrompt(prompt)
 
 			expect(result).toBe("Test completion response")
-			expect(mockCreate).toHaveBeenCalledWith({
-				model: "anthropic/claude-sonnet-4",
-				messages: [{ role: "user", content: prompt }],
-				stream: false,
-				temperature: VERCEL_AI_GATEWAY_DEFAULT_TEMPERATURE,
-				max_completion_tokens: 64000,
-			})
+			expect(mockCreate).toHaveBeenCalledWith(
+				{
+					model: "anthropic/claude-sonnet-4",
+					messages: [{ role: "user", content: prompt }],
+					stream: false,
+					temperature: VERCEL_AI_GATEWAY_DEFAULT_TEMPERATURE,
+					max_completion_tokens: 64000,
+				},
+				{ signal: undefined },
+			)
 		})
 
 		it("uses custom temperature for completion", async () => {
@@ -608,6 +611,7 @@ describe("VercelAiGatewayHandler", () => {
 				expect.objectContaining({
 					temperature: customTemp,
 				}),
+				expect.objectContaining({ signal: undefined }),
 			)
 		})
 
@@ -656,6 +660,7 @@ describe("VercelAiGatewayHandler", () => {
 				expect.objectContaining({
 					temperature: 0.9,
 				}),
+				expect.objectContaining({ signal: undefined }),
 			)
 		})
 

src/api/providers/__tests__/zoo-gateway.spec.ts

@@ -464,6 +464,7 @@ describe("ZooGatewayHandler", () => {
 					temperature: ZOO_GATEWAY_DEFAULT_TEMPERATURE,
 					max_completion_tokens: 64000,
 				}),
+				expect.objectContaining({ signal: undefined }),
 			)
 		})
 

src/api/providers/bedrock.ts

@@ -534,12 +534,21 @@ export class AwsBedrockHandler extends BaseProvider implements SingleCompletionH
 		const controller = new AbortController()
 		let timeoutId: NodeJS.Timeout | undefined
 
-		// Listen for external abort signal from metadata and forward to internal controller
+		// Listen for external abort signal from metadata and forward to internal controller.
+		// Handle both pre-aborted signals and future abort events.
 		const externalAbortSignal = metadata?.abortSignal
 		if (externalAbortSignal) {
-			externalAbortSignal.addEventListener("abort", () => {
+			if (externalAbortSignal.aborted) {
 				controller.abort()
-			})
+			} else {
+				externalAbortSignal.addEventListener(
+					"abort",
+					() => {
+						controller.abort()
+					},
+					{ once: true },
+				)
+			}
 		}
 
 		try {

src/api/providers/gemini.ts

@@ -343,7 +343,11 @@ export class GeminiHandler extends BaseProvider implements SingleCompletionHandl
 			}
 		}
 
-		const params: any = { model, contents, config, signal: metadata?.abortSignal }
+		const params: any = {
+			model,
+			contents,
+			config: { ...config, abortSignal: metadata?.abortSignal },
+		}
 
 		try {
 			const result = await this.client.models.generateContentStream(params)
@@ -595,8 +599,7 @@ export class GeminiHandler extends BaseProvider implements SingleCompletionHandl
 			const request = {
 				model,
 				contents: [{ role: "user", parts: [{ text: prompt }] }],
-				config: promptConfig,
-				signal: metadata?.abortSignal,
+				config: { ...promptConfig, abortSignal: metadata?.abortSignal },
 			}
 
 			const result = await this.client.models.generateContent(request)