fix(router-provider): fetch model metadata before context management decisions

src/api/index.ts

@@ -125,6 +125,13 @@ export interface ApiHandler {
 
 	getModel(): { id: string; info: ModelInfo }
 
+	/**
+	 * Ensures model metadata has been fetched from the remote API so that getModel()
+	 * returns accurate info (context window, pricing, etc.) instead of hardcoded defaults.
+	 * Only router providers that discover models over the network implement this.
+	 */
+	ensureModelFetched?(): Promise<void>
+
 	/**
 	 * Optional context window for context-management / auto-condense when it must differ from
 	 * getModel().info.contextWindow. Only VS Code LM overrides it (static `maxInputTokens` vs its

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

@@ -635,4 +635,92 @@ describe("ZooGatewayHandler", () => {
 			)
 		})
 	})
+
+	describe("ensureModelFetched", () => {
+		it("fetches models when instance models are empty", async () => {
+			const handler = new ZooGatewayHandler(mockOptions)
+			const { getModels } = await import("../fetchers/modelCache")
+
+			expect(handler.getModel().info.contextWindow).toBe(200000)
+
+			await handler.ensureModelFetched()
+
+			expect(getModels).toHaveBeenCalled()
+		})
+
+		it("skips the fetch when models are already populated", async () => {
+			const handler = new ZooGatewayHandler(mockOptions)
+			const { getModels } = await import("../fetchers/modelCache")
+
+			await handler.ensureModelFetched()
+			vitest.mocked(getModels).mockClear()
+
+			await handler.ensureModelFetched()
+			expect(getModels).not.toHaveBeenCalled()
+		})
+
+		it("short-circuits a subsequent fetchModel call after models are populated", async () => {
+			const handler = new ZooGatewayHandler(mockOptions)
+			const { getModels } = await import("../fetchers/modelCache")
+
+			await handler.ensureModelFetched()
+			vitest.mocked(getModels).mockClear()
+
+			await handler.fetchModel()
+			expect(getModels).not.toHaveBeenCalled()
+		})
+
+		it("deduplicates concurrent calls into a single fetch", async () => {
+			const handler = new ZooGatewayHandler(mockOptions)
+			const { getModels } = await import("../fetchers/modelCache")
+			vitest.mocked(getModels).mockClear()
+
+			await Promise.all([handler.ensureModelFetched(), handler.ensureModelFetched()])
+
+			expect(getModels).toHaveBeenCalledTimes(1)
+		})
+
+		it("recovers after a rejected fetch so later calls are not poisoned", async () => {
+			const handler = new ZooGatewayHandler(mockOptions)
+			const { getModels } = await import("../fetchers/modelCache")
+
+			vitest.mocked(getModels).mockRejectedValueOnce(new Error("network down"))
+			await expect(handler.ensureModelFetched()).rejects.toThrow("network down")
+
+			vitest.mocked(getModels).mockResolvedValueOnce({
+				"anthropic/claude-sonnet-4": {
+					maxTokens: 64000,
+					contextWindow: 1000000,
+					supportsImages: true,
+					supportsPromptCache: true,
+				},
+			})
+			await handler.ensureModelFetched()
+
+			expect(handler.getModel().info.contextWindow).toBe(1000000)
+		})
+
+		it("makes getModel return the fetched context window instead of the default", async () => {
+			const { getModels } = await import("../fetchers/modelCache")
+			vitest.mocked(getModels).mockResolvedValueOnce({
+				"google/gemini-2.5-pro": {
+					maxTokens: 65536,
+					contextWindow: 1048576,
+					supportsImages: true,
+					supportsPromptCache: false,
+				},
+			})
+
+			const handler = new ZooGatewayHandler({
+				...mockOptions,
+				zooGatewayModelId: "google/gemini-2.5-pro",
+			})
+
+			expect(handler.getModel().info.contextWindow).toBe(200000)
+
+			await handler.ensureModelFetched()
+
+			expect(handler.getModel().info.contextWindow).toBe(1048576)
+		})
+	})
 })

src/api/providers/router-provider.ts

@@ -56,9 +56,33 @@ export abstract class RouterProvider extends BaseProvider {
 		})
 	}
 
+	private modelFetchPromise?: Promise<{ id: string; info: ModelInfo }>
+
 	public async fetchModel() {
-		this.models = await getModels({ provider: this.name, apiKey: this.client.apiKey, baseUrl: this.client.baseURL })
-		return this.getModel()
+		if (Object.keys(this.models).length > 0) {
+			return this.getModel()
+		}
+
+		if (!this.modelFetchPromise) {
+			this.modelFetchPromise = getModels({
+				provider: this.name,
+				apiKey: this.client.apiKey,
+				baseUrl: this.client.baseURL,
+			})
+				.then((models) => {
+					this.models = models
+					return this.getModel()
+				})
+				.finally(() => {
+					this.modelFetchPromise = undefined
+				})
+		}
+
+		return this.modelFetchPromise
+	}
+
+	async ensureModelFetched(): Promise<void> {
+		await this.fetchModel()
 	}
 
 	override getModel(): { id: string; info: ModelInfo } {

src/core/task/Task.ts

@@ -2762,6 +2762,8 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 
 				await this.diffViewProvider.reset()
 
+				await this.safeEnsureModelFetched()
+
 				// Cache model info once per API request to avoid repeated calls during streaming
 				// This is especially important for tools and background usage collection
 				this.cachedStreamingModel = this.api.getModel()
@@ -3837,11 +3839,28 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		)
 	}
 
+	/**
+	 * Ensures router-provider model metadata is loaded before getModel() is used for
+	 * context management or streaming. Failures fall back to hardcoded defaults rather
+	 * than aborting the task.
+	 */
+	private async safeEnsureModelFetched(): Promise<void> {
+		try {
+			await this.api.ensureModelFetched?.()
+		} catch (error) {
+			console.error(
+				`[Task#${this.taskId}] Failed to fetch model metadata:`,
+				error instanceof Error ? error.message : error,
+			)
+		}
+	}
+
 	private async handleContextWindowExceededError(): Promise<void> {
 		const state = await this.providerRef.deref()?.getState()
 		const { profileThresholds = {}, mode, apiConfiguration } = state ?? {}
 
 		const { contextTokens } = this.getTokenUsage()
+		await this.safeEnsureModelFetched()
 		const modelInfo = this.api.getModel().info
 
 		const maxTokens = getModelMaxOutputTokens({
@@ -4042,6 +4061,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		const { contextTokens } = this.getTokenUsage()
 
 		if (contextTokens) {
+			await this.safeEnsureModelFetched()
 			const modelInfo = this.api.getModel().info
 
 			const maxTokens = getModelMaxOutputTokens({