@fondation-io/ai 7.0.0-beta.45

package/src/registry/custom-provider.ts

@@ -0,0 +1,210 @@
+import {
+  EmbeddingModelV3,
+  EmbeddingModelV4,
+  Experimental_VideoModelV3,
+  Experimental_VideoModelV4,
+  ImageModelV2,
+  ImageModelV3,
+  ImageModelV4,
+  LanguageModelV2,
+  LanguageModelV3,
+  LanguageModelV4,
+  NoSuchModelError,
+  ProviderV2,
+  ProviderV3,
+  ProviderV4,
+  RerankingModelV3,
+  RerankingModelV4,
+  SpeechModelV2,
+  SpeechModelV3,
+  SpeechModelV4,
+  TranscriptionModelV2,
+  TranscriptionModelV3,
+  TranscriptionModelV4,
+} from '@ai-sdk/provider';
+import { asEmbeddingModelV4 } from '../model/as-embedding-model-v4';
+import { asImageModelV4 } from '../model/as-image-model-v4';
+import { asLanguageModelV4 } from '../model/as-language-model-v4';
+import { asProviderV4 } from '../model/as-provider-v4';
+import { asRerankingModelV4 } from '../model/as-reranking-model-v4';
+import { asSpeechModelV4 } from '../model/as-speech-model-v4';
+import { asTranscriptionModelV4 } from '../model/as-transcription-model-v4';
+import { asVideoModelV4 } from '../model/as-video-model-v4';
+
+/**
+ * Creates a custom provider with specified language models, text embedding models, image models, transcription models, speech models, and an optional fallback provider.
+ *
+ * @param {Object} options - The options for creating the custom provider.
+ * @param {Record<string, LanguageModelV4>} [options.languageModels] - A record of language models, where keys are model IDs and values are LanguageModelV4 instances.
+ * @param {Record<string, EmbeddingModelV4>} [options.embeddingModels] - A record of text embedding models, where keys are model IDs and values are EmbeddingModelV4 instances.
+ * @param {Record<string, ImageModelV4>} [options.imageModels] - A record of image models, where keys are model IDs and values are ImageModelV4 instances.
+ * @param {Record<string, TranscriptionModelV4>} [options.transcriptionModels] - A record of transcription models, where keys are model IDs and values are TranscriptionModelV4 instances.
+ * @param {Record<string, SpeechModelV4>} [options.speechModels] - A record of speech models, where keys are model IDs and values are SpeechModelV4 instances.
+ * @param {Record<string, RerankingModelV4>} [options.rerankingModels] - A record of reranking models, where keys are model IDs and values are RerankingModelV4 instances.
+ * @param {ProviderV4} [options.fallbackProvider] - An optional fallback provider to use when a requested model is not found in the custom provider.
+ * @returns {ProviderV4} A ProviderV4 object with languageModel, embeddingModel, imageModel, transcriptionModel, and speechModel methods.
+ *
+ * @throws {NoSuchModelError} Throws when a requested model is not found and no fallback provider is available.
+ */
+export function customProvider<
+  LANGUAGE_MODELS extends Record<
+    string,
+    LanguageModelV2 | LanguageModelV3 | LanguageModelV4
+  >,
+  EMBEDDING_MODELS extends Record<string, EmbeddingModelV3 | EmbeddingModelV4>,
+  IMAGE_MODELS extends Record<
+    string,
+    ImageModelV2 | ImageModelV3 | ImageModelV4
+  >,
+  TRANSCRIPTION_MODELS extends Record<
+    string,
+    TranscriptionModelV2 | TranscriptionModelV3 | TranscriptionModelV4
+  >,
+  SPEECH_MODELS extends Record<
+    string,
+    SpeechModelV2 | SpeechModelV3 | SpeechModelV4
+  >,
+  RERANKING_MODELS extends Record<string, RerankingModelV3 | RerankingModelV4>,
+  VIDEO_MODELS extends Record<
+    string,
+    Experimental_VideoModelV3 | Experimental_VideoModelV4
+  >,
+>({
+  languageModels,
+  embeddingModels,
+  imageModels,
+  transcriptionModels,
+  speechModels,
+  rerankingModels,
+  videoModels,
+  fallbackProvider: fallbackProviderArg,
+}: {
+  languageModels?: LANGUAGE_MODELS;
+  embeddingModels?: EMBEDDING_MODELS;
+  imageModels?: IMAGE_MODELS;
+  transcriptionModels?: TRANSCRIPTION_MODELS;
+  speechModels?: SPEECH_MODELS;
+  rerankingModels?: RERANKING_MODELS;
+  videoModels?: VIDEO_MODELS;
+  fallbackProvider?: ProviderV4 | ProviderV3 | ProviderV2;
+}): ProviderV4 & {
+  languageModel(modelId: ExtractModelId<LANGUAGE_MODELS>): LanguageModelV4;
+  embeddingModel(modelId: ExtractModelId<EMBEDDING_MODELS>): EmbeddingModelV4;
+  imageModel(modelId: ExtractModelId<IMAGE_MODELS>): ImageModelV4;
+  transcriptionModel(
+    modelId: ExtractModelId<TRANSCRIPTION_MODELS>,
+  ): TranscriptionModelV4;
+  rerankingModel(modelId: ExtractModelId<RERANKING_MODELS>): RerankingModelV4;
+  speechModel(modelId: ExtractModelId<SPEECH_MODELS>): SpeechModelV4;
+  videoModel(modelId: ExtractModelId<VIDEO_MODELS>): Experimental_VideoModelV4;
+} {
+  const fallbackProvider = fallbackProviderArg
+    ? asProviderV4(fallbackProviderArg)
+    : undefined;
+
+  return {
+    specificationVersion: 'v4',
+    languageModel(modelId: ExtractModelId<LANGUAGE_MODELS>): LanguageModelV4 {
+      if (languageModels != null && modelId in languageModels) {
+        return asLanguageModelV4(languageModels[modelId]);
+      }
+
+      if (fallbackProvider) {
+        return (fallbackProvider as ProviderV4).languageModel(modelId);
+      }
+
+      throw new NoSuchModelError({ modelId, modelType: 'languageModel' });
+    },
+
+    embeddingModel(
+      modelId: ExtractModelId<EMBEDDING_MODELS>,
+    ): EmbeddingModelV4 {
+      if (embeddingModels != null && modelId in embeddingModels) {
+        return asEmbeddingModelV4(embeddingModels[modelId]);
+      }
+
+      if (fallbackProvider) {
+        return (fallbackProvider as ProviderV4).embeddingModel(modelId);
+      }
+
+      throw new NoSuchModelError({ modelId, modelType: 'embeddingModel' });
+    },
+
+    imageModel(modelId: ExtractModelId<IMAGE_MODELS>): ImageModelV4 {
+      if (imageModels != null && modelId in imageModels) {
+        return asImageModelV4(imageModels[modelId]);
+      }
+
+      if (fallbackProvider?.imageModel) {
+        return (fallbackProvider as ProviderV4).imageModel(modelId);
+      }
+
+      throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
+    },
+
+    transcriptionModel(
+      modelId: ExtractModelId<TRANSCRIPTION_MODELS>,
+    ): TranscriptionModelV4 {
+      if (transcriptionModels != null && modelId in transcriptionModels) {
+        return asTranscriptionModelV4(transcriptionModels[modelId]);
+      }
+
+      if (fallbackProvider?.transcriptionModel) {
+        return (fallbackProvider as ProviderV4).transcriptionModel!(modelId);
+      }
+
+      throw new NoSuchModelError({ modelId, modelType: 'transcriptionModel' });
+    },
+
+    speechModel(modelId: ExtractModelId<SPEECH_MODELS>): SpeechModelV4 {
+      if (speechModels != null && modelId in speechModels) {
+        return asSpeechModelV4(speechModels[modelId]);
+      }
+
+      if (fallbackProvider?.speechModel) {
+        return (fallbackProvider as ProviderV4).speechModel!(modelId);
+      }
+
+      throw new NoSuchModelError({ modelId, modelType: 'speechModel' });
+    },
+    rerankingModel(
+      modelId: ExtractModelId<RERANKING_MODELS>,
+    ): RerankingModelV4 {
+      if (rerankingModels != null && modelId in rerankingModels) {
+        return asRerankingModelV4(rerankingModels[modelId]);
+      }
+
+      if (fallbackProvider?.rerankingModel) {
+        return fallbackProvider.rerankingModel(modelId);
+      }
+
+      throw new NoSuchModelError({ modelId, modelType: 'rerankingModel' });
+    },
+    videoModel(
+      modelId: ExtractModelId<VIDEO_MODELS>,
+    ): Experimental_VideoModelV4 {
+      if (videoModels != null && modelId in videoModels) {
+        return asVideoModelV4(videoModels[modelId]);
+      }
+
+      // TODO AI SDK v7
+      // @ts-expect-error - videoModel support is experimental
+      const videoModel = fallbackProvider?.videoModel;
+      if (videoModel) {
+        return videoModel(modelId);
+      }
+
+      throw new NoSuchModelError({ modelId, modelType: 'videoModel' });
+    },
+  };
+}
+
+/**
+ * @deprecated Use `customProvider` instead.
+ */
+export const experimental_customProvider = customProvider;
+
+type ExtractModelId<MODELS extends Record<string, unknown>> = Extract<
+  keyof MODELS,
+  string
+>;

