@funkai/models 0.2.1 → 0.3.0

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();
-  });
-});

package/src/provider/resolver.ts

@@ -1,125 +0,0 @@
-import type { ModelId } from "@/catalog/index.js";
-import type { LanguageModel } from "@/provider/types.js";
-
-/**
- * A function that resolves a provider-specific model name to a {@link LanguageModel}.
- *
- * @example
- * ```typescript
- * import { createOpenAI } from '@ai-sdk/openai'
- *
- * const factory: ProviderFactory = createOpenAI({ apiKey: '...' })
- * const model = factory('gpt-4.1')
- * ```
- */
-export type ProviderFactory = (modelName: string) => LanguageModel;
-
-/**
- * Mapping from provider prefix (e.g. `"openai"`, `"anthropic"`) to a factory
- * that creates {@link LanguageModel} instances for that provider.
- */
-export type ProviderMap = Readonly<Record<string, ProviderFactory>>;
-
-/**
- * Configuration for {@link createModelResolver}.
- */
-export interface ModelResolverConfig {
-  /**
-   * Direct AI SDK provider mappings by prefix.
-   *
-   * When a model ID like `"openai/gpt-4.1"` is resolved, the prefix
-   * `"openai"` is extracted and looked up in this map. If found, the
-   * factory receives the model portion (`"gpt-4.1"`).
-   */
-  readonly providers?: ProviderMap;
-
-  /**
-   * A fallback factory used when no mapped provider matches.
-   *
-   * Receives the full model ID string. Useful for routing unmapped
-   * providers through an aggregator like OpenRouter.
-   *
-   * @example
-   * ```typescript
-   * import { openrouter } from '@funkai/models'
-   *
-   * const resolve = createModelResolver({
-   *   providers: { openai: createOpenAI({ apiKey: '...' }) },
-   *   fallback: openrouter,
-   * })
-   * ```
-   */
-  readonly fallback?: (modelId: string) => LanguageModel;
-}
-
-/**
- * A function that resolves a model ID to a {@link LanguageModel} instance.
- */
-export type ModelResolver = (modelId: ModelId) => LanguageModel;
-
-/**
- * Create a model resolver with configurable provider mappings.
- *
- * When a model ID like `"openai/gpt-4.1"` is resolved:
- * 1. The provider prefix (`"openai"`) is extracted
- * 2. If a direct provider is mapped for that prefix, it receives the model portion (`"gpt-4.1"`)
- * 3. Otherwise, the fallback is called with the full ID (if configured)
- * 4. If no fallback, an error is thrown
- *
- * @param config - Provider mappings and fallback configuration.
- * @returns A resolver function that maps model IDs to {@link LanguageModel} instances.
- *
- * @example
- * ```typescript
- * import { createOpenAI } from '@ai-sdk/openai'
- * import { createAnthropic } from '@ai-sdk/anthropic'
- *
- * const resolve = createModelResolver({
- *   providers: {
- *     openai: createOpenAI({ apiKey: '...' }),
- *     anthropic: createAnthropic({ apiKey: '...' }),
- *   },
- * })
- *
- * const m1 = resolve('openai/gpt-4.1')           // uses @ai-sdk/openai directly
- * const m2 = resolve('anthropic/claude-sonnet-4') // uses @ai-sdk/anthropic directly
- * ```
- */
-export function createModelResolver(config?: ModelResolverConfig): ModelResolver {
-  const providers = config?.providers ?? {};
-  const fallback = config?.fallback;
-
-  return (modelId: ModelId): LanguageModel => {
-    if (!modelId.trim()) {
-      throw new Error("Cannot resolve model: model ID is empty");
-    }
-
-    const slashIndex = modelId.indexOf("/");
-
-    if (slashIndex === -1) {
-      if (fallback) {
-        return fallback(modelId);
-      }
-      throw new Error(
-        `Cannot resolve model "${modelId}": no provider prefix and no fallback configured`,
-      );
-    }
-
-    const prefix = modelId.slice(0, slashIndex);
-    // eslint-disable-next-line security/detect-object-injection -- Prefix extracted from user model ID, used as record key lookup
-    const factory = providers[prefix];
-
-    if (factory) {
-      const modelName = modelId.slice(slashIndex + 1);
-      return factory(modelName);
-    }
-
-    if (fallback) {
-      return fallback(modelId);
-    }
-
-    throw new Error(
-      `Cannot resolve model "${modelId}": no provider mapped for "${prefix}" and no fallback configured`,
-    );
-  };
-}