@fondation-io/ai 7.0.0-beta.45

package/src/middleware/wrap-embedding-model.ts

@@ -0,0 +1,89 @@
+import {
+  EmbeddingModelV3,
+  EmbeddingModelV4,
+  EmbeddingModelV4CallOptions,
+} from '@ai-sdk/provider';
+import { asEmbeddingModelV4 } from '../model/as-embedding-model-v4';
+import { EmbeddingModelMiddleware } from '../types';
+import { asArray } from '../util/as-array';
+
+/**
+ * Wraps an EmbeddingModelV4 instance with middleware functionality.
+ * This function allows you to apply middleware to transform parameters,
+ * wrap embed operations of an embedding model.
+ *
+ * @param options - Configuration options for wrapping the embedding model.
+ * @param options.model - The original EmbeddingModelV4 instance to be wrapped.
+ * @param options.middleware - The middleware to be applied to the embedding model. 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.modelId - Optional custom model ID to override the original model's ID.
+ * @param options.providerId - Optional custom provider ID to override the original model's provider ID.
+ * @returns A new EmbeddingModelV4 instance with middleware applied.
+ */
+export const wrapEmbeddingModel = ({
+  model: inputModel,
+  middleware: middlewareArg,
+  modelId,
+  providerId,
+}: {
+  model: EmbeddingModelV3 | EmbeddingModelV4;
+  middleware: EmbeddingModelMiddleware | EmbeddingModelMiddleware[];
+  modelId?: string;
+  providerId?: string;
+}): EmbeddingModelV4 => {
+  const model = asEmbeddingModelV4(inputModel);
+  return [...asArray(middlewareArg)]
+    .reverse()
+    .reduce((wrappedModel, middleware) => {
+      return doWrap({ model: wrappedModel, middleware, modelId, providerId });
+    }, model);
+};
+
+const doWrap = ({
+  model,
+  middleware: {
+    transformParams,
+    wrapEmbed,
+    overrideProvider,
+    overrideModelId,
+    overrideMaxEmbeddingsPerCall,
+    overrideSupportsParallelCalls,
+  },
+  modelId,
+  providerId,
+}: {
+  model: EmbeddingModelV4;
+  middleware: EmbeddingModelMiddleware;
+  modelId?: string;
+  providerId?: string;
+}): EmbeddingModelV4 => {
+  async function doTransform({
+    params,
+  }: {
+    params: EmbeddingModelV4CallOptions;
+  }) {
+    return transformParams ? await transformParams({ params, model }) : params;
+  }
+
+  return {
+    specificationVersion: 'v4',
+    provider: providerId ?? overrideProvider?.({ model }) ?? model.provider,
+    modelId: modelId ?? overrideModelId?.({ model }) ?? model.modelId,
+    maxEmbeddingsPerCall:
+      overrideMaxEmbeddingsPerCall?.({ model }) ?? model.maxEmbeddingsPerCall,
+    supportsParallelCalls:
+      overrideSupportsParallelCalls?.({ model }) ?? model.supportsParallelCalls,
+    async doEmbed(
+      params: EmbeddingModelV4CallOptions,
+    ): Promise<Awaited<ReturnType<EmbeddingModelV4['doEmbed']>>> {
+      const transformedParams = await doTransform({ params });
+      const doEmbed = async () => model.doEmbed(transformedParams);
+      return wrapEmbed
+        ? wrapEmbed({
+            doEmbed,
+            params: transformedParams,
+            model,
+          })
+        : doEmbed();
+    },
+  };
+};

package/src/middleware/wrap-image-model.ts

