@funkai/models 0.2.1 → 0.3.1

package/src/cost/calculate.test.ts

@@ -4,10 +4,6 @@ import { calculateCost } from "./calculate.js";
 import type { ModelPricing } from "@/catalog/types.js";
 import type { TokenUsage } from "@/provider/types.js";
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
 const ZERO_USAGE: TokenUsage = {
   inputTokens: 0,
   outputTokens: 0,
@@ -18,29 +14,25 @@ const ZERO_USAGE: TokenUsage = {
 };
 
 const BASIC_PRICING: ModelPricing = {
-  input: 0.000002,
-  output: 0.000008,
+  input: 0.000_002,
+  output: 0.000_008,
 };
 
 const FULL_PRICING: ModelPricing = {
-  input: 0.000002,
-  output: 0.000008,
-  cacheRead: 0.0000005,
-  cacheWrite: 0.000001,
+  input: 0.000_002,
+  output: 0.000_008,
+  cacheRead: 0.000_000_5,
+  cacheWrite: 0.000_001,
 };
 
 const REASONING_PRICING: ModelPricing = {
-  input: 0.000002,
-  output: 0.000008,
-  cacheRead: 0.0000005,
-  cacheWrite: 0.000001,
-  reasoning: 0.000012,
+  input: 0.000_002,
+  output: 0.000_008,
+  cacheRead: 0.000_000_5,
+  cacheWrite: 0.000_001,
+  reasoning: 0.000_012,
 };
 
-// ---------------------------------------------------------------------------
-// calculateCost()
-// ---------------------------------------------------------------------------
-
 describe("calculateCost()", () => {
   it("returns all zeros for zero usage", () => {
     const result = calculateCost(ZERO_USAGE, FULL_PRICING);

package/src/index.ts

@@ -10,14 +10,8 @@ export type {
 } from "@/catalog/index.js";
 
 // Provider
-export { createOpenRouter, openrouter } from "@/provider/openrouter.js";
-export { createModelResolver } from "@/provider/resolver.js";
-export type {
-  ProviderFactory,
-  ProviderMap,
-  ModelResolverConfig,
-  ModelResolver,
-} from "@/provider/resolver.js";
+export { createProviderRegistry } from "@/provider/registry.js";
+export type { ProviderRegistryConfig, ProviderRegistry } from "@/provider/registry.js";
 export type { LanguageModel, TokenUsage } from "@/provider/types.js";
 
 // Cost

package/src/provider/index.ts

@@ -1,9 +1,3 @@
-export { createOpenRouter, openrouter } from "./openrouter.js";
-export { createModelResolver } from "./resolver.js";
-export type {
-  ProviderFactory,
-  ProviderMap,
-  ModelResolverConfig,
-  ModelResolver,
-} from "./resolver.js";
+export { createProviderRegistry } from "./registry.js";
+export type { ProviderRegistryConfig, ProviderRegistry } from "./registry.js";
 export type { LanguageModel, TokenUsage } from "./types.js";

package/src/provider/registry.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { createProviderRegistry } from "@/provider/registry.js";
+import type { LanguageModel } from "@/provider/types.js";
+
+function fakeModel(id: string): LanguageModel {
+  return { modelId: id } as unknown as LanguageModel;
+}
+
+function fakeProvider(prefix: string) {
+  return {
+    specificationVersion: "v3" as const,
+    languageModel: (modelName: string) => fakeModel(`${prefix}/${modelName}`),
+    textEmbeddingModel: () => {
+      throw new Error("not implemented");
+    },
+    embeddingModel: () => {
+      throw new Error("not implemented");
+    },
+    imageModel: () => {
+      throw new Error("not implemented");
+    },
+  };
+}
+
+describe("createProviderRegistry()", () => {
+  it("resolves a model ID via the mapped provider", () => {
+    const registry = createProviderRegistry({
+      providers: { openai: fakeProvider("openai") },
+    });
+
+    const result = registry("openai/gpt-4.1");
+
+    expect(result).toEqual(fakeModel("openai/gpt-4.1"));
+  });
+
+  it("supports multiple mapped providers", () => {
+    const openai = fakeProvider("openai");
+    const anthropic = fakeProvider("anthropic");
+    const openaiSpy = vi.spyOn(openai, "languageModel");
+    const anthropicSpy = vi.spyOn(anthropic, "languageModel");
+
+    const registry = createProviderRegistry({
+      providers: { openai, anthropic },
+    });
+
+    registry("openai/gpt-4.1");
+    registry("anthropic/claude-sonnet-4-20250514");
+
+    expect(openaiSpy).toHaveBeenCalledWith("gpt-4.1");
+    expect(anthropicSpy).toHaveBeenCalledWith("claude-sonnet-4-20250514");
+  });
+
+  it("handles model IDs with multiple slashes correctly", () => {
+    const registry = createProviderRegistry({
+      providers: { "meta-llama": fakeProvider("meta-llama") },
+    });
+
+    const result = registry("meta-llama/llama-4-scout/extended");
+
+    expect(result).toEqual(fakeModel("meta-llama/llama-4-scout/extended"));
+  });
+
+  it("throws for empty model ID", () => {
+    const registry = createProviderRegistry({
+      providers: { openai: fakeProvider("openai") },
+    });
+
+    expect(() => registry("")).toThrow("Cannot resolve model: model ID is empty");
+  });
+
+  it("throws for whitespace-only model ID", () => {
+    const registry = createProviderRegistry({
+      providers: { openai: fakeProvider("openai") },
+    });
+
+    expect(() => registry("   ")).toThrow("Cannot resolve model: model ID is empty");
+  });
+
+  it("throws for unmapped provider prefix", () => {
+    const registry = createProviderRegistry({
+      providers: { openai: fakeProvider("openai") },
+    });
+
+    expect(() => registry("anthropic/claude-sonnet-4-20250514")).toThrow();
+  });
+});

package/src/provider/registry.ts

@@ -0,0 +1,93 @@
+import { createProviderRegistry as baseCreateProviderRegistry } from "ai";
+
+import type { ModelId } from "@/catalog/index.js";
+import type { LanguageModel } from "@/provider/types.js";
+
+/**
+ * Extract the provider type accepted by the AI SDK's `createProviderRegistry`.
+ *
+ * @private
+ */
+type AIProviders = Parameters<typeof baseCreateProviderRegistry>[0];
+
+/**
+ * Configuration for {@link createProviderRegistry}.
+ */
+export interface ProviderRegistryConfig {
+  /**
+   * AI SDK provider instances keyed by prefix.
+   *
+   * When a model ID like `"openai/gpt-4.1"` is resolved, the prefix
+   * `"openai"` is extracted and looked up in this map.
+   *
+   * @example
+   * ```typescript
+   * import { createOpenAI } from '@ai-sdk/openai'
+   * import { anthropic } from '@ai-sdk/anthropic'
+   *
+   * const registry = createProviderRegistry({
+   *   providers: {
+   *     openai: createOpenAI({ apiKey: '...' }),
+   *     anthropic,
+   *   },
+   * })
+   * ```
+   */
+  readonly providers: AIProviders;
+}
+
+/**
+ * A function that resolves a model ID to a {@link LanguageModel} instance.
+ *
+ * @param modelId - Catalog model identifier in `provider/model` format.
+ * @returns The resolved AI SDK {@link LanguageModel}.
+ *
+ * @example
+ * ```typescript
+ * const model = registry("openai/gpt-4.1");
+ * ```
+ */
+export type ProviderRegistry = (modelId: ModelId) => LanguageModel;
+
+/**
+ * Create a provider registry that resolves `provider/model` string IDs
+ * to AI SDK {@link LanguageModel} instances.
+ *
+ * Thin wrapper around the AI SDK's `createProviderRegistry` that uses
+ * `/` as the separator instead of `:`, matching the model ID format used
+ * throughout the funkai catalog (e.g. `"openai/gpt-4.1"`).
+ *
+ * @param config - Provider mappings.
+ * @returns A resolver function that maps model IDs to {@link LanguageModel} instances.
+ *
+ * @example
+ * ```typescript
+ * import { createOpenAI } from '@ai-sdk/openai'
+ * import { anthropic } from '@ai-sdk/anthropic'
+ * import { createProviderRegistry } from '@funkai/models'
+ *
+ * const registry = createProviderRegistry({
+ *   providers: {
+ *     openai: createOpenAI({ apiKey: '...' }),
+ *     anthropic,
+ *   },
+ * })
+ *
+ * const m1 = registry('openai/gpt-4.1')
+ * const m2 = registry('anthropic/claude-sonnet-4')
+ * ```
+ */
+export function createProviderRegistry(config: ProviderRegistryConfig): ProviderRegistry {
+  const inner = baseCreateProviderRegistry(config.providers, {
+    separator: "/",
+  });
+
+  return (modelId: ModelId): LanguageModel => {
+    if (!modelId.trim()) {
+      throw new Error("Cannot resolve model: model ID is empty");
+    }
+    // Cast needed: AI SDK overloads expect `provider/model` template literal,
+    // But our ModelId is a branded string union. The runtime validates the format.
+    return inner.languageModel(modelId as `${string}/${string}`) as LanguageModel;
+  };
+}

package/src/provider/types.ts

@@ -1,4 +1,4 @@
-import { type LanguageModel as BaseLanguageModel } from "ai";
+import type { LanguageModel as BaseLanguageModel } from "ai";
 
 /**
  * AI SDK language model instance (v3 specification).

package/tsconfig.json

@@ -18,7 +18,8 @@
     "rootDir": ".",
     "paths": {
       "@/*": ["./src/*"]
-    }
+    },
+    "types": ["node"]
   },
   "include": ["src"],
   "exclude": ["node_modules", "dist"]

package/tsdown.config.ts

@@ -3,11 +3,14 @@ import { join } from "node:path";
 
 import { defineConfig } from "tsdown";
 
-// Read generated entry points (created by generate-models script)
 const entriesPath = join(import.meta.dirname, ".generated", "entries.json");
-const generatedEntries: string[] = existsSync(entriesPath)
-  ? JSON.parse(readFileSync(entriesPath, "utf-8"))
-  : [];
+// oxlint-disable-next-line eslint-plugin-jest/require-hook
+const generatedEntries: string[] = (() => {
+  if (existsSync(entriesPath)) {
+    return JSON.parse(readFileSync(entriesPath, "utf8")) as string[];
+  }
+  return [];
+})();
 
 export default defineConfig([
   {

package/dist/types-DjdaZckF.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-DjdaZckF.d.mts","names":[],"sources":["../src/catalog/types.ts"],"mappings":";;AAOA;;;;;;UAAiB,YAAA;EAWN;EAAA,SATA,KAAA;EAYS;EAAA,SATT,MAAA;EAkBM;EAAA,SAfN,SAAA;;WAGA,UAAA;EAiBM;EAAA,SAdN,SAAA;AAAA;;;;;;;UASM,eAAA;EAsBU;EAAA,SApBhB,KAAA;EA0BqB;EAAA,SAvBrB,MAAA;AAAA;;;;UAMM,iBAAA;EAmBN;EAAA,SAjBA,SAAA;EAuBA;EAAA,SApBA,QAAA;EA0BA;EAAA,SAvBA,UAAA;EA0BA;EAAA,SAvBA,gBAAA;AAAA;;;;UAMM,eAAA;EA0ByB;EAAA,SAxB/B,EAAA;;WAGA,IAAA;;WAGA,QAAA;;WAGA,MAAA;;WAGA,OAAA,EAAS,YAAA;;WAGT,aAAA;;WAGA,SAAA;;WAGA,UAAA,EAAY,eAAA;;WAGZ,YAAA,EAAc,iBAAA;AAAA"}

package/src/provider/openrouter.test.ts

@@ -1,125 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-// Mock the external provider before importing the module under test
-const mockBaseCreateOpenRouter = vi.fn();
-const mockProviderInstance = vi.fn();
-
-vi.mock("@openrouter/ai-sdk-provider", () => ({
-  createOpenRouter: mockBaseCreateOpenRouter,
-}));
-
-// Must import after mocking
-const { createOpenRouter, openrouter } = await import("@/provider/openrouter.js");
-
-// ---------------------------------------------------------------------------
-// createOpenRouter()
-// ---------------------------------------------------------------------------
-
-describe("createOpenRouter()", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockBaseCreateOpenRouter.mockReturnValue(mockProviderInstance);
-    vi.stubEnv("OPENROUTER_API_KEY", "env-key-123");
-  });
-
-  afterEach(() => {
-    vi.unstubAllEnvs();
-  });
-
-  it("uses explicit apiKey when provided in options", () => {
-    createOpenRouter({ apiKey: "explicit-key" });
-
-    expect(mockBaseCreateOpenRouter).toHaveBeenCalledWith(
-      expect.objectContaining({ apiKey: "explicit-key" }),
-    );
-  });
-
-  it("falls back to OPENROUTER_API_KEY env var when no apiKey in options", () => {
-    createOpenRouter();
-
-    expect(mockBaseCreateOpenRouter).toHaveBeenCalledWith(
-      expect.objectContaining({ apiKey: "env-key-123" }),
-    );
-  });
-
-  it("falls back to env var when options are provided without apiKey", () => {
-    createOpenRouter({});
-
-    expect(mockBaseCreateOpenRouter).toHaveBeenCalledWith(
-      expect.objectContaining({ apiKey: "env-key-123" }),
-    );
-  });
-
-  it("throws when no apiKey provided and env var is not set", () => {
-    vi.stubEnv("OPENROUTER_API_KEY", undefined as unknown as string);
-
-    expect(() => createOpenRouter()).toThrow("OPENROUTER_API_KEY environment variable is required");
-  });
-
-  it("forwards additional options to the base provider", () => {
-    createOpenRouter({ apiKey: "key", baseURL: "https://custom.api" } as Record<string, unknown>);
-
-    expect(mockBaseCreateOpenRouter).toHaveBeenCalledWith(
-      expect.objectContaining({
-        apiKey: "key",
-        baseURL: "https://custom.api",
-      }),
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// openrouter() — cached model factory
-// ---------------------------------------------------------------------------
-
-describe("openrouter()", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockProviderInstance.mockReturnValue({ modelId: "mock-model" });
-    mockBaseCreateOpenRouter.mockReturnValue(mockProviderInstance);
-  });
-
-  afterEach(() => {
-    vi.unstubAllEnvs();
-  });
-
-  it("creates a provider and returns a language model", () => {
-    vi.stubEnv("OPENROUTER_API_KEY", "key-test-create");
-
-    const result = openrouter("openai/gpt-5.2-codex");
-
-    expect(mockBaseCreateOpenRouter).toHaveBeenCalledWith({ apiKey: "key-test-create" });
-    expect(mockProviderInstance).toHaveBeenCalledWith("openai/gpt-5.2-codex");
-    expect(result).toEqual({ modelId: "mock-model" });
-  });
-
-  it("reuses cached provider on subsequent calls with same api key", () => {
-    vi.stubEnv("OPENROUTER_API_KEY", "key-test-reuse");
-
-    openrouter("openai/gpt-5.2-codex");
-    openrouter("openai/gpt-5.2");
-
-    // Provider should only be created once since key is the same
-    expect(mockBaseCreateOpenRouter).toHaveBeenCalledTimes(1);
-    expect(mockProviderInstance).toHaveBeenCalledTimes(2);
-  });
-
-  it("creates new provider when api key changes", () => {
-    vi.stubEnv("OPENROUTER_API_KEY", "key-test-change-1");
-    openrouter("openai/gpt-5.2-codex");
-
-    vi.stubEnv("OPENROUTER_API_KEY", "key-test-change-2");
-    openrouter("openai/gpt-5.2");
-
-    expect(mockBaseCreateOpenRouter).toHaveBeenCalledTimes(2);
-    expect(mockBaseCreateOpenRouter).toHaveBeenLastCalledWith({ apiKey: "key-test-change-2" });
-  });
-
-  it("throws when OPENROUTER_API_KEY is not set", () => {
-    vi.stubEnv("OPENROUTER_API_KEY", undefined as unknown as string);
-
-    expect(() => openrouter("openai/gpt-5.2-codex")).toThrow(
-      "OPENROUTER_API_KEY environment variable is required",
-    );
-  });
-});

package/src/provider/openrouter.ts

@@ -1,110 +0,0 @@
-import {
-  createOpenRouter as baseCreateOpenRouter,
-  type OpenRouterProvider,
-  type OpenRouterProviderSettings,
-} from "@openrouter/ai-sdk-provider";
-
-import type { ModelId } from "@/catalog/index.js";
-import type { LanguageModel } from "@/provider/types.js";
-
-/**
- * Create an OpenRouter provider instance with automatic API key resolution.
- *
- * Falls back to the `OPENROUTER_API_KEY` environment variable when
- * no explicit `apiKey` is provided in the options.
- *
- * @param options - Provider settings forwarded to `@openrouter/ai-sdk-provider`.
- * @returns A configured {@link OpenRouterProvider} instance.
- *
- * @example
- * ```typescript
- * const openrouter = createOpenRouter({ apiKey: 'sk-...' })
- * const m = openrouter('openai/gpt-5.2-codex')
- * ```
- */
-export function createOpenRouter(options?: OpenRouterProviderSettings): OpenRouterProvider {
-  const apiKey = resolveApiKey(options);
-  return baseCreateOpenRouter({
-    ...options,
-    apiKey,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Private helpers
-// ---------------------------------------------------------------------------
-
-/**
- * @private
- */
-function resolveApiKey(options: OpenRouterProviderSettings | undefined): string {
-  if (options != null && options.apiKey != null) {
-    return options.apiKey;
-  }
-  return getOpenRouterApiKey();
-}
-
-/**
- * Create a cached OpenRouter model resolver.
- *
- * The returned function caches the underlying provider and invalidates
- * when the API key changes at runtime.
- *
- * @returns A function that resolves a model ID to a {@link LanguageModel}.
- *
- * @private
- */
-// Cache mutation is safe: JS is single-threaded and baseCreateOpenRouter is synchronous.
-// If this were refactored to async initialization, a lock or re-architecture would be needed.
-function createCachedOpenRouter(): (modelId: ModelId) => LanguageModel {
-  const cache: { provider: OpenRouterProvider | undefined; apiKey: string | undefined } = {
-    provider: undefined,
-    apiKey: undefined,
-  };
-  return (modelId: ModelId): LanguageModel => {
-    const apiKey = getOpenRouterApiKey();
-    if (!cache.provider || cache.apiKey !== apiKey) {
-      cache.provider = baseCreateOpenRouter({ apiKey });
-      cache.apiKey = apiKey;
-    }
-    return cache.provider(modelId);
-  };
-}
-
-/**
- * Shorthand for creating a single OpenRouter language model.
- *
- * Resolves the API key from the environment and returns a ready-to-use
- * {@link LanguageModel} that can be passed directly to AI SDK functions.
- *
- * The provider instance is cached at module scope and reused across
- * calls. If `OPENROUTER_API_KEY` changes at runtime, the cache is
- * invalidated and a new provider is created.
- *
- * @param modelId - A model identifier (e.g. `"openai/gpt-5.2-codex"`).
- * @returns A configured {@link LanguageModel} instance.
- *
- * @example
- * ```typescript
- * const m = openrouter('openai/gpt-5.2-codex')
- * ```
- */
-export const openrouter: (modelId: ModelId) => LanguageModel = createCachedOpenRouter();
-
-/**
- * Read the OpenRouter API key from the environment.
- *
- * @throws {Error} If `OPENROUTER_API_KEY` is not set.
- *
- * @private
- */
-function getOpenRouterApiKey(): string {
-  const apiKey = process.env.OPENROUTER_API_KEY;
-  if (!apiKey) {
-    throw new Error(
-      "OPENROUTER_API_KEY environment variable is required. " +
-        "Set it in your .env file or environment.",
-    );
-  }
-  return apiKey;
-}

package/src/provider/resolver.test.ts

@@ -1,138 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-import { createModelResolver } from "@/provider/resolver.js";
-import type { LanguageModel } from "@/provider/types.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function fakeModel(id: string): LanguageModel {
-  return { modelId: id } as unknown as LanguageModel;
-}
-
-function fakeFactory(prefix: string): (modelName: string) => LanguageModel {
-  return (modelName: string) => fakeModel(`${prefix}/${modelName}`);
-}
-
-// ---------------------------------------------------------------------------
-// createModelResolver()
-// ---------------------------------------------------------------------------
-
-describe("createModelResolver()", () => {
-  it("throws when no providers or fallback are configured for prefixed ID", () => {
-    const resolve = createModelResolver();
-
-    expect(() => resolve("openai/gpt-4.1")).toThrow(
-      'Cannot resolve model "openai/gpt-4.1": no provider mapped for "openai" and no fallback configured',
-    );
-  });
-
-  it("throws when no providers or fallback are configured for unprefixed ID", () => {
-    const resolve = createModelResolver();
-
-    expect(() => resolve("gpt-4.1")).toThrow(
-      'Cannot resolve model "gpt-4.1": no provider prefix and no fallback configured',
-    );
-  });
-
-  it("uses a mapped provider when prefix matches", () => {
-    const openaiFactory = vi.fn(fakeFactory("openai"));
-    const resolve = createModelResolver({
-      providers: { openai: openaiFactory },
-    });
-
-    const result = resolve("openai/gpt-4.1");
-
-    expect(openaiFactory).toHaveBeenCalledWith("gpt-4.1");
-    expect(result).toEqual(fakeModel("openai/gpt-4.1"));
-  });
-
-  it("falls back to fallback for unmapped prefixes", () => {
-    const fallback = vi.fn((id: string) => fakeModel(id));
-    const resolve = createModelResolver({
-      providers: { openai: fakeFactory("openai") },
-      fallback,
-    });
-
-    resolve("anthropic/claude-sonnet-4-20250514");
-
-    expect(fallback).toHaveBeenCalledWith("anthropic/claude-sonnet-4-20250514");
-  });
-
-  it("handles model IDs without a slash via fallback", () => {
-    const fallback = vi.fn((id: string) => fakeModel(id));
-    const resolve = createModelResolver({ fallback });
-
-    resolve("gpt-4.1");
-
-    expect(fallback).toHaveBeenCalledWith("gpt-4.1");
-  });
-
-  it("throws for unmapped prefixes when no fallback is configured", () => {
-    const resolve = createModelResolver({
-      providers: { openai: fakeFactory("openai") },
-    });
-
-    expect(() => resolve("anthropic/claude-sonnet-4-20250514")).toThrow(
-      'Cannot resolve model "anthropic/claude-sonnet-4-20250514": no provider mapped for "anthropic" and no fallback configured',
-    );
-  });
-
-  it("supports multiple mapped providers", () => {
-    const openaiFactory = vi.fn(fakeFactory("openai"));
-    const anthropicFactory = vi.fn(fakeFactory("anthropic"));
-
-    const resolve = createModelResolver({
-      providers: {
-        openai: openaiFactory,
-        anthropic: anthropicFactory,
-      },
-    });
-
-    resolve("openai/gpt-4.1");
-    resolve("anthropic/claude-sonnet-4-20250514");
-
-    expect(openaiFactory).toHaveBeenCalledWith("gpt-4.1");
-    expect(anthropicFactory).toHaveBeenCalledWith("claude-sonnet-4-20250514");
-  });
-
-  it("handles model IDs with multiple slashes correctly", () => {
-    const resolve = createModelResolver({
-      providers: { "meta-llama": fakeFactory("meta-llama") },
-    });
-
-    resolve("meta-llama/llama-4-scout/extended");
-
-    expect(resolve("meta-llama/llama-4-scout/extended")).toEqual(
-      fakeModel("meta-llama/llama-4-scout/extended"),
-    );
-  });
-
-  it("throws for empty model ID", () => {
-    const resolve = createModelResolver();
-
-    expect(() => resolve("")).toThrow("Cannot resolve model: model ID is empty");
-  });
-
-  it("throws for whitespace-only model ID", () => {
-    const resolve = createModelResolver();
-
-    expect(() => resolve("   ")).toThrow("Cannot resolve model: model ID is empty");
-  });
-
-  it("prefers mapped provider over fallback", () => {
-    const openaiFactory = vi.fn(fakeFactory("openai"));
-    const fallback = vi.fn((id: string) => fakeModel(id));
-
-    const resolve = createModelResolver({
-      providers: { openai: openaiFactory },
-      fallback,
-    });
-
-    resolve("openai/gpt-4.1");
-
-    expect(openaiFactory).toHaveBeenCalledWith("gpt-4.1");
-    expect(fallback).not.toHaveBeenCalled();
-  });
-});