package/src/registry/index.ts

@@ -0,0 +1,7 @@
+export { customProvider, experimental_customProvider } from './custom-provider';
+export { NoSuchProviderError } from './no-such-provider-error';
+export {
+  createProviderRegistry,
+  experimental_createProviderRegistry,
+} from './provider-registry';
+export type { ProviderRegistryProvider } from './provider-registry';

package/src/registry/no-such-provider-error.ts

@@ -0,0 +1,41 @@
+import { AISDKError, NoSuchModelError } from '@ai-sdk/provider';
+
+const name = 'AI_NoSuchProviderError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class NoSuchProviderError extends NoSuchModelError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly providerId: string;
+  readonly availableProviders: string[];
+
+  constructor({
+    modelId,
+    modelType,
+    providerId,
+    availableProviders,
+    message = `No such provider: ${providerId} (available providers: ${availableProviders.join()})`,
+  }: {
+    modelId: string;
+    modelType:
+      | 'languageModel'
+      | 'embeddingModel'
+      | 'imageModel'
+      | 'transcriptionModel'
+      | 'speechModel'
+      | 'rerankingModel';
+    providerId: string;
+    availableProviders: string[];
+    message?: string;
+  }) {
+    super({ errorName: name, modelId, modelType, message });
+
+    this.providerId = providerId;
+    this.availableProviders = availableProviders;
+  }
+
+  static isInstance(error: unknown): error is NoSuchProviderError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/registry/provider-registry.ts

