ai 6.0.32 → 6.0.34

package/src/middleware/wrap-provider.test.ts

@@ -0,0 +1,120 @@
+import { MockLanguageModelV2 } from '../test/mock-language-model-v2';
+import { MockLanguageModelV3 } from '../test/mock-language-model-v3';
+import { MockImageModelV3 } from '../test/mock-image-model-v3';
+import { MockProviderV2 } from '../test/mock-provider-v2';
+import { MockProviderV3 } from '../test/mock-provider-v3';
+import { wrapProvider } from './wrap-provider';
+import { describe, it, expect, vi } from 'vitest';
+
+describe('wrapProvider', () => {
+  it('should wrap all language models in the provider', () => {
+    const model1 = new MockLanguageModelV3({ modelId: 'model-1' });
+    const model2 = new MockLanguageModelV3({ modelId: 'model-2' });
+    const model3 = new MockLanguageModelV3({ modelId: 'model-3' });
+
+    const provider = new MockProviderV3({
+      languageModels: {
+        'model-1': model1,
+        'model-2': model2,
+        'model-3': model3,
+      },
+    });
+
+    const overrideModelId = vi
+      .fn()
+      .mockImplementation(({ model }) => `override-${model.modelId}`);
+
+    const wrappedProvider = wrapProvider({
+      provider,
+      languageModelMiddleware: {
+        specificationVersion: 'v3',
+        overrideModelId,
+      },
+    });
+
+    expect(wrappedProvider.languageModel('model-1').modelId).toBe(
+      'override-model-1',
+    );
+    expect(wrappedProvider.languageModel('model-2').modelId).toBe(
+      'override-model-2',
+    );
+    expect(wrappedProvider.languageModel('model-3').modelId).toBe(
+      'override-model-3',
+    );
+
+    expect(overrideModelId).toHaveBeenCalledTimes(3);
+    expect(overrideModelId).toHaveBeenCalledWith({ model: model1 });
+    expect(overrideModelId).toHaveBeenCalledWith({ model: model2 });
+    expect(overrideModelId).toHaveBeenCalledWith({ model: model3 });
+  });
+
+  it('should work when the provider is a ProviderV2', () => {
+    const v2Model1 = new MockLanguageModelV2({ modelId: 'model-1' });
+    const v2Model2 = new MockLanguageModelV2({ modelId: 'model-2' });
+
+    const providerV2 = new MockProviderV2({
+      languageModels: {
+        'model-1': v2Model1,
+        'model-2': v2Model2,
+      },
+    });
+
+    const wrapped = wrapProvider({
+      provider: providerV2,
+      languageModelMiddleware: {
+        specificationVersion: 'v3',
+        overrideModelId: ({ model }) => `override-${model.modelId}`,
+      },
+    });
+
+    expect(wrapped.languageModel('model-1').modelId).toBe('override-model-1');
+    expect(wrapped.languageModel('model-2').modelId).toBe('override-model-2');
+  });
+
+  it('should wrap all image models in the provider when image middleware is provided', () => {
+    const model1 = new MockImageModelV3({ modelId: 'model-1' });
+    const model2 = new MockImageModelV3({ modelId: 'model-2' });
+    const model3 = new MockImageModelV3({ modelId: 'model-3' });
+
+    const provider = new MockProviderV3({
+      languageModels: {
+        'language-model': new MockLanguageModelV3({
+          modelId: 'language-model',
+        }),
+      },
+      imageModels: {
+        'model-1': model1,
+        'model-2': model2,
+        'model-3': model3,
+      },
+    });
+
+    const overrideModelId = vi
+      .fn()
+      .mockImplementation(({ model }) => `override-${model.modelId}`);
+
+    const wrappedProvider = wrapProvider({
+      provider,
+      languageModelMiddleware: { specificationVersion: 'v3' },
+      imageModelMiddleware: {
+        specificationVersion: 'v3',
+        overrideModelId,
+      },
+    });
+
+    expect(wrappedProvider.imageModel('model-1').modelId).toBe(
+      'override-model-1',
+    );
+    expect(wrappedProvider.imageModel('model-2').modelId).toBe(
+      'override-model-2',
+    );
+    expect(wrappedProvider.imageModel('model-3').modelId).toBe(
+      'override-model-3',
+    );
+
+    expect(overrideModelId).toHaveBeenCalledTimes(3);
+    expect(overrideModelId).toHaveBeenCalledWith({ model: model1 });
+    expect(overrideModelId).toHaveBeenCalledWith({ model: model2 });
+    expect(overrideModelId).toHaveBeenCalledWith({ model: model3 });
+  });
+});

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.test.ts

