|
| 1 | +// npx vitest run api/providers/__tests__/model-catalog-adapters.spec.ts |
| 2 | + |
| 3 | +// Real-handler coverage for the model-catalog adapter surface: each dynamic-catalog |
| 4 | +// provider must declare the correct cache scope and forward the right arguments to |
| 5 | +// its fetcher. Only the fetcher modules are mocked; handlers are constructed for real. |
| 6 | + |
| 7 | +import { providerIdentifiers, type ModelRecord } from "@roo-code/types" |
| 8 | + |
| 9 | +import type { GetModelsOptions } from "../../../shared/api" |
| 10 | +import type { ApiHandler, ModelCacheScope } from "../../index" |
| 11 | + |
| 12 | +const fetchers = vi.hoisted(() => ({ |
| 13 | + getDeepSeekModels: vi.fn(), |
| 14 | + getKenariModels: vi.fn(), |
| 15 | + getKimiCodeModels: vi.fn(), |
| 16 | + getLiteLLMModels: vi.fn(), |
| 17 | + getLMStudioModels: vi.fn(), |
| 18 | + getMoonshotModels: vi.fn(), |
| 19 | + getNanoGptModels: vi.fn(), |
| 20 | + getOllamaModels: vi.fn(), |
| 21 | + getOpencodeGoModels: vi.fn(), |
| 22 | + getOpenRouterModels: vi.fn(), |
| 23 | + getPoeModels: vi.fn(), |
| 24 | + getRequestyModels: vi.fn(), |
| 25 | + getUnboundModels: vi.fn(), |
| 26 | + getVercelAiGatewayModels: vi.fn(), |
| 27 | + getZooGatewayModels: vi.fn(), |
| 28 | +})) |
| 29 | + |
| 30 | +vi.mock("../fetchers/deepseek", async (importOriginal) => ({ |
| 31 | + ...(await importOriginal<typeof import("../fetchers/deepseek")>()), |
| 32 | + getDeepSeekModels: fetchers.getDeepSeekModels, |
| 33 | +})) |
| 34 | +vi.mock("../fetchers/kenari", async (importOriginal) => ({ |
| 35 | + ...(await importOriginal<typeof import("../fetchers/kenari")>()), |
| 36 | + getKenariModels: fetchers.getKenariModels, |
| 37 | +})) |
| 38 | +vi.mock("../fetchers/kimi-code", async (importOriginal) => ({ |
| 39 | + ...(await importOriginal<typeof import("../fetchers/kimi-code")>()), |
| 40 | + getKimiCodeModels: fetchers.getKimiCodeModels, |
| 41 | +})) |
| 42 | +vi.mock("../fetchers/litellm", async (importOriginal) => ({ |
| 43 | + ...(await importOriginal<typeof import("../fetchers/litellm")>()), |
| 44 | + getLiteLLMModels: fetchers.getLiteLLMModels, |
| 45 | +})) |
| 46 | +vi.mock("../fetchers/lmstudio", async (importOriginal) => ({ |
| 47 | + ...(await importOriginal<typeof import("../fetchers/lmstudio")>()), |
| 48 | + getLMStudioModels: fetchers.getLMStudioModels, |
| 49 | +})) |
| 50 | +vi.mock("../fetchers/moonshot", async (importOriginal) => ({ |
| 51 | + ...(await importOriginal<typeof import("../fetchers/moonshot")>()), |
| 52 | + getMoonshotModels: fetchers.getMoonshotModels, |
| 53 | +})) |
| 54 | +vi.mock("../fetchers/nanogpt", async (importOriginal) => ({ |
| 55 | + ...(await importOriginal<typeof import("../fetchers/nanogpt")>()), |
| 56 | + getNanoGptModels: fetchers.getNanoGptModels, |
| 57 | +})) |
| 58 | +vi.mock("../fetchers/ollama", async (importOriginal) => ({ |
| 59 | + ...(await importOriginal<typeof import("../fetchers/ollama")>()), |
| 60 | + getOllamaModels: fetchers.getOllamaModels, |
| 61 | +})) |
| 62 | +vi.mock("../fetchers/opencode-go", async (importOriginal) => ({ |
| 63 | + ...(await importOriginal<typeof import("../fetchers/opencode-go")>()), |
| 64 | + getOpencodeGoModels: fetchers.getOpencodeGoModels, |
| 65 | +})) |
| 66 | +vi.mock("../fetchers/openrouter", async (importOriginal) => ({ |
| 67 | + ...(await importOriginal<typeof import("../fetchers/openrouter")>()), |
| 68 | + getOpenRouterModels: fetchers.getOpenRouterModels, |
| 69 | +})) |
| 70 | +vi.mock("../fetchers/poe", async (importOriginal) => ({ |
| 71 | + ...(await importOriginal<typeof import("../fetchers/poe")>()), |
| 72 | + getPoeModels: fetchers.getPoeModels, |
| 73 | +})) |
| 74 | +vi.mock("../fetchers/requesty", async (importOriginal) => ({ |
| 75 | + ...(await importOriginal<typeof import("../fetchers/requesty")>()), |
| 76 | + getRequestyModels: fetchers.getRequestyModels, |
| 77 | +})) |
| 78 | +vi.mock("../fetchers/unbound", async (importOriginal) => ({ |
| 79 | + ...(await importOriginal<typeof import("../fetchers/unbound")>()), |
| 80 | + getUnboundModels: fetchers.getUnboundModels, |
| 81 | +})) |
| 82 | +vi.mock("../fetchers/vercel-ai-gateway", async (importOriginal) => ({ |
| 83 | + ...(await importOriginal<typeof import("../fetchers/vercel-ai-gateway")>()), |
| 84 | + getVercelAiGatewayModels: fetchers.getVercelAiGatewayModels, |
| 85 | +})) |
| 86 | +vi.mock("../fetchers/zoo-gateway", async (importOriginal) => ({ |
| 87 | + ...(await importOriginal<typeof import("../fetchers/zoo-gateway")>()), |
| 88 | + getZooGatewayModels: fetchers.getZooGatewayModels, |
| 89 | +})) |
| 90 | + |
| 91 | +import { AnthropicHandler } from "../anthropic" |
| 92 | +import { DeepSeekHandler } from "../deepseek" |
| 93 | +import { KenariHandler } from "../kenari" |
| 94 | +import { KimiCodeHandler } from "../kimi-code" |
| 95 | +import { LiteLLMHandler } from "../lite-llm" |
| 96 | +import { LmStudioHandler } from "../lm-studio" |
| 97 | +import { MoonshotHandler } from "../moonshot" |
| 98 | +import { NanoGptHandler } from "../nanogpt" |
| 99 | +import { NativeOllamaHandler } from "../native-ollama" |
| 100 | +import { OpencodeGoHandler } from "../opencode-go" |
| 101 | +import { OpenRouterHandler } from "../openrouter" |
| 102 | +import { PoeHandler } from "../poe" |
| 103 | +import { RequestyHandler } from "../requesty" |
| 104 | +import { UnboundHandler } from "../unbound" |
| 105 | +import { VercelAiGatewayHandler } from "../vercel-ai-gateway" |
| 106 | +import { ZooGatewayHandler } from "../zoo-gateway" |
| 107 | + |
| 108 | +const BASE_URL = "https://catalog.example.com/v1" |
| 109 | +const API_KEY = "catalog-key" |
| 110 | +const CATALOG: ModelRecord = { |
| 111 | + "test-model": { maxTokens: 1024, contextWindow: 8192, supportsPromptCache: false }, |
| 112 | +} |
| 113 | + |
| 114 | +interface AdapterCase { |
| 115 | + name: string |
| 116 | + create: () => ApiHandler |
| 117 | + fetcher: keyof typeof fetchers |
| 118 | + scope: ModelCacheScope |
| 119 | + /** Positional arguments expected before the optional `{ signal }` options bag. */ |
| 120 | + expectedArgs: unknown[] |
| 121 | + /** Whether the adapter forwards an AbortSignal to its fetcher. */ |
| 122 | + forwardsSignal: boolean |
| 123 | +} |
| 124 | + |
| 125 | +const cases: AdapterCase[] = [ |
| 126 | + { |
| 127 | + name: "DeepSeek", |
| 128 | + create: () => new DeepSeekHandler({ deepSeekApiKey: API_KEY }), |
| 129 | + fetcher: "getDeepSeekModels", |
| 130 | + scope: { urlScoped: true, keyScoped: false, authScoped: false }, |
| 131 | + expectedArgs: [BASE_URL, API_KEY], |
| 132 | + forwardsSignal: true, |
| 133 | + }, |
| 134 | + { |
| 135 | + name: "Kenari", |
| 136 | + create: () => new KenariHandler({ kenariApiKey: API_KEY }), |
| 137 | + fetcher: "getKenariModels", |
| 138 | + scope: { urlScoped: false, keyScoped: false, authScoped: false }, |
| 139 | + expectedArgs: [API_KEY], |
| 140 | + forwardsSignal: true, |
| 141 | + }, |
| 142 | + { |
| 143 | + name: "Kimi Code", |
| 144 | + create: () => new KimiCodeHandler({ kimiCodeAuthMethod: "api-key", kimiCodeApiKey: API_KEY }), |
| 145 | + fetcher: "getKimiCodeModels", |
| 146 | + scope: { urlScoped: false, keyScoped: true, authScoped: true }, |
| 147 | + expectedArgs: [API_KEY], |
| 148 | + forwardsSignal: false, |
| 149 | + }, |
| 150 | + { |
| 151 | + name: "LiteLLM", |
| 152 | + create: () => new LiteLLMHandler({ litellmApiKey: API_KEY, litellmBaseUrl: BASE_URL }), |
| 153 | + fetcher: "getLiteLLMModels", |
| 154 | + scope: { urlScoped: true, keyScoped: true, authScoped: false }, |
| 155 | + expectedArgs: [API_KEY, BASE_URL], |
| 156 | + forwardsSignal: true, |
| 157 | + }, |
| 158 | + { |
| 159 | + name: "LM Studio", |
| 160 | + create: () => new LmStudioHandler({ lmStudioBaseUrl: BASE_URL }), |
| 161 | + fetcher: "getLMStudioModels", |
| 162 | + scope: { urlScoped: true, keyScoped: false, authScoped: false }, |
| 163 | + expectedArgs: [BASE_URL], |
| 164 | + forwardsSignal: true, |
| 165 | + }, |
| 166 | + { |
| 167 | + name: "Moonshot", |
| 168 | + create: () => new MoonshotHandler({ moonshotApiKey: API_KEY }), |
| 169 | + fetcher: "getMoonshotModels", |
| 170 | + scope: { urlScoped: true, keyScoped: true, authScoped: false }, |
| 171 | + expectedArgs: [BASE_URL, API_KEY], |
| 172 | + forwardsSignal: true, |
| 173 | + }, |
| 174 | + { |
| 175 | + name: "NanoGPT", |
| 176 | + create: () => new NanoGptHandler({ nanoGptApiKey: API_KEY }), |
| 177 | + fetcher: "getNanoGptModels", |
| 178 | + scope: { urlScoped: false, keyScoped: true, authScoped: false }, |
| 179 | + expectedArgs: [API_KEY], |
| 180 | + forwardsSignal: true, |
| 181 | + }, |
| 182 | + { |
| 183 | + name: "Ollama", |
| 184 | + create: () => new NativeOllamaHandler({ ollamaBaseUrl: BASE_URL }), |
| 185 | + fetcher: "getOllamaModels", |
| 186 | + scope: { urlScoped: true, keyScoped: false, authScoped: false }, |
| 187 | + expectedArgs: [BASE_URL, API_KEY], |
| 188 | + forwardsSignal: true, |
| 189 | + }, |
| 190 | + { |
| 191 | + name: "OpenCode Go", |
| 192 | + create: () => new OpencodeGoHandler({ opencodeGoApiKey: API_KEY }), |
| 193 | + fetcher: "getOpencodeGoModels", |
| 194 | + scope: { urlScoped: false, keyScoped: false, authScoped: false }, |
| 195 | + expectedArgs: [API_KEY], |
| 196 | + forwardsSignal: true, |
| 197 | + }, |
| 198 | + { |
| 199 | + name: "OpenRouter", |
| 200 | + create: () => new OpenRouterHandler({ openRouterApiKey: API_KEY }), |
| 201 | + fetcher: "getOpenRouterModels", |
| 202 | + scope: { urlScoped: false, keyScoped: false, authScoped: false }, |
| 203 | + expectedArgs: [undefined], |
| 204 | + forwardsSignal: true, |
| 205 | + }, |
| 206 | + { |
| 207 | + name: "Poe", |
| 208 | + create: () => new PoeHandler({ poeApiKey: API_KEY }), |
| 209 | + fetcher: "getPoeModels", |
| 210 | + scope: { urlScoped: true, keyScoped: true, authScoped: false }, |
| 211 | + expectedArgs: [API_KEY, BASE_URL], |
| 212 | + forwardsSignal: true, |
| 213 | + }, |
| 214 | + { |
| 215 | + name: "Requesty", |
| 216 | + create: () => new RequestyHandler({ requestyApiKey: API_KEY }), |
| 217 | + fetcher: "getRequestyModels", |
| 218 | + scope: { urlScoped: true, keyScoped: true, authScoped: false }, |
| 219 | + expectedArgs: [BASE_URL, API_KEY], |
| 220 | + forwardsSignal: true, |
| 221 | + }, |
| 222 | + { |
| 223 | + name: "Unbound", |
| 224 | + create: () => new UnboundHandler({ unboundApiKey: API_KEY }), |
| 225 | + fetcher: "getUnboundModels", |
| 226 | + scope: { urlScoped: false, keyScoped: false, authScoped: false }, |
| 227 | + expectedArgs: [API_KEY], |
| 228 | + forwardsSignal: true, |
| 229 | + }, |
| 230 | + { |
| 231 | + name: "Vercel AI Gateway", |
| 232 | + create: () => new VercelAiGatewayHandler({ vercelAiGatewayApiKey: API_KEY }), |
| 233 | + fetcher: "getVercelAiGatewayModels", |
| 234 | + scope: { urlScoped: false, keyScoped: false, authScoped: false }, |
| 235 | + expectedArgs: [undefined], |
| 236 | + forwardsSignal: true, |
| 237 | + }, |
| 238 | + { |
| 239 | + name: "Zoo Gateway", |
| 240 | + create: () => new ZooGatewayHandler({ zooSessionToken: API_KEY }), |
| 241 | + fetcher: "getZooGatewayModels", |
| 242 | + scope: { urlScoped: true, keyScoped: true, authScoped: true }, |
| 243 | + expectedArgs: [{ zooSessionToken: API_KEY, zooGatewayBaseUrl: BASE_URL }], |
| 244 | + forwardsSignal: false, |
| 245 | + }, |
| 246 | +] |
| 247 | + |
| 248 | +describe("model catalog adapters", () => { |
| 249 | + const options: GetModelsOptions = { provider: providerIdentifiers.litellm, baseUrl: BASE_URL, apiKey: API_KEY } |
| 250 | + |
| 251 | + beforeEach(() => { |
| 252 | + for (const fetcher of Object.values(fetchers)) { |
| 253 | + fetcher.mockReset() |
| 254 | + fetcher.mockResolvedValue(CATALOG) |
| 255 | + } |
| 256 | + }) |
| 257 | + |
| 258 | + describe.each(cases)("$name", ({ create, fetcher, scope, expectedArgs, forwardsSignal }) => { |
| 259 | + it("declares its model cache scope", () => { |
| 260 | + expect(create().getModelCacheScope()).toEqual(scope) |
| 261 | + }) |
| 262 | + |
| 263 | + it("forwards fetch arguments without a signal", async () => { |
| 264 | + const handler = create() |
| 265 | + |
| 266 | + await expect(handler.fetchModels?.(options)).resolves.toBe(CATALOG) |
| 267 | + |
| 268 | + expect(fetchers[fetcher]).toHaveBeenCalledTimes(1) |
| 269 | + expect(fetchers[fetcher]).toHaveBeenCalledWith(...expectedArgs) |
| 270 | + }) |
| 271 | + |
| 272 | + it( |
| 273 | + forwardsSignal ? "forwards the abort signal to its fetcher" : "does not forward an abort signal", |
| 274 | + async () => { |
| 275 | + const handler = create() |
| 276 | + const signal = new AbortController().signal |
| 277 | + |
| 278 | + await expect(handler.fetchModels?.(options, signal)).resolves.toBe(CATALOG) |
| 279 | + |
| 280 | + const expected = forwardsSignal ? [...expectedArgs, { signal }] : expectedArgs |
| 281 | + expect(fetchers[fetcher]).toHaveBeenCalledWith(...expected) |
| 282 | + }, |
| 283 | + ) |
| 284 | + |
| 285 | + it("propagates fetcher failures", async () => { |
| 286 | + fetchers[fetcher].mockRejectedValueOnce(new Error("catalog unavailable")) |
| 287 | + |
| 288 | + await expect(create().fetchModels?.(options)).rejects.toThrow("catalog unavailable") |
| 289 | + }) |
| 290 | + }) |
| 291 | + |
| 292 | + it("defaults to an unscoped cache and no catalog fetcher for static providers", () => { |
| 293 | + const handler: ApiHandler = new AnthropicHandler({ apiKey: API_KEY }) |
| 294 | + |
| 295 | + expect(handler.getModelCacheScope()).toEqual({ urlScoped: false, keyScoped: false, authScoped: false }) |
| 296 | + expect(handler.fetchModels).toBeUndefined() |
| 297 | + }) |
| 298 | +}) |
0 commit comments