feat(api): add ensureModelFetched to the six remaining catalog providers

Add BaseProvider.ensureCatalogLoaded, a single-flight one-time catalog load
mirroring RouterProvider.ensureModelFetched: concurrent callers share one
fetch, a successful load is memoized, a failed load is retried, and a
caller's signal detaches only that caller's wait.

Wire the hook into openrouter, requesty, unbound, poe, lm-studio and
native-ollama, and drop OpenRouter's eager constructor fetch so the catalog
loads on demand instead of at handler construction.

Extend the shared adapter harness with a pre-warm matrix (memoization,
retry, single flight, pre-aborted caller, mid-flight waiter detach) plus
per-provider regression tests and direct ensureCatalogLoaded unit tests.

Author: p12tic

src/api/providers/__tests__/base-provider.spec.ts

@@ -32,6 +32,11 @@ class TestProvider extends BaseProvider {
 	public testConvertToolsForOpenAI(tools: any[] | undefined, strict?: boolean): any[] | undefined {
 		return this.convertToolsForOpenAI(tools, strict)
 	}
+
+	// Expose protected method for testing
+	public testEnsureCatalogLoaded(load: () => Promise<void>, signal?: AbortSignal): Promise<void> {
+		return this.ensureCatalogLoaded(load, signal)
+	}
 }
 
 describe("BaseProvider", () => {
@@ -527,4 +532,83 @@ describe("BaseProvider", () => {
 			expect(result?.[0]).toEqual(tools[0])
 		})
 	})
+
+	describe("ensureCatalogLoaded", () => {
+		it("loads once and memoizes a successful load", async () => {
+			const load = vi.fn().mockResolvedValue(undefined)
+
+			await provider.testEnsureCatalogLoaded(load)
+			await provider.testEnsureCatalogLoaded(load)
+
+			expect(load).toHaveBeenCalledTimes(1)
+		})
+
+		it("single-flights concurrent callers", async () => {
+			let resolveLoad: () => void = () => {}
+			const load = vi.fn(
+				() =>
+					new Promise<void>((resolve) => {
+						resolveLoad = resolve
+					}),
+			)
+
+			const first = provider.testEnsureCatalogLoaded(load)
+			const second = provider.testEnsureCatalogLoaded(load)
+
+			expect(load).toHaveBeenCalledTimes(1)
+
+			resolveLoad()
+			await Promise.all([first, second])
+		})
+
+		it("retries after a failed load", async () => {
+			const load = vi.fn().mockRejectedValueOnce(new Error("catalog unavailable")).mockResolvedValue(undefined)
+
+			await expect(provider.testEnsureCatalogLoaded(load)).rejects.toThrow("catalog unavailable")
+			await expect(provider.testEnsureCatalogLoaded(load)).resolves.toBeUndefined()
+
+			expect(load).toHaveBeenCalledTimes(2)
+		})
+
+		it("rejects a pre-aborted caller without starting a load", async () => {
+			const controller = new AbortController()
+			controller.abort(new Error("caller gave up"))
+			const load = vi.fn().mockResolvedValue(undefined)
+
+			await expect(provider.testEnsureCatalogLoaded(load, controller.signal)).rejects.toThrow("caller gave up")
+			expect(load).not.toHaveBeenCalled()
+		})
+
+		it("detaches only the aborted waiter while the shared load still settles", async () => {
+			let resolveLoad: () => void = () => {}
+			const load = vi.fn(
+				() =>
+					new Promise<void>((resolve) => {
+						resolveLoad = resolve
+					}),
+			)
+
+			const controller = new AbortController()
+			const wait = provider.testEnsureCatalogLoaded(load, controller.signal)
+			controller.abort(new Error("caller gave up"))
+
+			await expect(wait).rejects.toThrow("caller gave up")
+
+			resolveLoad()
+			await new Promise((resolve) => setTimeout(resolve, 0))
+
+			// The shared load completed, so a later caller is a memoized no-op.
+			await expect(provider.testEnsureCatalogLoaded(load)).resolves.toBeUndefined()
+			expect(load).toHaveBeenCalledTimes(1)
+		})
+
+		it("does not forward the caller signal to the shared load", async () => {
+			const controller = new AbortController()
+			const load = vi.fn().mockResolvedValue(undefined)
+
+			await provider.testEnsureCatalogLoaded(load, controller.signal)
+
+			expect(load).toHaveBeenCalledWith()
+		})
+	})
 })

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

@@ -62,9 +62,21 @@ vi.mock("openai", () => {
 
 import type { Anthropic } from "@anthropic-ai/sdk"
 
+import { providerIdentifiers } from "@roo-code/types"
+
 import { LmStudioHandler } from "../lm-studio"
 import type { ApiHandlerOptions } from "../../../shared/api"
 
+const { mockGetModels, mockGetModelsFromCache } = vi.hoisted(() => ({
+	mockGetModels: vi.fn(),
+	mockGetModelsFromCache: vi.fn(),
+}))
+
+vi.mock("../fetchers/modelCache", () => ({
+	getModels: mockGetModels,
+	getModelsFromCache: mockGetModelsFromCache,
+}))
+
 describe("LmStudioHandler", () => {
 	let handler: LmStudioHandler
 	let mockOptions: ApiHandlerOptions
@@ -77,6 +89,9 @@ describe("LmStudioHandler", () => {
 		}
 		handler = new LmStudioHandler(mockOptions)
 		mockCreate.mockClear()
+		mockGetModels.mockReset()
+		mockGetModelsFromCache.mockReset()
+		mockGetModelsFromCache.mockReturnValue(undefined)
 	})
 
 	describe("constructor", () => {
@@ -258,4 +273,31 @@ describe("LmStudioHandler", () => {
 			expect(modelInfo.info.contextWindow).toBe(128_000)
 		})
 	})
+
+	describe("ensureModelFetched", () => {
+		it("returns default info before the pre-warm and cached info after", async () => {
+			// The pre-warm populates the shared cache that getModel() reads, so the
+			// cache starts empty and is filled by the mocked getModels() call.
+			let cacheContents: Record<string, { maxTokens: number; contextWindow: number }> | undefined
+			mockGetModelsFromCache.mockImplementation(() => cacheContents)
+			mockGetModels.mockImplementation(async () => {
+				cacheContents = { "local-model": { maxTokens: 4096, contextWindow: 32_768 } }
+				return cacheContents
+			})
+
+			expect(handler.getModel().info.contextWindow).toBe(128_000)
+
+			await handler.ensureModelFetched()
+
+			expect(mockGetModels).toHaveBeenCalledWith(
+				{
+					provider: providerIdentifiers.lmstudio,
+					baseUrl: "http://localhost:1234",
+				},
+				handler,
+			)
+			expect(handler.getModel().info.contextWindow).toBe(32_768)
+			expect(handler.getModel().info.maxTokens).toBe(4096)
+		})
+	})
 })