@@ -0,0 +1,319 @@
+import { EmbeddingModelV2 } from '@ai-sdk/provider';
+import { asEmbeddingModelV3 } from './as-embedding-model-v3';
+import { MockEmbeddingModelV2 } from '../test/mock-embedding-model-v2';
+import { MockEmbeddingModelV3 } from '../test/mock-embedding-model-v3';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as logWarningsModule from '../logger/log-warnings';
+
+describe('asEmbeddingModelV3', () => {
+  let logWarningSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    logWarningSpy = vi.spyOn(logWarningsModule, 'logWarnings');
+  });
+
+  afterEach(() => {
+    logWarningSpy.mockRestore();
+  });
+
+  describe('when an embedding model v3 is provided', () => {
+    it('should return the same v3 model unchanged', () => {
+      const originalModel = new MockEmbeddingModelV3({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+      });
+
+      const result = asEmbeddingModelV3(originalModel);
+
+      expect(result).toBe(originalModel);
+      expect(result.specificationVersion).toBe('v3');
+    });
+
+    it('should not log any warning', () => {
+      const originalModel = new MockEmbeddingModelV3({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+      });
+
+      asEmbeddingModelV3(originalModel);
+
+      expect(logWarningSpy).not.toHaveBeenCalled();
+    });
+
+    it('should preserve all v3 model properties', () => {
+      const originalModel = new MockEmbeddingModelV3({
+        provider: 'test-provider-v3',
+        modelId: 'test-model-v3',
+        maxEmbeddingsPerCall: 10,
+        supportsParallelCalls: true,
+      });
+
+      const result = asEmbeddingModelV3(originalModel);
+
+      expect(result.provider).toBe('test-provider-v3');
+      expect(result.modelId).toBe('test-model-v3');
+      expect(result.maxEmbeddingsPerCall).toBe(10);
+      expect(result.supportsParallelCalls).toBe(true);
+      expect(result.specificationVersion).toBe('v3');
+    });
+  });
+
+  describe('when an embedding model v2 is provided', () => {
+    it('should convert v2 to v3 and change specificationVersion', () => {
+      const v2Model = new MockEmbeddingModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+      });
+
+      const result = asEmbeddingModelV3(v2Model);
+
+      expect(result.specificationVersion).toBe('v3');
+      expect(result).not.toBe(v2Model);
+    });
+
+    it('should log a compatibility warning', () => {
+      const v2Model = new MockEmbeddingModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+      });
+
+      asEmbeddingModelV3(v2Model);
+
+      expect(logWarningSpy).toHaveBeenCalledWith({
+        warnings: [
+          {
+            type: 'compatibility',
+            feature: 'specificationVersion',
+            details: expect.stringContaining(
+              'Using v2 specification compatibility',
+            ),
+          },
+        ],
+        provider: 'test-provider',
+        model: 'test-model-id',
+      });
+    });
+
+    it('should preserve provider property', () => {
+      const v2Model = new MockEmbeddingModelV2({
+        provider: 'test-provider-v2',
+        modelId: 'test-model-id',
+      });
+
+      const result = asEmbeddingModelV3(v2Model);
+
+      expect(result.provider).toBe('test-provider-v2');
+    });
+
+    it('should preserve modelId property', () => {
+      const v2Model = new MockEmbeddingModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-v2',
+      });
+
+      const result = asEmbeddingModelV3(v2Model);
+
+      expect(result.modelId).toBe('test-model-v2');
+    });
+
+    it('should preserve maxEmbeddingsPerCall property', () => {
+      const v2Model = new MockEmbeddingModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        maxEmbeddingsPerCall: 5,
+      });
+
+      const result = asEmbeddingModelV3(v2Model);
+
+      expect(result.maxEmbeddingsPerCall).toBe(5);
+    });
+
+    it('should preserve maxEmbeddingsPerCall as undefined', () => {
+      const v2Model = new MockEmbeddingModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        maxEmbeddingsPerCall: null,
+      });
+
+      const result = asEmbeddingModelV3(v2Model);
+
+      expect(result.maxEmbeddingsPerCall).toBeUndefined();
+    });
+
+    it('should preserve supportsParallelCalls property', () => {
+      const v2Model = new MockEmbeddingModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        supportsParallelCalls: true,
+      });
+
+      const result = asEmbeddingModelV3(v2Model);
+
+      expect(result.supportsParallelCalls).toBe(true);
+    });
+
+    it('should preserve supportsParallelCalls as promise', async () => {
+      const v2Model = new MockEmbeddingModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        supportsParallelCalls: Promise.resolve(true),
+      });
+
+      const result = asEmbeddingModelV3(v2Model);
+
+      expect(await result.supportsParallelCalls).toBe(true);
+    });
+
+    it('should make doEmbed method callable', async () => {
+      const v2Model = new MockEmbeddingModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        doEmbed: async () => ({
+          embeddings: [[0.1, 0.2, 0.3]],
+        }),
+      });
+
+      const result = asEmbeddingModelV3(v2Model);
+
+      const response = await result.doEmbed({
+        values: ['test text'],
+      });
+
+      expect(response.embeddings).toHaveLength(1);
+      expect(response.embeddings[0]).toEqual([0.1, 0.2, 0.3]);
+    });
+
+    it('should handle doEmbed with multiple embeddings', async () => {
+      const v2Model = new MockEmbeddingModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        doEmbed: async () => ({
+          embeddings: [
+            [0.1, 0.2, 0.3],
+            [0.4, 0.5, 0.6],
+          ],
+        }),
+      });
+
+      const result = asEmbeddingModelV3(v2Model);
+
+      const response = await result.doEmbed({
+        values: ['text one', 'text two'],
+      });
+
+      expect(response.embeddings).toHaveLength(2);
+      expect(response.embeddings[0]).toEqual([0.1, 0.2, 0.3]);
+      expect(response.embeddings[1]).toEqual([0.4, 0.5, 0.6]);
+    });
+
+    it('should handle doEmbed with usage information', async () => {
+      const v2Model = new MockEmbeddingModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        doEmbed: async () => ({
+          embeddings: [[0.1, 0.2, 0.3]],
+          usage: { tokens: 50 },
+        }),
+      });
+
+      const result = asEmbeddingModelV3(v2Model);
+
+      const response = await result.doEmbed({
+        values: ['test text'],
+      });
+
+      expect(response.usage?.tokens).toBe(50);
+    });
+
+    it('should handle doEmbed with provider metadata', async () => {
+      const v2Model = new MockEmbeddingModelV2<string>({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        doEmbed: async () => ({
+          embeddings: [[0.1, 0.2, 0.3]],
+          providerMetadata: {
+            testProvider: { customField: 'value' },
+          },
+        }),
+      });
+
+      const result = asEmbeddingModelV3(v2Model);
+
+      const response = await result.doEmbed({
+        values: ['test text'],
+      });
+
+      expect(response.providerMetadata?.testProvider).toEqual({
+        customField: 'value',
+      });
+    });
+
+    it('should handle doEmbed with response headers', async () => {
+      const v2Model = new MockEmbeddingModelV2<string>({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        doEmbed: async () => ({
+          embeddings: [[0.1, 0.2, 0.3]],
+          response: {
+            headers: { 'x-custom': 'header-value' },
+          },
+        }),
+      });
+
+      const result = asEmbeddingModelV3(v2Model);
+
+      const response = await result.doEmbed({
+        values: ['test text'],
+      });
+
+      expect(response.response?.headers).toEqual({
+        'x-custom': 'header-value',
+      });
+    });
+
+    it('should handle doEmbed with response body', async () => {
+      const v2Model = new MockEmbeddingModelV2<string>({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        doEmbed: async () => ({
+          embeddings: [[0.1, 0.2, 0.3]],
+          response: {
+            body: { raw: 'response data' },
+          },
+        }),
+      });
+
+      const result = asEmbeddingModelV3(v2Model);
+
+      const response = await result.doEmbed({
+        values: ['test text'],
+      });
+
+      expect(response.response?.body).toEqual({ raw: 'response data' });
+    });
+
+    it('should preserve prototype methods when using class instances', async () => {
+      class TestEmbeddingModelV2 implements EmbeddingModelV2<string> {
+        readonly specificationVersion = 'v2' as const;
+        readonly provider = 'test-provider';
+        readonly modelId = 'test-model-id';
+        readonly maxEmbeddingsPerCall = 1;
+        readonly supportsParallelCalls = false;
+
+        customMethod() {
+          return 'custom-value';
+        }
+
+        async doEmbed() {
+          return { embeddings: [[0.1, 0.2, 0.3]] };
+        }
+      }
+
+      const v2Model = new TestEmbeddingModelV2();
+      const result = asEmbeddingModelV3(v2Model) as any;
+
+      expect(result.customMethod()).toBe('custom-value');
+      expect(result.specificationVersion).toBe('v3');
+    });
+  });
+});

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;
+}