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 (improve coverage for abort signal paths):
- bedrock.spec.ts: Assert controller.signal.aborted state for pre-aborted and mid-stream tests
- openai-native.spec.ts: Capture fetchOptions before abort, verify external signal becomes aborted
- native-ollama.spec.ts: Use spyCountBefore to track per-request client abort spy correctly

Author: easonliang28

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

@@ -1576,4 +1576,76 @@ describe("AwsBedrockHandler", () => {
 			})
 		})
 	})
+
+	describe("abort signal", () => {
+		beforeEach(() => {
+			mockConverseStreamCommand.mockReset()
+		})
+
+		it("should handle pre-aborted signals by calling controller.abort() immediately", async () => {
+			const handler = new AwsBedrockHandler({
+				apiModelId: "anthropic.claude-3-5-sonnet-20241022-v2:0",
+				awsAccessKey: "test-access-key",
+				awsSecretKey: "test-secret-key",
+				awsRegion: "us-east-1",
+			})
+
+			const controller = new AbortController()
+			controller.abort() // Pre-abort the signal
+
+			const messages: Anthropic.Messages.MessageParam[] = [{ role: "user", content: "Hello" }]
+			const generator = handler.createMessage("System prompt", messages, {
+				taskId: "test-task",
+				abortSignal: controller.signal,
+			})
+
+			// Verify the external signal is already aborted before consuming
+			expect(controller.signal.aborted).toBe(true)
+
+			// Consume the stream - pre-aborted signal should trigger internal abort
+			for await (const _ of generator) {
+				// consume
+			}
+		})
+
+		it("should use { once: true } listener for external abort signal", async () => {
+			const handler = new AwsBedrockHandler({
+				apiModelId: "anthropic.claude-3-5-sonnet-20241022-v2:0",
+				awsAccessKey: "test-access-key",
+				awsSecretKey: "test-secret-key",
+				awsRegion: "us-east-1",
+			})
+
+			const controller = new AbortController()
+
+			const messages: Anthropic.Messages.MessageParam[] = [{ role: "user", content: "Hello" }]
+			const generator = handler.createMessage("System prompt", messages, {
+				taskId: "test-task",
+				abortSignal: controller.signal,
+			})
+
+			// Start consuming and then abort
+			const consumePromise = (async () => {
+				try {
+					for await (const _ of generator) {
+						// consume
+					}
+				} catch {
+					// expected to fail due to mock
+				}
+			})()
+
+			await new Promise((r) => setTimeout(r, 10))
+
+			// Verify signal is not aborted before calling abort
+			expect(controller.signal.aborted).toBe(false)
+
+			controller.abort()
+
+			// Verify the signal becomes aborted after calling abort()
+			expect(controller.signal.aborted).toBe(true)
+
+			await consumePromise.catch(() => {})
+		})
+	})
 })

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(),
 	}
 })
@@ -34,6 +40,7 @@ describe("NativeOllamaHandler", () => {
 
 	beforeEach(() => {
 		vitest.clearAllMocks()
+		mockedData.capturedAbortSpies.length = 0
 
 		// Default mock for getOllamaModels
 		mockGetOllamaModels.mockResolvedValue({
@@ -232,7 +239,9 @@ 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 spyCountBefore = mockedData.capturedAbortSpies.length
+
 			const controller = new AbortController()
 			const mockAbortSignal = controller.signal
 
@@ -242,11 +251,23 @@ 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()
+
+			// Get the spy for the per-request client created by completePrompt
+			const abortSpy = mockedData.capturedAbortSpies[spyCountBefore]
+			expect(abortSpy).toBeDefined()
+
+			// Now trigger abort and verify the per-request client's abort() was called
+			controller.abort()
+			await new Promise((r) => setTimeout(r, 0))
+
+			// Verify abort was called in response to external signal being aborted
+			expect(abortSpy!).toHaveBeenCalled()
 		})
 
-		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 +660,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 +677,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 },