@@ -0,0 +1,92 @@
+import {
+  ImageModelV2,
+  ImageModelV3,
+  ImageModelV4,
+  ImageModelV4CallOptions,
+} from '@ai-sdk/provider';
+import { asImageModelV4 } from '../model/as-image-model-v4';
+import { ImageModelMiddleware } from '../types';
+import { asArray } from '../util/as-array';
+
+/**
+ * Wraps an ImageModelV4 instance with middleware functionality.
+ * This function allows you to apply middleware to transform parameters
+ * and wrap generate operations of an image model.
+ *
+ * @param options - Configuration options for wrapping the image model.
+ * @param options.model - The original ImageModelV4 instance to be wrapped.
+ * @param options.middleware - The middleware to be applied to the image model. 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.modelId - Optional custom model ID to override the original model's ID.
+ * @param options.providerId - Optional custom provider ID to override the original model's provider ID.
+ * @returns A new ImageModelV4 instance with middleware applied.
+ */
+export const wrapImageModel = ({
+  model: inputModel,
+  middleware: middlewareArg,
+  modelId,
+  providerId,
+}: {
+  model: ImageModelV2 | ImageModelV3 | ImageModelV4;
+  middleware: ImageModelMiddleware | ImageModelMiddleware[];
+  modelId?: string;
+  providerId?: string;
+}): ImageModelV4 => {
+  const model = asImageModelV4(inputModel);
+  return [...asArray(middlewareArg)]
+    .reverse()
+    .reduce((wrappedModel, middleware) => {
+      return doWrap({ model: wrappedModel, middleware, modelId, providerId });
+    }, model);
+};
+
+const doWrap = ({
+  model,
+  middleware: {
+    transformParams,
+    wrapGenerate,
+    overrideProvider,
+    overrideModelId,
+    overrideMaxImagesPerCall,
+  },
+  modelId,
+  providerId,
+}: {
+  model: ImageModelV4;
+  middleware: ImageModelMiddleware;
+  modelId?: string;
+  providerId?: string;
+}): ImageModelV4 => {
+  async function doTransform({ params }: { params: ImageModelV4CallOptions }) {
+    return transformParams ? await transformParams({ params, model }) : params;
+  }
+
+  const maxImagesPerCallRaw =
+    overrideMaxImagesPerCall?.({ model }) ?? model.maxImagesPerCall;
+
+  // Ensure provider implementations that rely on `this` inside `maxImagesPerCall`
+  // keep working after the value is copied onto the wrapper object.
+  const maxImagesPerCall =
+    maxImagesPerCallRaw instanceof Function
+      ? maxImagesPerCallRaw.bind(model)
+      : maxImagesPerCallRaw;
+
+  return {
+    specificationVersion: 'v4',
+    provider: providerId ?? overrideProvider?.({ model }) ?? model.provider,
+    modelId: modelId ?? overrideModelId?.({ model }) ?? model.modelId,
+    maxImagesPerCall,
+    async doGenerate(
+      params: ImageModelV4CallOptions,
+    ): Promise<Awaited<ReturnType<ImageModelV4['doGenerate']>>> {
+      const transformedParams = await doTransform({ params });
+      const doGenerate = async () => model.doGenerate(transformedParams);
+      return wrapGenerate
+        ? wrapGenerate({
+            doGenerate,
+            params: transformedParams,
+            model,
+          })
+        : doGenerate();
+    },
+  };
+};

package/src/middleware/wrap-language-model.ts

