refactor: add schema validation to readModels and extract common validation logic

- Extract `validateModelRecord` helper to deduplicate Zod validation logic

- Add `modelRecordSchema.safeParse()` validation to `readModels` disk cache reads

- Update tests to ensure Zod validation strictly enforces `ModelRecord` schema

This resolves a vulnerability where a corrupted or tampered disk cache JSON file could lead to the injection of unexpected properties.

Author: daewoongoh

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

@@ -61,7 +61,8 @@ vi.mock("../../../core/config/ContextProxy", () => ({
 
 // Then imports
 import type { Mock, Mocked } from "vitest"
-import { providerIdentifiers } from "@roo-code/types"
+import { providerIdentifiers, modelInfoSchema } from "@roo-code/types"
+import { z } from "zod"
 import * as fsSync from "fs"
 import NodeCache from "node-cache"
 import { TelemetryService } from "@roo-code/telemetry"
@@ -356,6 +357,32 @@ describe("getModelsFromCache disk fallback", () => {
 	})
 })
 
+describe("validateModelRecord schema validation", () => {
+	// Mirrors the modelRecordSchema used by the private validateModelRecord helper.
+	const modelRecordSchema = z.record(z.string(), modelInfoSchema)
+
+	it("accepts a valid ModelRecord", () => {
+		const validModels = {
+			"cached-model": {
+				maxTokens: 8192,
+				contextWindow: 200000,
+				supportsPromptCache: true,
+			},
+		}
+		const result = modelRecordSchema.safeParse(validModels)
+
+		expect(result.success).toBe(true)
+		expect(result.data).toEqual(validModels)
+	})
+
+	it("rejects data that does not conform to ModelRecord", () => {
+		const invalidData = [{ notAModelRecord: true }]
+		const result = modelRecordSchema.safeParse(invalidData)
+
+		expect(result.success).toBe(false)
+	})
+})
+
 describe("empty cache protection", () => {
 	let mockCache: Mocked<NodeCache>
 	let mockGet: Mocked<NodeCache>["get"]

src/api/providers/fetchers/modelCache.ts

@@ -204,12 +204,28 @@ async function writeModels(cacheKey: string, data: ModelRecord) {
 	await safeWriteJson(path.join(cacheDir, filename), data)
 }
 
+/**
+ * Validate parsed JSON data against the ModelRecord Zod schema.
+ * Returns the validated data on success, or undefined (with an error log) on failure.
+ */
+function validateModelRecord(data: unknown, cacheKey: string): ModelRecord | undefined {
+	const validation = modelRecordSchema.safeParse(data)
+	if (!validation.success) {
+		console.error(`[MODEL_CACHE] Invalid disk cache for ${cacheKey}:`, validation.error.format())
+		return undefined
+	}
+	return validation.data
+}
+
 async function readModels(cacheKey: string): Promise<ModelRecord | undefined> {
 	const filename = `${cacheKeyToFilename(cacheKey)}_models.json`
 	const cacheDir = await getCacheDirectoryPath(ContextProxy.instance.globalStorageUri.fsPath)
 	const filePath = path.join(cacheDir, filename)
 	const exists = await fileExistsAtPath(filePath)
-	return exists ? JSON.parse(await fs.readFile(filePath, "utf8")) : undefined
+	if (!exists) return undefined
+
+	const data = JSON.parse(await fs.readFile(filePath, "utf8"))
+	return validateModelRecord(data, cacheKey)
 }
 
 /**
@@ -533,21 +549,15 @@ export function getModelsFromCache(options: GetModelsOptions | ProviderName): Mo
 			const data = fsSync.readFileSync(filePath, "utf8")
 			const models = JSON.parse(data)
 
-			// Validate the disk cache data structure using Zod schema
-			// This ensures the data conforms to ModelRecord = Record<string, ModelInfo>
-			const validation = modelRecordSchema.safeParse(models)
-			if (!validation.success) {
-				console.error(
-					`[MODEL_CACHE] Invalid disk cache data structure for ${cacheKey}:`,
-					validation.error.format(),
-				)
+			const validated = validateModelRecord(models, cacheKey)
+			if (!validated) {
 				return undefined
 			}
 
 			// Populate memory cache for future fast access
-			memoryCache.set(cacheKey, validation.data)
+			memoryCache.set(cacheKey, validated)
 
-			return validation.data
+			return validated
 		}
 	} catch (error) {
 		console.error(`[MODEL_CACHE] Error loading ${cacheKey} models from disk:`, error)