feat(zoo-gateway): add provider types, handler, and model fetcher

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: James Mtendamema

packages/types/src/provider-settings.ts

@@ -38,6 +38,7 @@ export const DEFAULT_CONSECUTIVE_MISTAKE_LIMIT = 3
 export const dynamicProviders = [
 	"openrouter",
 	"vercel-ai-gateway",
+	"zoo-gateway",
 	"litellm",
 	"requesty",
 	"unbound",
@@ -399,6 +400,12 @@ const vercelAiGatewaySchema = baseProviderSettingsSchema.extend({
 	vercelAiGatewayModelId: z.string().optional(),
 })
 
+const zooGatewaySchema = baseProviderSettingsSchema.extend({
+	zooSessionToken: z.string().optional(),
+	zooGatewayModelId: z.string().optional(),
+	zooGatewayBaseUrl: z.string().optional(),
+})
+
 const basetenSchema = apiModelIdProviderModelSchema.extend({
 	basetenApiKey: z.string().optional(),
 })
@@ -437,6 +444,7 @@ export const providerSettingsSchemaDiscriminated = z.discriminatedUnion("apiProv
 	fireworksSchema.merge(z.object({ apiProvider: z.literal("fireworks") })),
 	qwenCodeSchema.merge(z.object({ apiProvider: z.literal("qwen-code") })),
 	vercelAiGatewaySchema.merge(z.object({ apiProvider: z.literal("vercel-ai-gateway") })),
+	zooGatewaySchema.merge(z.object({ apiProvider: z.literal("zoo-gateway") })),
 	defaultSchema,
 ])
 
@@ -471,6 +479,7 @@ export const providerSettingsSchema = z.object({
 	...fireworksSchema.shape,
 	...qwenCodeSchema.shape,
 	...vercelAiGatewaySchema.shape,
+	...zooGatewaySchema.shape,
 	...codebaseIndexProviderSchema.shape,
 })
 
@@ -501,6 +510,7 @@ export const modelIdKeys = [
 	"unboundModelId",
 	"litellmModelId",
 	"vercelAiGatewayModelId",
+	"zooGatewayModelId",
 ] as const satisfies readonly (keyof ProviderSettings)[]
 
 export type ModelIdKey = (typeof modelIdKeys)[number]
