@depup/ai 6.0.116-depup.0

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

@@ -0,0 +1,86 @@
+import {
+  EmbeddingModelV3,
+  EmbeddingModelV3CallOptions,
+} from '@ai-sdk/provider';
+import { EmbeddingModelMiddleware } from '../types';
+import { asArray } from '../util/as-array';
+
+/**
+ * Wraps an EmbeddingModelV3 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 EmbeddingModelV3 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 EmbeddingModelV3 instance with middleware applied.
+ */
+export const wrapEmbeddingModel = ({
+  model,
+  middleware: middlewareArg,
+  modelId,
+  providerId,
+}: {
+  model: EmbeddingModelV3;
+  middleware: EmbeddingModelMiddleware | EmbeddingModelMiddleware[];
+  modelId?: string;
+  providerId?: string;
+}): EmbeddingModelV3 => {
+  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: EmbeddingModelV3;
+  middleware: EmbeddingModelMiddleware;
+  modelId?: string;
+  providerId?: string;
+}): EmbeddingModelV3 => {
+  async function doTransform({
+    params,
+  }: {
+    params: EmbeddingModelV3CallOptions;
+  }) {
+    return transformParams ? await transformParams({ params, model }) : params;
+  }
+
+  return {
+    specificationVersion: 'v3',
+    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: EmbeddingModelV3CallOptions,
+    ): Promise<Awaited<ReturnType<EmbeddingModelV3['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,85 @@
+import { ImageModelV3, ImageModelV3CallOptions } from '@ai-sdk/provider';
+import { ImageModelMiddleware } from '../types';
+import { asArray } from '../util/as-array';
+
+/**
+ * Wraps an ImageModelV3 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 ImageModelV3 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 ImageModelV3 instance with middleware applied.
+ */
+export const wrapImageModel = ({
+  model,
+  middleware: middlewareArg,
+  modelId,
+  providerId,
+}: {
+  model: ImageModelV3;
+  middleware: ImageModelMiddleware | ImageModelMiddleware[];
+  modelId?: string;
+  providerId?: string;
+}): ImageModelV3 => {
+  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: ImageModelV3;
+  middleware: ImageModelMiddleware;
+  modelId?: string;
+  providerId?: string;
+}): ImageModelV3 => {
+  async function doTransform({ params }: { params: ImageModelV3CallOptions }) {
+    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: 'v3',
+    provider: providerId ?? overrideProvider?.({ model }) ?? model.provider,
+    modelId: modelId ?? overrideModelId?.({ model }) ?? model.modelId,
+    maxImagesPerCall,
+    async doGenerate(
+      params: ImageModelV3CallOptions,
+    ): Promise<Awaited<ReturnType<ImageModelV3['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,104 @@
+import {
+  LanguageModelV3,
+  LanguageModelV3CallOptions,
+  LanguageModelV3GenerateResult,
+  LanguageModelV3StreamResult,
+} from '@ai-sdk/provider';
+import { LanguageModelMiddleware } from '../types';
+import { asArray } from '../util/as-array';
+
+/**
+ * Wraps a LanguageModelV3 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 LanguageModelV3 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 LanguageModelV3 instance with middleware applied.
+ */
+export const wrapLanguageModel = ({
+  model,
+  middleware: middlewareArg,
+  modelId,
+  providerId,
+}: {
+  model: LanguageModelV3;
+  middleware: LanguageModelMiddleware | LanguageModelMiddleware[];
+  modelId?: string;
+  providerId?: string;
+}): LanguageModelV3 => {
+  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: LanguageModelV3;
+  middleware: LanguageModelMiddleware;
+  modelId?: string;
+  providerId?: string;
+}): LanguageModelV3 => {
+  async function doTransform({
+    params,
+    type,
+  }: {
+    params: LanguageModelV3CallOptions;
+    type: 'generate' | 'stream';
+  }) {
+    return transformParams
+      ? await transformParams({ params, type, model })
+      : params;
+  }
+
+  return {
+    specificationVersion: 'v3',
+
+    provider: providerId ?? overrideProvider?.({ model }) ?? model.provider,
+    modelId: modelId ?? overrideModelId?.({ model }) ?? model.modelId,
+    supportedUrls: overrideSupportedUrls?.({ model }) ?? model.supportedUrls,
+
+    async doGenerate(
+      params: LanguageModelV3CallOptions,
+    ): Promise<LanguageModelV3GenerateResult> {
+      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: LanguageModelV3CallOptions,
+    ): Promise<LanguageModelV3StreamResult> {
+      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 } 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 { asProviderV3 } from '../model/as-provider-v3';
+
+/**
+ * Wraps a ProviderV3 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 ProviderV3 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 ProviderV3 instance with middleware applied to all language models.
+ */
+export function wrapProvider({
+  provider,
+  languageModelMiddleware,
+  imageModelMiddleware,
+}: {
+  provider: ProviderV3 | ProviderV2;
+  languageModelMiddleware: LanguageModelMiddleware | LanguageModelMiddleware[];
+  imageModelMiddleware?: ImageModelMiddleware | ImageModelMiddleware[];
+}): ProviderV3 {
+  const providerV3 = asProviderV3(provider);
+  return {
+    specificationVersion: 'v3',
+    languageModel: (modelId: string) =>
+      wrapLanguageModel({
+        model: providerV3.languageModel(modelId),
+        middleware: languageModelMiddleware,
+      }),
+    embeddingModel: providerV3.embeddingModel,
+    imageModel: (modelId: string) => {
+      let model = providerV3.imageModel(modelId);
+
+      if (imageModelMiddleware != null) {
+        model = wrapImageModel({ model, middleware: imageModelMiddleware });
+      }
+
+      return model;
+    },
+    transcriptionModel: providerV3.transcriptionModel,
+    speechModel: providerV3.speechModel,
+    rerankingModel: providerV3.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-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-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-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-speech-model-v3.ts

@@ -0,0 +1,24 @@
+import { SpeechModelV2, SpeechModelV3 } from '@ai-sdk/provider';
+import { logV2CompatibilityWarning } from '../util/log-v2-compatibility-warning';
+
+export function asSpeechModelV3(
+  model: SpeechModelV3 | SpeechModelV2,
+): SpeechModelV3 {
+  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 SpeechModelV2) {
+      if (prop === 'specificationVersion') return 'v3';
+      return target[prop];
+    },
+  }) as unknown as SpeechModelV3;
+}

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

@@ -0,0 +1,24 @@
+import { TranscriptionModelV2, TranscriptionModelV3 } from '@ai-sdk/provider';
+import { logV2CompatibilityWarning } from '../util/log-v2-compatibility-warning';
+
+export function asTranscriptionModelV3(
+  model: TranscriptionModelV3 | TranscriptionModelV2,
+): TranscriptionModelV3 {
+  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 TranscriptionModelV2) {
+      if (prop === 'specificationVersion') return 'v3';
+      return target[prop];
+    },
+  }) as unknown as TranscriptionModelV3;
+}