@@ -0,0 +1,331 @@
+import {
+  EmbeddingModelV4,
+  ImageModelV4,
+  LanguageModelV4,
+  NoSuchModelError,
+  ProviderV2,
+  ProviderV3,
+  ProviderV4,
+  RerankingModelV4,
+  SpeechModelV4,
+  TranscriptionModelV4,
+} from '@ai-sdk/provider';
+import { wrapImageModel } from '../middleware/wrap-image-model';
+import { wrapLanguageModel } from '../middleware/wrap-language-model';
+import { asProviderV4 } from '../model/as-provider-v4';
+import { ImageModelMiddleware, LanguageModelMiddleware } from '../types';
+import { NoSuchProviderError } from './no-such-provider-error';
+
+type ExtractLiteralUnion<T> = T extends string
+  ? string extends T
+    ? never
+    : T
+  : never;
+
+export interface ProviderRegistryProvider<
+  PROVIDERS extends Record<string, ProviderV4> = Record<string, ProviderV4>,
+  SEPARATOR extends string = ':',
+> {
+  languageModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string
+      ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['languageModel']>>[0]>}`
+      : never,
+  ): LanguageModelV4;
+  languageModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never,
+  ): LanguageModelV4;
+
+  embeddingModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string
+      ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['embeddingModel']>>[0]>}`
+      : never,
+  ): EmbeddingModelV4;
+  embeddingModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never,
+  ): EmbeddingModelV4;
+
+  imageModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string
+      ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['imageModel']>>[0]>}`
+      : never,
+  ): ImageModelV4;
+  imageModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never,
+  ): ImageModelV4;
+
+  transcriptionModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string
+      ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['transcriptionModel']>>[0]>}`
+      : never,
+  ): TranscriptionModelV4;
+  transcriptionModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never,
+  ): TranscriptionModelV4;
+
+  speechModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string
+      ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['speechModel']>>[0]>}`
+      : never,
+  ): SpeechModelV4;
+  speechModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never,
+  ): SpeechModelV4;
+
+  rerankingModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string
+      ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['rerankingModel']>>[0]>}`
+      : never,
+  ): RerankingModelV4;
+  rerankingModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never,
+  ): RerankingModelV4;
+}
+
+/**
+ * Creates a registry for the given providers with optional middleware functionality.
+ * This function allows you to register multiple providers and optionally apply middleware
+ * to all language models from the registry, enabling you to transform parameters, wrap generate
+ * operations, and wrap stream operations for every language model accessed through the registry.
+ *
+ * @param providers - A record of provider instances to be registered in the registry.
+ * @param options - Configuration options for the provider registry.
+ * @param options.separator - The separator used between provider ID and model ID in the combined identifier. Defaults to ':'.
+ * @param options.languageModelMiddleware - Optional middleware to be applied to all language models from the registry. When multiple middlewares are provided, the first middleware will transform the input first, and the last middleware will be wrapped directly around the model.
+ * @param options.imageModelMiddleware - Optional middleware to be applied to all image models from the registry. When multiple middlewares are provided, the first middleware will transform the input first, and the last middleware will be wrapped directly around the model.
+ * @returns A new ProviderRegistryProvider instance that provides access to all registered providers with optional middleware applied to language and image models.
+ */
+export function createProviderRegistry<
+  PROVIDERS extends Record<string, ProviderV2 | ProviderV3 | ProviderV4>,
+  SEPARATOR extends string = ':',
+>(
+  providers: PROVIDERS,
+  {
+    separator = ':' as SEPARATOR,
+    languageModelMiddleware,
+    imageModelMiddleware,
+  }: {
+    separator?: SEPARATOR;
+    languageModelMiddleware?:
+      | LanguageModelMiddleware
+      | LanguageModelMiddleware[];
+    imageModelMiddleware?: ImageModelMiddleware | ImageModelMiddleware[];
+  } = {},
+): ProviderRegistryProvider<{ [K in keyof PROVIDERS]: ProviderV4 }, SEPARATOR> {
+  type V4Providers = { [K in keyof PROVIDERS]: ProviderV4 };
+  const registry = new DefaultProviderRegistry<V4Providers, SEPARATOR>({
+    separator,
+    languageModelMiddleware,
+    imageModelMiddleware,
+  });
+
+  for (const [id, provider] of Object.entries(providers)) {
+    registry.registerProvider({ id, provider: asProviderV4(provider) } as {
+      id: keyof V4Providers;
+      provider: V4Providers[keyof V4Providers];
+    });
+  }
+
+  return registry;
+}
+
+/**
+ * @deprecated Use `createProviderRegistry` instead.
+ */
+export const experimental_createProviderRegistry = createProviderRegistry;
+
+class DefaultProviderRegistry<
+  PROVIDERS extends Record<string, ProviderV4>,
+  SEPARATOR extends string,
+> implements ProviderRegistryProvider<PROVIDERS, SEPARATOR> {
+  private providers: PROVIDERS = {} as PROVIDERS;
+  private separator: SEPARATOR;
+  private languageModelMiddleware?:
+    | LanguageModelMiddleware
+    | LanguageModelMiddleware[];
+  private imageModelMiddleware?: ImageModelMiddleware | ImageModelMiddleware[];
+
+  constructor({
+    separator,
+    languageModelMiddleware,
+    imageModelMiddleware,
+  }: {
+    separator: SEPARATOR;
+    languageModelMiddleware?:
+      | LanguageModelMiddleware
+      | LanguageModelMiddleware[];
+    imageModelMiddleware?: ImageModelMiddleware | ImageModelMiddleware[];
+  }) {
+    this.separator = separator;
+    this.languageModelMiddleware = languageModelMiddleware;
+    this.imageModelMiddleware = imageModelMiddleware;
+  }
+
+  registerProvider<K extends keyof PROVIDERS>({
+    id,
+    provider,
+  }: {
+    id: K;
+    provider: PROVIDERS[K];
+  }): void {
+    this.providers[id] = provider;
+  }
+
+  private getProvider(
+    id: string,
+    modelType:
+      | 'languageModel'
+      | 'embeddingModel'
+      | 'imageModel'
+      | 'transcriptionModel'
+      | 'speechModel'
+      | 'rerankingModel',
+  ): ProviderV4 {
+    const provider = this.providers[id as keyof PROVIDERS];
+
+    if (provider == null) {
+      throw new NoSuchProviderError({
+        modelId: id,
+        modelType,
+        providerId: id,
+        availableProviders: Object.keys(this.providers),
+      });
+    }
+
+    return asProviderV4(provider);
+  }
+
+  private splitId(
+    id: string,
+    modelType:
+      | 'languageModel'
+      | 'embeddingModel'
+      | 'imageModel'
+      | 'transcriptionModel'
+      | 'speechModel'
+      | 'rerankingModel',
+  ): [string, string] {
+    const index = id.indexOf(this.separator);
+
+    if (index === -1) {
+      throw new NoSuchModelError({
+        modelId: id,
+        modelType,
+        message:
+          `Invalid ${modelType} id for registry: ${id} ` +
+          `(must be in the format "providerId${this.separator}modelId")`,
+      });
+    }
+
+    return [id.slice(0, index), id.slice(index + this.separator.length)];
+  }
+
+  languageModel<KEY extends keyof PROVIDERS>(
+    id: `${KEY & string}${SEPARATOR}${string}`,
+  ): LanguageModelV4 {
+    const [providerId, modelId] = this.splitId(id, 'languageModel');
+    let model = this.getProvider(providerId, 'languageModel').languageModel?.(
+      modelId,
+    );
+
+    if (model == null) {
+      throw new NoSuchModelError({ modelId: id, modelType: 'languageModel' });
+    }
+
+    if (this.languageModelMiddleware != null) {
+      model = wrapLanguageModel({
+        model,
+        middleware: this.languageModelMiddleware,
+      });
+    }
+
+    return model;
+  }
+
+  embeddingModel<KEY extends keyof PROVIDERS>(
+    id: `${KEY & string}${SEPARATOR}${string}`,
+  ): EmbeddingModelV4 {
+    const [providerId, modelId] = this.splitId(id, 'embeddingModel');
+    const provider = this.getProvider(providerId, 'embeddingModel');
+
+    const model = provider.embeddingModel?.(modelId);
+
+    if (model == null) {
+      throw new NoSuchModelError({
+        modelId: id,
+        modelType: 'embeddingModel',
+      });
+    }
+
+    return model;
+  }
+
+  imageModel<KEY extends keyof PROVIDERS>(
+    id: `${KEY & string}${SEPARATOR}${string}`,
+  ): ImageModelV4 {
+    const [providerId, modelId] = this.splitId(id, 'imageModel');
+    const provider = this.getProvider(providerId, 'imageModel');
+
+    let model = provider.imageModel?.(modelId);
+
+    if (model == null) {
+      throw new NoSuchModelError({ modelId: id, modelType: 'imageModel' });
+    }
+
+    if (this.imageModelMiddleware != null) {
+      model = wrapImageModel({
+        model,
+        middleware: this.imageModelMiddleware,
+      });
+    }
+
+    return model;
+  }
+
+  transcriptionModel<KEY extends keyof PROVIDERS>(
+    id: `${KEY & string}${SEPARATOR}${string}`,
+  ): TranscriptionModelV4 {
+    const [providerId, modelId] = this.splitId(id, 'transcriptionModel');
+    const provider = this.getProvider(providerId, 'transcriptionModel');
+
+    const model = provider.transcriptionModel?.(modelId);
+
+    if (model == null) {
+      throw new NoSuchModelError({
+        modelId: id,
+        modelType: 'transcriptionModel',
+      });
+    }
+
+    return model;
+  }
+
+  speechModel<KEY extends keyof PROVIDERS>(
+    id: `${KEY & string}${SEPARATOR}${string}`,
+  ): SpeechModelV4 {
+    const [providerId, modelId] = this.splitId(id, 'speechModel');
+    const provider = this.getProvider(providerId, 'speechModel');
+
+    const model = provider.speechModel?.(modelId);
+
+    if (model == null) {
+      throw new NoSuchModelError({ modelId: id, modelType: 'speechModel' });
+    }
+
+    return model;
+  }
+
+  rerankingModel<KEY extends keyof PROVIDERS>(
+    id: `${KEY & string}${SEPARATOR}${string}`,
+  ): RerankingModelV4 {
+    const [providerId, modelId] = this.splitId(id, 'rerankingModel');
+    const provider = this.getProvider(providerId, 'rerankingModel');
+
+    const model = provider.rerankingModel?.(modelId);
+
+    if (model == null) {
+      throw new NoSuchModelError({ modelId: id, modelType: 'rerankingModel' });
+    }
+
+    return model;
+  }
+}

package/src/rerank/index.ts

@@ -0,0 +1,8 @@
+export { rerank } from './rerank';
+export type { RerankResult } from './rerank-result';
+export type {
+  RerankOnStartEvent,
+  RerankOnFinishEvent,
+  RerankStartEvent,
+  RerankFinishEvent,
+} from './rerank-events';