@@ -546,6 +556,7 @@ export const modelIdKeysByProvider: Record<TypicalProvider, ModelIdKey> = {
 	zai: "apiModelId",
 	fireworks: "apiModelId",
 	"vercel-ai-gateway": "vercelAiGatewayModelId",
+	"zoo-gateway": "zooGatewayModelId",
 }
 
 /**
@@ -564,8 +575,13 @@ export const getApiProtocol = (provider: ProviderName | undefined, modelId?: str
 		return "anthropic"
 	}
 
-	// Vercel AI Gateway uses anthropic protocol for anthropic models.
-	if (provider && provider === "vercel-ai-gateway" && modelId && modelId.toLowerCase().startsWith("anthropic/")) {
+	// Vercel AI Gateway, Zoo Gateway, and Roo use anthropic protocol for anthropic models.
+	if (
+		provider &&
+		["vercel-ai-gateway", "zoo-gateway", "roo"].includes(provider) &&
+		modelId &&
+		modelId.toLowerCase().startsWith("anthropic/")
+	) {
 		return "anthropic"
 	}
 
@@ -662,6 +678,7 @@ export const MODELS_BY_PROVIDER: Record<
 	requesty: { id: "requesty", label: "Requesty", models: [] },
 	unbound: { id: "unbound", label: "Unbound", models: [] },
 	"vercel-ai-gateway": { id: "vercel-ai-gateway", label: "Vercel AI Gateway", models: [] },
+	"zoo-gateway": { id: "zoo-gateway", label: "Zoo Gateway", models: [] },
 
 	// Local providers; models discovered from localhost endpoints.
 	lmstudio: { id: "lmstudio", label: "LM Studio", models: [] },

packages/types/src/providers/index.ts

@@ -25,6 +25,7 @@ export * from "./vercel-ai-gateway.js"
 export * from "./zai.js"
 export * from "./minimax.js"
 export * from "./mimo.js"
+export * from "./zoo-gateway.js"
 
 import { anthropicDefaultModelId } from "./anthropic.js"
 import { basetenDefaultModelId } from "./baseten.js"
@@ -49,6 +50,7 @@ import { vercelAiGatewayDefaultModelId } from "./vercel-ai-gateway.js"
 import { internationalZAiDefaultModelId, mainlandZAiDefaultModelId } from "./zai.js"
 import { minimaxDefaultModelId } from "./minimax.js"
 import { mimoDefaultModelId } from "./mimo.js"
+import { zooGatewayDefaultModelId } from "./zoo-gateway.js"
 
 // Import the ProviderName type from provider-settings to avoid duplication
 import type { ProviderName } from "../provider-settings.js"
@@ -115,6 +117,8 @@ export function getProviderDefaultModelId(
 			return unboundDefaultModelId
 		case "vercel-ai-gateway":
 			return vercelAiGatewayDefaultModelId
+		case "zoo-gateway":
+			return zooGatewayDefaultModelId
 		case "anthropic":
 		case "gemini-cli":
 		case "fake-ai":

packages/types/src/providers/zoo-gateway.ts

@@ -0,0 +1,24 @@
+import type { ModelInfo } from "../model.js"
+
+// Zoo Gateway uses the same model ID format as Vercel AI Gateway (provider/model-name)
+export const zooGatewayDefaultModelId = "anthropic/claude-sonnet-4"
+
+// Zoo Gateway serves the same models as Vercel AI Gateway, so prompt caching support is identical
+// We reuse VERCEL_AI_GATEWAY_PROMPT_CACHING_MODELS from vercel-ai-gateway.ts
+// Instead of duplicating, we just export a reference to indicate they're the same
+export { VERCEL_AI_GATEWAY_PROMPT_CACHING_MODELS as ZOO_GATEWAY_PROMPT_CACHING_MODELS } from "./vercel-ai-gateway.js"
+
+export const zooGatewayDefaultModelInfo: ModelInfo = {
+	maxTokens: 64000,
+	contextWindow: 200000,
+	supportsImages: true,
+	supportsPromptCache: true,
+	inputPrice: 3,
+	outputPrice: 15,
+	cacheWritesPrice: 3.75,
+	cacheReadsPrice: 0.3,
+	description:
+		"Claude Sonnet 4 significantly improves on Sonnet 3.7's industry-leading capabilities, excelling in coding with a state-of-the-art 72.7% on SWE-bench. The model balances performance and efficiency for internal and external use cases, with enhanced steerability for greater control over implementations.",
+}
+
+export const ZOO_GATEWAY_DEFAULT_TEMPERATURE = 0.7

src/api/index.ts

@@ -32,6 +32,7 @@ import {
 	ZAiHandler,
 	FireworksHandler,
 	VercelAiGatewayHandler,
+	ZooGatewayHandler,
 	MiniMaxHandler,
 	MimoHandler,
 	BasetenHandler,
@@ -176,6 +177,8 @@ export function buildApiHandler(configuration: ProviderSettings): ApiHandler {
 			return new FireworksHandler(options)
 		case "vercel-ai-gateway":
 			return new VercelAiGatewayHandler(options)
+		case "zoo-gateway":
+			return new ZooGatewayHandler(options)
 		case "minimax":
 			return new MiniMaxHandler(options)
 		case "baseten":

src/api/providers/fetchers/modelCache.ts

@@ -26,6 +26,7 @@ import { getOllamaModels } from "./ollama"
 import { getLMStudioModels } from "./lmstudio"
 import { getPoeModels } from "./poe"
 import { getDeepSeekModels } from "./deepseek"
+import { getZooGatewayModels } from "./zoo-gateway"
 
 const memoryCache = new NodeCache({ stdTTL: 5 * 60, checkperiod: 5 * 60 })
 
@@ -92,6 +93,9 @@ async function fetchModelsFromProvider(options: GetModelsOptions): Promise<Model
 		case "deepseek":
 			models = await getDeepSeekModels(options.baseUrl, options.apiKey)
 			break
+		case "zoo-gateway":
+			models = await getZooGatewayModels({ zooSessionToken: options.apiKey, zooGatewayBaseUrl: options.baseUrl })
+			break
 		default: {
 			// Ensures router is exhaustively checked if RouterName is a strict union.
 			const exhaustiveCheck: never = provider
@@ -116,7 +120,10 @@ async function fetchModelsFromProvider(options: GetModelsOptions): Promise<Model
 export const getModels = async (options: GetModelsOptions): Promise<ModelRecord> => {
 	const { provider } = options
 
-	let models = getModelsFromCache(provider)
+	// Always fetch fresh to prevent serving stale models from different auth contexts.
+	const shouldSkipCache = provider === "zoo-gateway"
+
+	let models = shouldSkipCache ? undefined : getModelsFromCache(provider)
 
 	if (models) {
 		return models
@@ -128,13 +135,14 @@ export const getModels = async (options: GetModelsOptions): Promise<ModelRecord>
 
 		// Only cache non-empty results to prevent persisting failed API responses
 		// Empty results could indicate API failure rather than "no models exist"
-		if (modelCount > 0) {
+		// Zoo Gateway models are user-specific - skip caching entirely
+		if (modelCount > 0 && !shouldSkipCache) {
 			memoryCache.set(provider, models)
 
 			await writeModels(provider, models).catch((err) =>
 				console.error(`[MODEL_CACHE] Error writing ${provider} models to file cache:`, err),
 			)
-		} else {
+		} else if (modelCount === 0) {
 			TelemetryService.instance.captureEvent(TelemetryEventName.MODEL_CACHE_EMPTY_RESPONSE, {
 				provider,
 				context: "getModels",
@@ -163,6 +171,11 @@ export const getModels = async (options: GetModelsOptions): Promise<ModelRecord>
 export const refreshModels = async (options: GetModelsOptions): Promise<ModelRecord> => {
 	const { provider } = options
 
+	// Zoo Gateway models are user-specific (auth-scoped). Mirror the bypass in
+	// getModels() so we never persist one user's model list and serve it to a
+	// different authenticated user from cache.
+	const shouldSkipCache = provider === "zoo-gateway"
+
 	// Check if there's already an in-flight refresh for this provider
 	// This prevents race conditions where multiple concurrent refreshes might
 	// overwrite each other's results
@@ -179,7 +192,7 @@ export const refreshModels = async (options: GetModelsOptions): Promise<ModelRec
 			const modelCount = Object.keys(models).length
 
 			// Get existing cached data for comparison
-			const existingCache = getModelsFromCache(provider)
+			const existingCache = shouldSkipCache ? undefined : getModelsFromCache(provider)
 			const existingCount = existingCache ? Object.keys(existingCache).length : 0
 
 			if (modelCount === 0) {
@@ -196,18 +209,23 @@ export const refreshModels = async (options: GetModelsOptions): Promise<ModelRec
 				}
 			}
 
-			// Update memory cache first
-			memoryCache.set(provider, models)
+			if (!shouldSkipCache) {
+				memoryCache.set(provider, models)
 
-			// Atomically write to disk (safeWriteJson handles atomic writes)
-			await writeModels(provider, models).catch((err) =>
-				console.error(`[refreshModels] Error writing ${provider} models to disk:`, err),
-			)
+				await writeModels(provider, models).catch((err) =>
+					console.error(`[refreshModels] Error writing ${provider} models to disk:`, err),
+				)
+			}
 
 			return models
 		} catch (error) {
-			// Log the error for debugging, then return existing cache if available (graceful degradation)
+			// Log the error for debugging, then return existing cache if available (graceful degradation).
+			// For auth-scoped providers (zoo-gateway) we MUST NOT return cached models from a prior
+			// session, since they could belong to a different user — return empty instead.
 			console.error(`[refreshModels] Failed to refresh ${provider} models:`, error)
+			if (shouldSkipCache) {
+				return {}
+			}
 			return getModelsFromCache(provider) || {}
 		} finally {
 			// Always clean up the in-flight tracking

src/api/providers/fetchers/zoo-gateway.ts

@@ -0,0 +1,123 @@
+import axios from "axios"
+
+import type { ModelInfo } from "@roo-code/types"
+
+import type { ApiHandlerOptions } from "../../../shared/api"
+import { getZooCodeBaseUrl } from "../../../services/zoo-code-auth"
+
+// Reuse the same schemas and parsing logic from vercel-ai-gateway since the API format is identical
+import { type VercelAiGatewayModel, parseVercelAiGatewayModel } from "./vercel-ai-gateway"
+
+import { z } from "zod"
+
+/**
+ * ZooGatewayPricing (same format as Vercel AI Gateway)
+ */
+
+const zooGatewayPricingSchema = z.object({
+	input: z.string().optional(),
+	output: z.string().optional(),
+	input_cache_write: z.string().optional(),
+	input_cache_read: z.string().optional(),
+	image: z.string().optional(),
+})
+
+/**
+ * ZooGatewayModel (same format as Vercel AI Gateway)
+ */
+
+const zooGatewayModelSchema = z.object({
+	id: z.string(),
+	object: z.string(),
+	created: z.number(),
+	owned_by: z.string(),
+	name: z.string(),
+	description: z.string(),
+	context_window: z.number(),
+	max_tokens: z.number(),
+	type: z.string(),
+	pricing: zooGatewayPricingSchema,
+})
+
+/**
+ * ZooGatewayModelsResponse
+ */
+
+const zooGatewayModelsResponseSchema = z.object({
+	object: z.string(),
+	data: z.array(zooGatewayModelSchema),
+})
+
+type ZooGatewayModelsResponse = z.infer<typeof zooGatewayModelsResponseSchema>
+
+// Bound model discovery so a network stall can't hang provider initialization paths.
+const MODEL_DISCOVERY_TIMEOUT_MS = 15_000
+
+/**
+ * getZooGatewayModels
+ *
+ * Fetches models from the Zoo Gateway API. Requires authentication via the zoo_ext_ token.
+ */
+
+export async function getZooGatewayModels(options?: ApiHandlerOptions): Promise<Record<string, ModelInfo>> {
+	const models: Record<string, ModelInfo> = {}
+	const baseURL = options?.zooGatewayBaseUrl ?? `${getZooCodeBaseUrl()}/api/gateway/v1`
+
+	// Build headers - Zoo Gateway requires authentication via the zoo_ext_ session token
+	const headers: Record<string, string> = {}
+	if (options?.zooSessionToken) {
+		headers["Authorization"] = `Bearer ${options.zooSessionToken}`
+	}
+
+	try {
+		const response = await axios.get<ZooGatewayModelsResponse>(`${baseURL}/models`, {
+			headers,
+			timeout: MODEL_DISCOVERY_TIMEOUT_MS,
+		})
+		const result = zooGatewayModelsResponseSchema.safeParse(response.data)
+		const data = result.success ? result.data.data : response.data.data
+
+		if (!result.success) {
+			console.error(`Zoo Gateway models response is invalid ${JSON.stringify(result.error.format())}`)
+		}
+
+		for (const model of data) {
+			const { id } = model
+
+			// Only include language models for chat inference.
+			// Embedding models are statically defined in embeddingModels.ts.
+			if (model.type !== "language") {
+				continue
+			}
+
+			// Parse model using the same logic as Vercel AI Gateway since formats are identical
+			models[id] = parseZooGatewayModel({ id, model: model as VercelAiGatewayModel })
+		}
+	} catch (error) {
+		// Log only safe fields; never serialize the full error object because it
+		// includes request config/headers which carry the bearer session token.
+		const err = error as {
+			message?: string
+			name?: string
+			code?: string
+			response?: { status?: number; statusText?: string }
+		}
+		console.error(
+			`Error fetching Zoo Gateway models: name=${err.name ?? "Error"} code=${err.code ?? "unknown"} status=${err.response?.status ?? "unknown"} ${err.response?.statusText ?? ""} message=${err.message ?? "unknown error"}`,
+		)
+	}
+
+	return models
+}
+
+/**
+ * parseZooGatewayModel
+ *
+ * Parses a Zoo Gateway model into ModelInfo format.
+ * Zoo Gateway returns the same format as Vercel AI Gateway, so we can reuse the parsing logic.
+ */
+
+export const parseZooGatewayModel = ({ id, model }: { id: string; model: VercelAiGatewayModel }): ModelInfo => {
+	// Reuse the parsing logic from vercel-ai-gateway
+	return parseVercelAiGatewayModel({ id, model })
+}

src/api/providers/index.ts

@@ -25,6 +25,7 @@ export { XAIHandler } from "./xai"
 export { ZAiHandler } from "./zai"
 export { FireworksHandler } from "./fireworks"
 export { VercelAiGatewayHandler } from "./vercel-ai-gateway"
+export { ZooGatewayHandler } from "./zoo-gateway"
 export { MiniMaxHandler } from "./minimax"
 export { MimoHandler } from "./mimo"
 export { BasetenHandler } from "./baseten"