@@ -0,0 +1,108 @@
+import {
+  LanguageModelV2,
+  LanguageModelV3,
+  LanguageModelV4,
+  LanguageModelV4CallOptions,
+  LanguageModelV4GenerateResult,
+  LanguageModelV4StreamResult,
+} from '@ai-sdk/provider';
+import { asLanguageModelV4 } from '../model/as-language-model-v4';
+import { LanguageModelMiddleware } from '../types';
+import { asArray } from '../util/as-array';
+
+/**
+ * Wraps a LanguageModelV4 instance with middleware functionality.
+ * This function allows you to apply middleware to transform parameters,
+ * wrap generate operations, and wrap stream operations of a language model.
+ *
+ * @param options - Configuration options for wrapping the language model.
+ * @param options.model - The original LanguageModelV4 instance to be wrapped.
+ * @param options.middleware - The middleware to be applied to the language model. 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.modelId - Optional custom model ID to override the original model's ID.
+ * @param options.providerId - Optional custom provider ID to override the original model's provider ID.
+ * @returns A new LanguageModelV4 instance with middleware applied.
+ */
+export const wrapLanguageModel = ({
+  model: inputModel,
+  middleware: middlewareArg,
+  modelId,
+  providerId,
+}: {
+  model: LanguageModelV2 | LanguageModelV3 | LanguageModelV4;
+  middleware: LanguageModelMiddleware | LanguageModelMiddleware[];
+  modelId?: string;
+  providerId?: string;
+}): LanguageModelV4 => {
+  const model = asLanguageModelV4(inputModel);
+  return [...asArray(middlewareArg)]
+    .reverse()
+    .reduce((wrappedModel, middleware) => {
+      return doWrap({ model: wrappedModel, middleware, modelId, providerId });
+    }, model);
+};
+
+const doWrap = ({
+  model,
+  middleware: {
+    transformParams,
+    wrapGenerate,
+    wrapStream,
+    overrideProvider,
+    overrideModelId,
+    overrideSupportedUrls,
+  },
+  modelId,
+  providerId,
+}: {
+  model: LanguageModelV4;
+  middleware: LanguageModelMiddleware;
+  modelId?: string;
+  providerId?: string;
+}): LanguageModelV4 => {
+  async function doTransform({
+    params,
+    type,
+  }: {
+    params: LanguageModelV4CallOptions;
+    type: 'generate' | 'stream';
+  }) {
+    return transformParams
+      ? await transformParams({ params, type, model })
+      : params;
+  }
+
+  return {
+    specificationVersion: 'v4',
+
+    provider: providerId ?? overrideProvider?.({ model }) ?? model.provider,
+    modelId: modelId ?? overrideModelId?.({ model }) ?? model.modelId,
+    supportedUrls: overrideSupportedUrls?.({ model }) ?? model.supportedUrls,
+
+    async doGenerate(
+      params: LanguageModelV4CallOptions,
+    ): Promise<LanguageModelV4GenerateResult> {
+      const transformedParams = await doTransform({ params, type: 'generate' });
+      const doGenerate = async () => model.doGenerate(transformedParams);
+      const doStream = async () => model.doStream(transformedParams);
+      return wrapGenerate
+        ? wrapGenerate({
+            doGenerate,
+            doStream,
+            params: transformedParams,
+            model,
+          })
+        : doGenerate();
+    },
+
+    async doStream(
+      params: LanguageModelV4CallOptions,
+    ): Promise<LanguageModelV4StreamResult> {
+      const transformedParams = await doTransform({ params, type: 'stream' });
+      const doGenerate = async () => model.doGenerate(transformedParams);
+      const doStream = async () => model.doStream(transformedParams);
+      return wrapStream
+        ? wrapStream({ doGenerate, doStream, params: transformedParams, model })
+        : doStream();
+    },
+  };
+};

package/src/middleware/wrap-provider.ts

@@ -0,0 +1,51 @@
+import type { ProviderV2, ProviderV3, ProviderV4 } from '@ai-sdk/provider';
+import { ImageModelMiddleware } from '../types/image-model-middleware';
+import { LanguageModelMiddleware } from '../types/language-model-middleware';
+import { wrapImageModel } from './wrap-image-model';
+import { wrapLanguageModel } from './wrap-language-model';
+import { asProviderV4 } from '../model/as-provider-v4';
+
+/**
+ * Wraps a ProviderV4 instance with middleware functionality.
+ * This function allows you to apply middleware to all language models
+ * from the provider, enabling you to transform parameters, wrap generate
+ * operations, and wrap stream operations for every language model.
+ *
+ * @param options - Configuration options for wrapping the provider.
+ * @param options.provider - The original ProviderV4 instance to be wrapped.
+ * @param options.languageModelMiddleware - The middleware to be applied to all language models from the provider. 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 provider. 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 ProviderV4 instance with middleware applied to all language models.
+ */
+export function wrapProvider({
+  provider,
+  languageModelMiddleware,
+  imageModelMiddleware,
+}: {
+  provider: ProviderV4 | ProviderV3 | ProviderV2;
+  languageModelMiddleware: LanguageModelMiddleware | LanguageModelMiddleware[];
+  imageModelMiddleware?: ImageModelMiddleware | ImageModelMiddleware[];
+}): ProviderV4 {
+  const providerV4 = asProviderV4(provider);
+  return {
+    specificationVersion: 'v4',
+    languageModel: (modelId: string) =>
+      wrapLanguageModel({
+        model: providerV4.languageModel(modelId),
+        middleware: languageModelMiddleware,
+      }),
+    embeddingModel: providerV4.embeddingModel,
+    imageModel: (modelId: string) => {
+      let model = providerV4.imageModel(modelId);
+
+      if (imageModelMiddleware != null) {
+        model = wrapImageModel({ model, middleware: imageModelMiddleware });
+      }
+
+      return model;
+    },
+    transcriptionModel: providerV4.transcriptionModel,
+    speechModel: providerV4.speechModel,
+    rerankingModel: providerV4.rerankingModel,
+  };
+}

