feat(api): abort signal support for requesty (createMessage + kill tests)

src/api/providers/fetchers/__tests__/modelCache.spec.ts

@@ -169,6 +169,29 @@ describe("getModels with new GetModelsOptions", () => {
 		expect(result).toEqual(mockModels)
 	})
 
+	it("forwards the caller's cancellation signal to Requesty model discovery", async () => {
+		setupCancellationMocks()
+		// Keep the fetch pending so the caller's abort lands mid-flight: under the
+		// single-flight contract the caller's signal detaches this waiter (and rejects
+		// it with the canonical AbortError) instead of being handed to the fetcher.
+		const fetchModels = vi.fn().mockImplementation(() => new Promise<ModelRecord>(() => {}))
+		const handler = makeHandler(REQUESTY_SCOPE, fetchModels)
+
+		const controller = new AbortController()
+		const promise = getModels(
+			{
+				provider: providerIdentifiers.requesty,
+				apiKey: DUMMY_REQUESTY_KEY,
+				signal: controller.signal,
+			},
+			handler,
+		)
+
+		controller.abort()
+
+		await expect(promise).rejects.toMatchObject({ name: "AbortError" })
+	})
+
 	it("dispatches credentialed fetchers through canonical provider identifiers", async () => {
 		const mockModels = {
 			"requesty/canonical-model": {

src/api/providers/fetchers/__tests__/requesty.spec.ts

@@ -166,16 +166,75 @@ describe("getRequestyModels", () => {
 		expect(sonnet.supportsTemperature).toBeUndefined()
 	})
 
-	it("passes the caller's abort signal to the catalog request", async () => {
+	it("threads a wall-clock merged signal and the bounded timeout into the models request", async () => {
 		const controller = new AbortController()
 		mockAxiosGet.mockResolvedValueOnce({ data: { data: [] } })
 
 		await getRequestyModels(undefined, undefined, { signal: controller.signal })
 
+		// The shared axios mock accumulates calls across this file's tests, so assert on
+		// the call this test just made (the last one) rather than a global call count.
+		const calls = mockAxiosGet.mock.calls
+		const config = calls[calls.length - 1]?.[1]
+		expect(config?.signal).toBeInstanceOf(AbortSignal)
+		// The request signal is the caller's signal merged with the wall-clock
+		// deadline, not the raw caller signal: axios's timeout option resets when
+		// headers arrive, so only the merged signal enforces the 10_000 ms limit.
+		expect(config?.signal).not.toBe(controller.signal)
+		expect(config?.timeout).toBe(10_000)
+
+		// The caller's abort still propagates through the merged signal.
+		controller.abort()
+		expect(config?.signal?.aborted).toBe(true)
+	})
+
+	it("applies the bounded timeout as a standalone timeout signal when no signal is provided", async () => {
+		mockAxiosGet.mockResolvedValueOnce({ data: { data: [] } })
+
+		await getRequestyModels()
+
+		const calls = mockAxiosGet.mock.calls
+		const config = calls[calls.length - 1]?.[1]
+		// Even without a caller signal the request carries the wall-clock deadline
+		// as its own timeout signal.
+		expect(config?.signal).toBeInstanceOf(AbortSignal)
+		expect(config?.signal?.aborted).toBe(false)
+		expect(config?.timeout).toBe(10_000)
+	})
+
+	it("passes a merged request signal and the bounded timeout to the catalog request", async () => {
+		const controller = new AbortController()
+		mockAxiosGet.mockResolvedValueOnce({ data: { data: [] } })
+
+		await getRequestyModels(undefined, undefined, { signal: controller.signal })
+
+		const calls = mockAxiosGet.mock.calls
+		const config = calls[calls.length - 1]?.[1]
 		expect(mockAxiosGet).toHaveBeenCalledWith("https://router.requesty.ai/v1/models", {
 			headers: {},
-			signal: controller.signal,
+			signal: config?.signal,
+			timeout: 10_000,
 		})
+		expect(config?.signal).toBeInstanceOf(AbortSignal)
+	})
+
+	it("aborts the catalog request when the caller signal aborts after the request signal was merged", async () => {
+		const controller = new AbortController()
+		let requestSignal: AbortSignal | undefined
+		mockAxiosGet.mockImplementation(((_url: string, config?: { signal?: AbortSignal }) => {
+			requestSignal = config?.signal
+			// Mirror the HTTP client: reject when the request signal fires.
+			return new Promise<never>((_resolve, reject) => {
+				requestSignal?.addEventListener("abort", () => reject(new Error("canceled")), { once: true })
+			})
+		}) as typeof axios.get)
+
+		const fetchPromise = getRequestyModels(undefined, undefined, { signal: controller.signal })
+		expect(requestSignal).toBeInstanceOf(AbortSignal)
+		expect(requestSignal).not.toBe(controller.signal)
+		controller.abort()
+
+		await expect(fetchPromise).rejects.toMatchObject({ name: "AbortError" })
 	})
 
 	it("rejects with an AbortError when the signal aborts the pending request", async () => {

src/api/providers/fetchers/requesty.ts

@@ -5,7 +5,12 @@ import type { ModelInfo } from "@roo-code/types"
 import { parseApiPrice } from "../../../shared/cost"
 import { toRequestyServiceUrl } from "../../../shared/utils/requesty"
 
-import { throwIfAborted } from "../utils/abort-signal"
+import { mergeAbortSignalAndTimeout, throwIfAborted } from "../utils/abort-signal"
+
+// Bounded wall-clock limit for the models discovery request. Without it a hung connection
+// would keep the request alive indefinitely; 10_000 ms matches the other in-tree axios
+// fetchers (kenari, opencode-go, nanogpt).
+const REQUESTY_MODELS_TIMEOUT_MS = 10_000
 
 export async function getRequestyModels(
 	baseUrl?: string,
@@ -24,7 +29,16 @@ export async function getRequestyModels(
 		const resolvedBaseUrl = toRequestyServiceUrl(baseUrl)
 		const modelsUrl = new URL("v1/models", resolvedBaseUrl)
 
-		const response = await axios.get(modelsUrl.toString(), { headers, signal: opts?.signal })
+		// Axios's own timeout resets once response headers arrive (follow-redirects),
+		// so a slow body could outlive REQUESTY_MODELS_TIMEOUT_MS. Merge the wall-clock
+		// deadline into the request signal so the fetch is bounded end to end.
+		const requestSignal = mergeAbortSignalAndTimeout(opts?.signal, REQUESTY_MODELS_TIMEOUT_MS)
+
+		const response = await axios.get(modelsUrl.toString(), {
+			headers,
+			signal: requestSignal,
+			timeout: REQUESTY_MODELS_TIMEOUT_MS,
+		})
 		const rawModels = response.data.data
 
 		for (const rawModel of rawModels) {