fix(ModelCache): Re-arm empty-model-response throttle for auth-scoped providers + privacy doc fix

Author: edelauna

PRIVACY.md

@@ -56,8 +56,8 @@ go—and, importantly, where they don't.
 ## **Your Choices & Control**
 
 - You can run models locally to prevent data being sent to third-parties.
-- Telemetry collection is enabled by default to help us improve Zoo Code, but
-  you can opt out at any time through the settings.
+- Telemetry collection is off by default and requires your explicit opt-in.
+  You can change your choice at any time through the settings.
 - You can delete Zoo Code to stop all data collection.
 
 ## **Security & Updates**

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

@@ -43,6 +43,7 @@ vi.mock("fs", () => ({
 vi.mock("../litellm")
 vi.mock("../openrouter")
 vi.mock("../requesty")
+vi.mock("../zoo-gateway")
 
 // Mock ContextProxy with a simple static instance
 vi.mock("../../../core/config/ContextProxy", () => ({
@@ -64,10 +65,12 @@ import { getModels, getModelsFromCache } from "../modelCache"
 import { getLiteLLMModels } from "../litellm"
 import { getOpenRouterModels } from "../openrouter"
 import { getRequestyModels } from "../requesty"
+import { getZooGatewayModels } from "../zoo-gateway"
 
 const mockGetLiteLLMModels = getLiteLLMModels as Mock<typeof getLiteLLMModels>
 const mockGetOpenRouterModels = getOpenRouterModels as Mock<typeof getOpenRouterModels>
 const mockGetRequestyModels = getRequestyModels as Mock<typeof getRequestyModels>
+const mockGetZooGatewayModels = getZooGatewayModels as Mock<typeof getZooGatewayModels>
 
 const DUMMY_REQUESTY_KEY = "requesty-key-for-testing"
 
@@ -296,6 +299,39 @@ describe("empty cache protection", () => {
 			expect(result).toEqual(mockModels)
 			expect(mockSet).toHaveBeenCalledWith("openrouter", mockModels)
 		})
+
+		it("re-arms the empty-response throttle after a non-empty response from an auth-scoped provider", async () => {
+			// zoo-gateway is auth-scoped and skips caching entirely, but a non-empty response
+			// must still clear the empty-response throttle so a later empty response is reported again.
+			mockGetZooGatewayModels.mockResolvedValueOnce({})
+
+			await getModels({ provider: "zoo-gateway", apiKey: "test-key" })
+
+			expect(TelemetryService.instance.captureEvent).toHaveBeenCalledTimes(1)
+
+			const mockModels = {
+				"zoo-gateway/model": {
+					maxTokens: 8192,
+					contextWindow: 128000,
+					supportsPromptCache: false,
+					description: "Zoo Gateway model",
+				},
+			}
+			mockGetZooGatewayModels.mockResolvedValueOnce(mockModels)
+
+			await getModels({ provider: "zoo-gateway", apiKey: "test-key" })
+
+			// Auth-scoped providers never populate the cache.
+			expect(mockSet).not.toHaveBeenCalled()
+
+			mockGetZooGatewayModels.mockResolvedValueOnce({})
+
+			await getModels({ provider: "zoo-gateway", apiKey: "test-key" })
+
+			// The throttle should have been re-armed by the non-empty response above, so this
+			// second empty response is reported again instead of being suppressed.
+			expect(TelemetryService.instance.captureEvent).toHaveBeenCalledTimes(2)
+		})
 	})
 
 	describe("refreshModels", () => {

src/api/providers/fetchers/modelCache.ts

@@ -279,15 +279,19 @@ export const getModels = async (options: GetModelsOptions): Promise<ModelRecord>
 
 		// Only cache non-empty results so a failed API response doesn't get persisted
 		// as if the provider had no models. Auth-scoped providers skip caching entirely.
-		if (modelCount > 0 && !shouldSkipCache) {
-			memoryCache.set(cacheKey, models)
+		if (modelCount > 0) {
+			// Clear the empty-response throttle for any non-empty response, including from
+			// auth-scoped providers that skip caching, so a later empty response is reported again.
+			reportedEmptyModelResponse.delete(cacheKey)
 
-			await writeModels(cacheKey, models).catch((err) =>
-				console.error(`[MODEL_CACHE] Error writing ${cacheKey} models to file cache:`, err),
-			)
+			if (!shouldSkipCache) {
+				memoryCache.set(cacheKey, models)
 
-			reportedEmptyModelResponse.delete(cacheKey)
-		} else if (modelCount === 0) {
+				await writeModels(cacheKey, models).catch((err) =>
+					console.error(`[MODEL_CACHE] Error writing ${cacheKey} models to file cache:`, err),
+				)
+			}
+		} else {
 			captureModelCacheEmptyResponseOnce(provider, cacheKey, { context: "getModels", hasExistingCache: false })
 		}