package/src/model/as-embedding-model-v3.ts

@@ -0,0 +1,24 @@
+import { EmbeddingModelV2, EmbeddingModelV3 } from '@ai-sdk/provider';
+import { logV2CompatibilityWarning } from '../util/log-v2-compatibility-warning';
+
+export function asEmbeddingModelV3(
+  model: EmbeddingModelV2<string> | EmbeddingModelV3,
+): EmbeddingModelV3 {
+  if (model.specificationVersion === 'v3') {
+    return model;
+  }
+
+  logV2CompatibilityWarning({
+    provider: model.provider,
+    modelId: model.modelId,
+  });
+
+  // TODO this could break, we need to properly map v2 to v3
+  // and support all relevant v3 properties:
+  return new Proxy(model, {
+    get(target, prop: keyof EmbeddingModelV2<string>) {
+      if (prop === 'specificationVersion') return 'v3';
+      return target[prop];
+    },
+  }) as unknown as EmbeddingModelV3;
+}

package/src/model/as-embedding-model-v4.ts

@@ -0,0 +1,25 @@
+import {
+  EmbeddingModelV2,
+  EmbeddingModelV3,
+  EmbeddingModelV4,
+} from '@ai-sdk/provider';
+import { asEmbeddingModelV3 } from './as-embedding-model-v3';
+
+export function asEmbeddingModelV4(
+  model: EmbeddingModelV2<string> | EmbeddingModelV3 | EmbeddingModelV4,
+): EmbeddingModelV4 {
+  if (model.specificationVersion === 'v4') {
+    return model;
+  }
+
+  // first convert v2 to v3, then proxy v3 as v4:
+  const v3Model =
+    model.specificationVersion === 'v2' ? asEmbeddingModelV3(model) : model;
+
+  return new Proxy(v3Model, {
+    get(target, prop: keyof EmbeddingModelV3) {
+      if (prop === 'specificationVersion') return 'v4';
+      return target[prop];
+    },
+  }) as unknown as EmbeddingModelV4;
+}

package/src/model/as-image-model-v3.ts

@@ -0,0 +1,24 @@
+import { ImageModelV2, ImageModelV3 } from '@ai-sdk/provider';
+import { logV2CompatibilityWarning } from '../util/log-v2-compatibility-warning';
+
+export function asImageModelV3(
+  model: ImageModelV2 | ImageModelV3,
+): ImageModelV3 {
+  if (model.specificationVersion === 'v3') {
+    return model;
+  }
+
+  logV2CompatibilityWarning({
+    provider: model.provider,
+    modelId: model.modelId,
+  });
+
+  // TODO this could break, we need to properly map v2 to v3
+  // and support all relevant v3 properties:
+  return new Proxy(model, {
+    get(target, prop: keyof ImageModelV2) {
+      if (prop === 'specificationVersion') return 'v3';
+      return target[prop];
+    },
+  }) as unknown as ImageModelV3;
+}

package/src/model/as-image-model-v4.ts

@@ -0,0 +1,21 @@
+import { ImageModelV2, ImageModelV3, ImageModelV4 } from '@ai-sdk/provider';
+import { asImageModelV3 } from './as-image-model-v3';
+
+export function asImageModelV4(
+  model: ImageModelV2 | ImageModelV3 | ImageModelV4,
+): ImageModelV4 {
+  if (model.specificationVersion === 'v4') {
+    return model;
+  }
+
+  // first convert v2 to v3, then proxy v3 as v4:
+  const v3Model =
+    model.specificationVersion === 'v2' ? asImageModelV3(model) : model;
+
+  return new Proxy(v3Model, {
+    get(target, prop: keyof ImageModelV3) {
+      if (prop === 'specificationVersion') return 'v4';
+      return target[prop];
+    },
+  }) as unknown as ImageModelV4;
+}

package/src/model/as-language-model-v3.ts

