@funkai/models 0.1.0 → 0.3.0

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

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`,
-    );
-  };
-}