fix(openrouter): address CodeRabbit review findings

- abort the per-request controller in createMessage's finally so an abandoned
  generator (early break / downstream error) cancels the in-flight stream
- reject pre-aborted completePrompt with the canonical createAbortError
  message instead of throwIfAborted's generic text (drop the now-unused
  throwIfAborted import and its Stryker directive)
- extract the duplicated settlesWithin helper into shared
  src/test-utils/promise.ts and import it from both spec files
- assert the registered abort listener by identity instead of
  expect.any(Function)
- add a test that verifies abandoning the generator aborts the request signal

Author: easonliang28

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

@@ -25,6 +25,7 @@ import { makeApiHandlerOptions, makeCreateMessageMetadata } from "../../../test-
 import { asyncStreamFrom, collectStream } from "../../../test-utils/stream"
 import { collectStreamAndParseToolCalls } from "../../../test-utils/native-tool-call-stream"
 import { clearAllMocks } from "../../../test-utils/reset"
+import { settlesWithin } from "../../../test-utils/promise"
 
 vitest.mock("openai")
 vitest.mock("delay", () => ({
@@ -109,27 +110,6 @@ vitest.mock("../fetchers/modelCache", () => ({
 	}),
 }))
 
-/**
- * Fail fast when an awaited operation never settles. Mutations that break abort
- * propagation would otherwise hang the test until Stryker's per-mutant timeout,
- * marking the mutant "Timeout" instead of "Killed".
- */
-function settlesWithin<T>(promise: Promise<T>, ms: number): Promise<T> {
-	return new Promise<T>((resolve, reject) => {
-		const timer = setTimeout(() => reject(new Error("operation did not settle within " + ms + "ms")), ms)
-		void promise.then(
-			(value) => {
-				clearTimeout(timer)
-				resolve(value)
-			},
-			(error) => {
-				clearTimeout(timer)
-				reject(error)
-			},
-		)
-	})
-}
-
 const ABORT_SETTLE_MS = 150
 
 describe("OpenRouterHandler", () => {
@@ -859,6 +839,45 @@ describe("OpenRouterHandler", () => {
 			})
 			expect(chunks).toContainEqual({ type: "text", text: "first" })
 		})
+		it("cancels the in-flight stream when the consumer abandons the generator", async () => {
+			const handler = new OpenRouterHandler(mockOptions)
+
+			// Emulate the OpenAI SDK: the first chunk arrives, then the response body
+			// stalls until the request signal aborts — no further chunk arrives on its own.
+			let requestSignal: AbortSignal | undefined
+			const mockCreate = vitest
+				.fn()
+				.mockImplementation(async (_params: unknown, options?: { signal?: AbortSignal }) => {
+					requestSignal = options?.signal
+					return (async function* () {
+						yield { id: "1", choices: [{ delta: { content: "first" } }] }
+						await new Promise<void>((resolve) => {
+							expect(requestSignal).toBeDefined()
+							if (requestSignal!.aborted) {
+								resolve()
+							} else {
+								requestSignal!.addEventListener("abort", () => resolve(), { once: true })
+							}
+						})
+						yield { id: "2", choices: [{ delta: { content: "second" } }] }
+					})()
+				})
+			// The auto-mocked OpenAI client is injected via a structural type to avoid `any` casts.
+			const client = handler["client"] as unknown as { chat: { completions: { create: typeof mockCreate } } }
+			client.chat = { completions: { create: mockCreate } }
+
+			const generator = handler.createMessage("test", [{ role: "user" as const, content: "hi" }])
+
+			const first = await settlesWithin(generator.next(), ABORT_SETTLE_MS)
+			expect(first.value).toEqual({ type: "text", text: "first" })
+			expect(requestSignal?.aborted).toBe(false)
+
+			// Abandon the generator mid-stream: the finally block must abort the per-request
+			// controller so the in-flight stream is cancelled instead of lingering until
+			// the client-level timeout.
+			await settlesWithin(generator.return(undefined), ABORT_SETTLE_MS)
+			expect(requestSignal?.aborted).toBe(true)
+		})
 		it("does not emit buffered chunks after a mid-stream abort (iterator keeps delivering)", async () => {
 			const handler = new OpenRouterHandler(mockOptions)
 			const controller = new AbortController()
@@ -2501,7 +2520,7 @@ describe("OpenRouterHandler", () => {
 				handler.completePrompt("test prompt", { abortSignal: controller.signal }),
 			).rejects.toMatchObject({
 				name: "AbortError",
-				message: "This operation was aborted",
+				message: "The OpenRouter request was aborted",
 			})
 			// The pre-abort guard rejects before any model lookup beyond the constructor's own.
 			const { getModels } = await import("../fetchers/modelCache")

src/api/providers/openrouter.ts

@@ -36,13 +36,7 @@ import { DEFAULT_HEADERS, NOT_PROVIDED } from "./constants"
 import { BaseProvider } from "./base-provider"
 import type { ApiHandlerCreateMessageMetadata, CompletePromptOptions, SingleCompletionHandler } from "../index"
 import { handleOpenAIError } from "./utils/error-handler"
-import {
-	createAbortError,
-	isRequestAborted,
-	mergeAbortSignalAndTimeout,
-	rejectOnAbort,
-	throwIfAborted,
-} from "./utils/abort-signal"
+import { createAbortError, isRequestAborted, mergeAbortSignalAndTimeout, rejectOnAbort } from "./utils/abort-signal"
 import { generateImageWithProvider, ImageGenerationResult } from "./utils/image-generation"
 import { applyRouterToolPreferences } from "./utils/router-tool-preferences"
 
@@ -628,6 +622,10 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 			}
 		} finally {
 			removeExternalAbortListener?.()
+			// Cancel the in-flight request when the consumer abandons the generator
+			// (early break / downstream error). No-op once the stream has completed
+			// or the controller is already aborted.
+			controller.abort()
 		}
 	}
 
@@ -678,9 +676,8 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 		// waiting for the lookup to settle. The configured timeoutMs covers the lookup
 		// as well.
 		const requestAbortSignal = mergeAbortSignalAndTimeout(options?.abortSignal, options?.timeoutMs)
-		// Stryker disable next-line ConditionalExpression: without signal or timeout the merged signal is undefined and throwIfAborted(undefined) is a no-op, so forcing the branch is unobservable
-		if (requestAbortSignal) {
-			throwIfAborted(requestAbortSignal)
+		if (requestAbortSignal?.aborted) {
+			throw createAbortError(this.providerName)
 		}
 
 		let model: Awaited<ReturnType<OpenRouterHandler["fetchModel"]>>

src/api/providers/utils/__tests__/abort-signal.spec.ts

@@ -6,27 +6,7 @@ import {
 	rejectOnAbort,
 	throwIfAborted,
 } from "../abort-signal"
-
-/**
- * Fail fast when a promise never settles. Mutations that remove the settle,
- * reject, or abort wiring would otherwise hang the test until Stryker's
- * per-mutant timeout, marking the mutant "Timeout" instead of "Killed".
- */
-function settlesWithin<T>(promise: Promise<T>, ms: number): Promise<T> {
-	return new Promise<T>((resolve, reject) => {
-		const timer = setTimeout(() => reject(new Error("promise did not settle within " + ms + "ms")), ms)
-		void promise.then(
-			(value) => {
-				clearTimeout(timer)
-				resolve(value)
-			},
-			(error) => {
-				clearTimeout(timer)
-				reject(error)
-			},
-		)
-	})
-}
+import { settlesWithin } from "../../../../test-utils/promise"
 
 const SETTLE_MS = 200
 
@@ -116,7 +96,9 @@ describe("rejectOnAbort", () => {
 		controller.abort()
 
 		await expect(settlesWithin(race, SETTLE_MS)).rejects.toMatchObject({ name: "AbortError" })
-		expect(addSpy).toHaveBeenCalledWith("abort", expect.any(Function), { once: true })
+		const registeredListener = addSpy.mock.calls[0]?.[1]
+		expect(registeredListener).toBeTypeOf("function")
+		expect(addSpy).toHaveBeenCalledWith("abort", registeredListener, { once: true })
 		addSpy.mockRestore()
 	})
 })

src/test-utils/promise.ts

@@ -0,0 +1,20 @@
+/**
+ * Fail fast when a promise never settles. Mutations that break settle or
+ * reject wiring would otherwise hang the test until Stryker's per-mutant
+ * timeout, marking the mutant "Timeout" instead of "Killed".
+ */
+export function settlesWithin<T>(promise: Promise<T>, ms: number): Promise<T> {
+	return new Promise<T>((resolve, reject) => {
+		const timer = setTimeout(() => reject(new Error(`operation did not settle within ${ms}ms`)), ms)
+		void promise.then(
+			(value) => {
+				clearTimeout(timer)
+				resolve(value)
+			},
+			(error) => {
+				clearTimeout(timer)
+				reject(error)
+			},
+		)
+	})
+}