@@ -0,0 +1,103 @@
+import {
+  LanguageModelV2,
+  LanguageModelV2FinishReason,
+  LanguageModelV2StreamPart,
+  LanguageModelV2Usage,
+  LanguageModelV3,
+  LanguageModelV3FinishReason,
+  LanguageModelV3StreamPart,
+  LanguageModelV3Usage,
+} from '@ai-sdk/provider';
+import { logV2CompatibilityWarning } from '../util/log-v2-compatibility-warning';
+
+export function asLanguageModelV3(
+  model: LanguageModelV2 | LanguageModelV3,
+): LanguageModelV3 {
+  if (model.specificationVersion === 'v3') {
+    return model;
+  }
+
+  logV2CompatibilityWarning({
+    provider: model.provider,
+    modelId: model.modelId,
+  });
+
+  // TODO this could break, we need to properly map v2 to v3
+  // and support all relevant v3 properties:
+  return new Proxy(model, {
+    get(target, prop: keyof LanguageModelV2) {
+      switch (prop) {
+        case 'specificationVersion':
+          return 'v3';
+        case 'doGenerate':
+          return async (...args: Parameters<LanguageModelV2['doGenerate']>) => {
+            const result = await target.doGenerate(...args);
+            return {
+              ...result,
+              finishReason: convertV2FinishReasonToV3(result.finishReason),
+              usage: convertV2UsageToV3(result.usage),
+            };
+          };
+        case 'doStream':
+          return async (...args: Parameters<LanguageModelV2['doStream']>) => {
+            const result = await target.doStream(...args);
+            return {
+              ...result,
+              stream: convertV2StreamToV3(result.stream),
+            };
+          };
+        default:
+          return target[prop];
+      }
+    },
+  }) as unknown as LanguageModelV3;
+}
+
+function convertV2StreamToV3(
+  stream: ReadableStream<LanguageModelV2StreamPart>,
+): ReadableStream<LanguageModelV3StreamPart> {
+  return stream.pipeThrough(
+    new TransformStream<LanguageModelV2StreamPart, LanguageModelV3StreamPart>({
+      transform(chunk, controller) {
+        switch (chunk.type) {
+          case 'finish':
+            controller.enqueue({
+              ...chunk,
+              finishReason: convertV2FinishReasonToV3(chunk.finishReason),
+              usage: convertV2UsageToV3(chunk.usage),
+            });
+            break;
+          default:
+            // TODO: AI SDK 6 - no casting (stream parts need to be mapped)
+            controller.enqueue(chunk as LanguageModelV3StreamPart);
+            break;
+        }
+      },
+    }),
+  );
+}
+
+function convertV2FinishReasonToV3(
+  finishReason: LanguageModelV2FinishReason,
+): LanguageModelV3FinishReason {
+  return {
+    unified: finishReason === 'unknown' ? 'other' : finishReason,
+    raw: undefined,
+  };
+}
+
+function convertV2UsageToV3(usage: LanguageModelV2Usage): LanguageModelV3Usage {
+  return {
+    inputTokens: {
+      total: usage.inputTokens,
+      noCache: undefined,
+      cacheRead: usage.cachedInputTokens,
+      cacheWrite: undefined,
+    },
+    outputTokens: {
+      total: usage.outputTokens,
+      text: undefined,
+      reasoning: usage.reasoningTokens,
+    },
+  };
+}

package/src/model/as-language-model-v4.ts

@@ -0,0 +1,25 @@
+import {
+  LanguageModelV2,
+  LanguageModelV3,
+  LanguageModelV4,
+} from '@ai-sdk/provider';
+import { asLanguageModelV3 } from './as-language-model-v3';
+
+export function asLanguageModelV4(
+  model: LanguageModelV2 | LanguageModelV3 | LanguageModelV4,
+): LanguageModelV4 {
+  if (model.specificationVersion === 'v4') {
+    return model;
+  }
+
+  // first convert v2 to v3, then proxy v3 as v4:
+  const v3Model =
+    model.specificationVersion === 'v2' ? asLanguageModelV3(model) : model;
+
+  return new Proxy(v3Model, {
+    get(target, prop: keyof LanguageModelV3) {
+      if (prop === 'specificationVersion') return 'v4';
+      return target[prop];
+    },
+  }) as unknown as LanguageModelV4;
+}

package/src/model/as-provider-v3.ts

