fix(api): address CodeRabbit review on gateway-b abort handling

Author: easonliang28

src/api/providers/__tests__/opencode-go.spec.ts

@@ -415,6 +415,41 @@ describe("OpencodeGoHandler", () => {
 			await expect(consumed).rejects.toMatchObject({ name: "AbortError" })
 			expect(capturedSignal?.aborted).toBe(true)
 		})
+
+		it("detaches the bridged abort listener when the request completes normally", async () => {
+			// The listener is added with { once: true }, so it only detaches on
+			// abort. A task-scoped signal spanning many requests must not
+			// accumulate a listener per request: assert explicit removal after a
+			// normal (non-aborted) completion.
+			mockCreate.mockImplementation(async () =>
+				asyncStreamFrom([
+					{
+						choices: [{ delta: { content: "ok" }, index: 0 }],
+						index: 0,
+					},
+					{
+						choices: [{ delta: {}, index: 0 }],
+						index: 0,
+						usage: { prompt_tokens: 2, completion_tokens: 3 },
+					},
+				]),
+			)
+
+			const handler = new OpencodeGoHandler(mockOptions)
+			const controller = new AbortController()
+			const removeListenerSpy = vi.spyOn(controller.signal, "removeEventListener")
+
+			const stream = handler.createMessage(
+				"sys",
+				[{ role: "user", content: "hi" }],
+				makeCreateMessageMetadata({ abortSignal: controller.signal }),
+			)
+
+			const chunks = await collectStream(stream)
+			expect(chunks).toContainEqual({ type: "text", text: "ok" })
+			expect(removeListenerSpy).toHaveBeenCalledWith("abort", expect.any(Function))
+			expect(controller.signal.aborted).toBe(false)
+		})
 	})
 	describe("completePrompt", () => {
 		it("returns the message content for a non-streaming completion", async () => {
@@ -660,6 +695,20 @@ describe("OpencodeGoHandler", () => {
 			})
 		})
 
+		it("completePrompt omits the timeout option when timeoutMs is 0 (Anthropic path)", async () => {
+			// The SDK treats timeout: 0 as an immediate abort, so the "disabled"
+			// value must never be forwarded — assert the absence of the option.
+			mockAnthropicCreate.mockResolvedValue({ content: [{ type: "text", text: "response" }] })
+			const handler = new OpencodeGoHandler(anthropicOptions)
+			await handler.completePrompt("ping", { timeoutMs: 0 })
+			const call = mockAnthropicCreate.mock.calls[mockAnthropicCreate.mock.calls.length - 1]
+			const requestOptions = call[1] as { timeout?: number } | undefined
+			// When no option is forwarded the provider omits the SDK options
+			// argument entirely, so absence means: undefined arg OR an arg
+			// without a timeout key.
+			expect(Object.keys(requestOptions ?? {})).not.toContain("timeout")
+		})
+
 		it("completePrompt works without options (backward compatible, Anthropic path)", async () => {
 			mockAnthropicCreate.mockResolvedValue({ content: [{ type: "text", text: "response" }] })
 			const handler = new OpencodeGoHandler(anthropicOptions)
@@ -735,6 +784,20 @@ describe("OpencodeGoHandler", () => {
 				)
 			})
 
+			it("completePrompt omits the timeout option when timeoutMs is 0 (OpenAI path)", async () => {
+				// The OpenAI SDK treats timeout: 0 as an immediate abort, so the
+				// "disabled" value must never be forwarded — assert the absence of
+				// the option.
+				mockCreate.mockResolvedValueOnce({
+					choices: [{ message: { content: "response" } }],
+				})
+				const handler = new OpencodeGoHandler(openaiOptions)
+				await handler.completePrompt("ping", { timeoutMs: 0 })
+				const call = mockCreate.mock.calls[mockCreate.mock.calls.length - 1]
+				const requestOptions = call[1] as { timeout?: number } | undefined
+				expect(requestOptions).not.toHaveProperty("timeout")
+			})
+
 			it("completePrompt works without options (backward compatible, OpenAI path)", async () => {
 				mockCreate.mockResolvedValueOnce({
 					choices: [{ message: { content: "response" } }],

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

@@ -239,6 +239,24 @@ describe("UnboundHandler", () => {
 		)
 	})
 
+	it("completePrompt should omit the timeout option when timeoutMs is 0", async () => {
+		// The OpenAI SDK treats timeout: 0 as an immediate abort, so the
+		// "disabled" value must never be forwarded — assert the absence of
+		// the option (a forwarded timeout: 0 would fail this assertion).
+		sharedMockCreate.mockResolvedValue({
+			choices: [{ message: { content: "completed text" } }],
+		})
+
+		const handler = new UnboundHandler({
+			unboundApiKey: "test-key",
+			unboundModelId: "openai/gpt-4o",
+		})
+
+		await handler.completePrompt("Write a haiku", { timeoutMs: 0 })
+		const call = sharedMockCreate.mock.calls[sharedMockCreate.mock.calls.length - 1]
+		const requestOptions = call[1] as { timeout?: number } | undefined
+		expect(requestOptions).not.toHaveProperty("timeout")
+	})
 	it("completePrompt should work without options (backward compatible)", async () => {
 		sharedMockCreate.mockResolvedValue({
 			choices: [{ message: { content: "completed text" } }],
@@ -314,5 +332,38 @@ describe("UnboundHandler", () => {
 			await expect(consumed).rejects.toMatchObject({ name: "AbortError" })
 			expect(capturedSignal?.aborted).toBe(true)
 		})
+
+		it("detaches the bridged abort listener when the request completes normally", async () => {
+			// The listener is added with { once: true }, so it only detaches on
+			// abort. A task-scoped signal spanning many requests must not
+			// accumulate a listener per request: assert explicit removal after a
+			// normal (non-aborted) completion.
+			sharedMockCreate.mockImplementation(async () =>
+				asyncStreamFrom([
+					{ choices: [{ delta: { content: "ok" } }] },
+					{ choices: [{ delta: {} }], usage: { prompt_tokens: 1, completion_tokens: 1 } },
+				]),
+			)
+
+			const controller = new AbortController()
+			const removeListenerSpy = vi.spyOn(controller.signal, "removeEventListener")
+
+			const handler = new UnboundHandler({
+				unboundApiKey: "test-key",
+				unboundModelId: "openai/gpt-4o",
+			})
+
+			const chunks = await collectStream(
+				handler.createMessage(
+					"system",
+					[{ role: "user", content: "hi" }],
+					makeCreateMessageMetadata({ abortSignal: controller.signal }),
+				),
+			)
+
+			expect(chunks).toContainEqual({ type: "text", text: "ok" })
+			expect(removeListenerSpy).toHaveBeenCalledWith("abort", expect.any(Function))
+			expect(controller.signal.aborted).toBe(false)
+		})
 	})
 })

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

@@ -754,6 +754,29 @@ describe("VercelAiGatewayHandler", () => {
 			)
 		})
 
+		it("should omit the timeout option when timeoutMs is 0", async () => {
+			// The OpenAI SDK treats timeout: 0 as an immediate abort, so the
+			// "disabled" value must never be forwarded — assert the absence of
+			// the option (a forwarded timeout: 0 would fail this assertion).
+			const handler = new VercelAiGatewayHandler(mockOptions)
+			mockCreate.mockImplementation(async () => ({
+				choices: [
+					{
+						message: { role: "assistant", content: "response" },
+						finish_reason: "stop",
+						index: 0,
+					},
+				],
+			}))
+
+			await handler.completePrompt("test prompt", { timeoutMs: 0 })
+			const call = mockCreate.mock.calls[mockCreate.mock.calls.length - 1]
+			const requestOptions = call[1] as { timeout?: number } | undefined
+			// When no option is forwarded the provider omits the SDK options
+			// argument entirely, so absence means: undefined arg OR an arg
+			// without a timeout key.
+			expect(Object.keys(requestOptions ?? {})).not.toContain("timeout")
+		})
 		it("should work without options (backward compatible)", async () => {
 			const handler = new VercelAiGatewayHandler(mockOptions)
 			mockCreate.mockImplementation(async () => ({
@@ -824,6 +847,41 @@ describe("VercelAiGatewayHandler", () => {
 			await expect(consumed).rejects.toMatchObject({ name: "AbortError" })
 			expect(capturedSignal?.aborted).toBe(true)
 		})
+
+		it("detaches the bridged abort listener when the request completes normally", async () => {
+			// The listener is added with { once: true }, so it only detaches on
+			// abort. A task-scoped signal spanning many requests must not
+			// accumulate a listener per request: assert explicit removal after a
+			// normal (non-aborted) completion.
+			mockCreate.mockImplementation(async () =>
+				asyncStreamFrom([
+					{
+						choices: [{ delta: { content: "ok" }, index: 0 }],
+						index: 0,
+					},
+					{
+						choices: [{ delta: {}, index: 0 }],
+						index: 0,
+						usage: { prompt_tokens: 2, completion_tokens: 3 },
+					},
+				]),
+			)
+
+			const handler = new VercelAiGatewayHandler(mockOptions)
+			const controller = new AbortController()
+			const removeListenerSpy = vi.spyOn(controller.signal, "removeEventListener")
+
+			const stream = handler.createMessage(
+				"test prompt",
+				[{ role: "user", content: "hello" }],
+				makeCreateMessageMetadata({ abortSignal: controller.signal }),
+			)
+
+			const chunks = await collectStream(stream)
+			expect(chunks).toContainEqual({ type: "text", text: "ok" })
+			expect(removeListenerSpy).toHaveBeenCalledWith("abort", expect.any(Function))
+			expect(controller.signal.aborted).toBe(false)
+		})
 	})
 
 	describe("temperature support", () => {

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

@@ -487,17 +487,19 @@ describe("ZooGatewayHandler", () => {
 			)
 		})
 
-		it("should pass timeoutMs=0 through to client", async () => {
+		it("should omit the timeout option when timeoutMs is 0", async () => {
+			// The OpenAI SDK treats timeout: 0 as an immediate abort, so the
+			// "disabled" value must never be forwarded — assert the absence of
+			// the option (a forwarded timeout: 0 would fail this assertion).
 			const handler = new ZooGatewayHandler(mockOptions)
 			mockCreate.mockImplementation(async () => ({
 				choices: [{ message: { role: "assistant", content: "response" } }],
 			}))
 
 			await handler.completePrompt("test prompt", { timeoutMs: 0 })
-			expect(mockCreate).toHaveBeenCalledWith(
-				expect.objectContaining({ model: expect.any(String) }),
-				expect.objectContaining({ timeout: 0 }),
-			)
+			const call = mockCreate.mock.calls[mockCreate.mock.calls.length - 1]
+			const requestOptions = call[1] as { timeout?: number } | undefined
+			expect(requestOptions).not.toHaveProperty("timeout")
 		})
 
 		it("should work without options (backward compatible)", async () => {
@@ -564,6 +566,41 @@ describe("ZooGatewayHandler", () => {
 			await expect(consumed).rejects.toMatchObject({ name: "AbortError" })
 			expect(capturedSignal?.aborted).toBe(true)
 		})
+
+		it("detaches the bridged abort listener when the request completes normally", async () => {
+			// The listener is added with { once: true }, so it only detaches on
+			// abort. A task-scoped signal spanning many requests must not
+			// accumulate a listener per request: assert explicit removal after a
+			// normal (non-aborted) completion.
+			mockCreate.mockImplementation(async () =>
+				asyncStreamFrom([
+					{
+						choices: [{ delta: { content: "ok" }, index: 0 }],
+						index: 0,
+					},
+					{
+						choices: [{ delta: {}, index: 0 }],
+						index: 0,
+						usage: { prompt_tokens: 2, completion_tokens: 3 },
+					},
+				]),
+			)
+
+			const handler = new ZooGatewayHandler(mockOptions)
+			const controller = new AbortController()
+			const removeListenerSpy = vi.spyOn(controller.signal, "removeEventListener")
+
+			const stream = handler.createMessage(
+				"prompt",
+				[{ role: "user", content: "hello" }],
+				makeCreateMessageMetadata({ abortSignal: controller.signal }),
+			)
+
+			const chunks = await collectStream(stream)
+			expect(chunks).toContainEqual({ type: "text", text: "ok" })
+			expect(removeListenerSpy).toHaveBeenCalledWith("abort", expect.any(Function))
+			expect(controller.signal.aborted).toBe(false)
+		})
 	})
 	describe("classifyGatewayApiError", () => {
 		it("returns sign_in on 401", () => {