@@ -0,0 +1,36 @@
+import { ProviderV2, ProviderV3 } from '@ai-sdk/provider';
+import { asEmbeddingModelV3 } from './as-embedding-model-v3';
+import { asImageModelV3 } from './as-image-model-v3';
+import { asLanguageModelV3 } from './as-language-model-v3';
+import { asTranscriptionModelV3 } from './as-transcription-model-v3';
+import { asSpeechModelV3 } from './as-speech-model-v3';
+
+export function asProviderV3(provider: ProviderV2 | ProviderV3): ProviderV3 {
+  if (
+    'specificationVersion' in provider &&
+    provider.specificationVersion === 'v3'
+  ) {
+    return provider;
+  }
+
+  // v3 providers have already been returned
+  const v2Provider: ProviderV2 = provider as ProviderV2;
+
+  return {
+    specificationVersion: 'v3',
+    languageModel: (modelId: string) =>
+      asLanguageModelV3(v2Provider.languageModel(modelId)),
+    embeddingModel: (modelId: string) =>
+      asEmbeddingModelV3(v2Provider.textEmbeddingModel(modelId)),
+    imageModel: (modelId: string) =>
+      asImageModelV3(v2Provider.imageModel(modelId)),
+    transcriptionModel: v2Provider.transcriptionModel
+      ? (modelId: string) =>
+          asTranscriptionModelV3(v2Provider.transcriptionModel!(modelId))
+      : undefined,
+    speechModel: v2Provider.speechModel
+      ? (modelId: string) => asSpeechModelV3(v2Provider.speechModel!(modelId))
+      : undefined,
+    rerankingModel: undefined, // v2 providers don't have reranking models
+  };
+}

package/src/model/as-provider-v4.ts

@@ -0,0 +1,47 @@
+import { ProviderV2, ProviderV3, ProviderV4 } from '@ai-sdk/provider';
+import { asProviderV3 } from './as-provider-v3';
+import { asEmbeddingModelV4 } from './as-embedding-model-v4';
+import { asImageModelV4 } from './as-image-model-v4';
+import { asLanguageModelV4 } from './as-language-model-v4';
+import { asRerankingModelV4 } from './as-reranking-model-v4';
+import { asTranscriptionModelV4 } from './as-transcription-model-v4';
+import { asSpeechModelV4 } from './as-speech-model-v4';
+
+export function asProviderV4(
+  provider: ProviderV2 | ProviderV3 | ProviderV4,
+): ProviderV4 {
+  if (
+    'specificationVersion' in provider &&
+    provider.specificationVersion === 'v4'
+  ) {
+    return provider;
+  }
+
+  // first ensure we have at least a v3 provider:
+  const v3Provider: ProviderV3 =
+    !('specificationVersion' in provider) ||
+    provider.specificationVersion !== 'v3'
+      ? asProviderV3(provider as ProviderV2)
+      : provider;
+
+  return {
+    specificationVersion: 'v4',
+    languageModel: (modelId: string) =>
+      asLanguageModelV4(v3Provider.languageModel(modelId)),
+    embeddingModel: (modelId: string) =>
+      asEmbeddingModelV4(v3Provider.embeddingModel(modelId)),
+    imageModel: (modelId: string) =>
+      asImageModelV4(v3Provider.imageModel(modelId)),
+    transcriptionModel: v3Provider.transcriptionModel
+      ? (modelId: string) =>
+          asTranscriptionModelV4(v3Provider.transcriptionModel!(modelId))
+      : undefined,
+    speechModel: v3Provider.speechModel
+      ? (modelId: string) => asSpeechModelV4(v3Provider.speechModel!(modelId))
+      : undefined,
+    rerankingModel: v3Provider.rerankingModel
+      ? (modelId: string) =>
+          asRerankingModelV4(v3Provider.rerankingModel!(modelId))
+      : undefined,
+  };
+}

package/src/model/as-reranking-model-v4.ts

@@ -0,0 +1,16 @@
+import { RerankingModelV3, RerankingModelV4 } from '@ai-sdk/provider';
+
+export function asRerankingModelV4(
+  model: RerankingModelV3 | RerankingModelV4,
+): RerankingModelV4 {
+  if (model.specificationVersion === 'v4') {
+    return model;
+  }
+
+  return new Proxy(model, {
+    get(target, prop: keyof RerankingModelV3) {
+      if (prop === 'specificationVersion') return 'v4';
+      return target[prop];
+    },
+  }) as unknown as RerankingModelV4;
+}