ai 6.0.33 → 6.0.35

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

@@ -0,0 +1,508 @@
+import { LanguageModelV2 } from '@ai-sdk/provider';
+import {
+  convertArrayToReadableStream,
+  convertReadableStreamToArray,
+} from '@ai-sdk/provider-utils/test';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as logWarningsModule from '../logger/log-warnings';
+import { MockLanguageModelV2 } from '../test/mock-language-model-v2';
+import { MockLanguageModelV3 } from '../test/mock-language-model-v3';
+import { asLanguageModelV3 } from './as-language-model-v3';
+
+describe('asLanguageModelV3', () => {
+  let logWarningSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    logWarningSpy = vi.spyOn(logWarningsModule, 'logWarnings');
+  });
+
+  afterEach(() => {
+    logWarningSpy.mockRestore();
+  });
+
+  describe('when a language model v3 is provided', () => {
+    it('should return the same v3 model unchanged', () => {
+      const originalModel = new MockLanguageModelV3({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+      });
+
+      const result = asLanguageModelV3(originalModel);
+
+      expect(result).toBe(originalModel);
+      expect(result.specificationVersion).toBe('v3');
+    });
+
+    it('should not log any warning', () => {
+      const originalModel = new MockLanguageModelV3({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+      });
+
+      asLanguageModelV3(originalModel);
+
+      expect(logWarningSpy).not.toHaveBeenCalled();
+    });
+
+    it('should preserve all v3 model properties', () => {
+      const originalModel = new MockLanguageModelV3({
+        provider: 'test-provider-v3',
+        modelId: 'test-model-v3',
+        supportedUrls: { 'image/*': [/^https:\/\/test\.com/] },
+      });
+
+      const result = asLanguageModelV3(originalModel);
+
+      expect(result.provider).toBe('test-provider-v3');
+      expect(result.modelId).toBe('test-model-v3');
+      expect(result.specificationVersion).toBe('v3');
+    });
+  });
+
+  describe('when a language model v2 is provided', () => {
+    it('should convert v2 to v3 and change specificationVersion', () => {
+      const v2Model = new MockLanguageModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+      });
+
+      const result = asLanguageModelV3(v2Model);
+
+      expect(result.specificationVersion).toBe('v3');
+      expect(result).not.toBe(v2Model);
+    });
+
+    it('should log a compatibility warning', () => {
+      const v2Model = new MockLanguageModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+      });
+
+      asLanguageModelV3(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 MockLanguageModelV2({
+        provider: 'test-provider-v2',
+        modelId: 'test-model-id',
+      });
+
+      const result = asLanguageModelV3(v2Model);
+
+      expect(result.provider).toBe('test-provider-v2');
+    });
+
+    it('should preserve modelId property', () => {
+      const v2Model = new MockLanguageModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-v2',
+      });
+
+      const result = asLanguageModelV3(v2Model);
+
+      expect(result.modelId).toBe('test-model-v2');
+    });
+
+    it('should preserve supportedUrls property', async () => {
+      const supportedUrls = { 'audio/*': [/^https:\/\/example\.com/] };
+      const v2Model = new MockLanguageModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        supportedUrls,
+      });
+
+      const result = asLanguageModelV3(v2Model);
+
+      expect(await result.supportedUrls).toEqual(supportedUrls);
+    });
+
+    it('should preserve supportedUrls as promise', async () => {
+      const supportedUrls = { 'video/*': [/^https:\/\/videos\.com/] };
+      const v2Model = new MockLanguageModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        supportedUrls: () => Promise.resolve(supportedUrls),
+      });
+
+      const result = asLanguageModelV3(v2Model);
+
+      expect(await result.supportedUrls).toEqual(supportedUrls);
+    });
+
+    it('should make doGenerate method callable', async () => {
+      const v2Model = new MockLanguageModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        doGenerate: async () => ({
+          content: [{ type: 'text', text: 'Hello' }],
+          finishReason: 'stop',
+          usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+          warnings: [],
+        }),
+      });
+
+      const result = asLanguageModelV3(v2Model);
+
+      const response = await result.doGenerate({
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'test' }] }],
+      });
+
+      expect(response).toMatchInlineSnapshot(`
+        {
+          "content": [
+            {
+              "text": "Hello",
+              "type": "text",
+            },
+          ],
+          "finishReason": {
+            "raw": undefined,
+            "unified": "stop",
+          },
+          "usage": {
+            "inputTokens": {
+              "cacheRead": undefined,
+              "cacheWrite": undefined,
+              "noCache": undefined,
+              "total": 10,
+            },
+            "outputTokens": {
+              "reasoning": undefined,
+              "text": undefined,
+              "total": 5,
+            },
+          },
+          "warnings": [],
+        }
+      `);
+    });
+
+    describe('doStream', () => {
+      it('should convert v2 stream to v3 stream', async () => {
+        const v2Model = new MockLanguageModelV2({
+          doStream: async ({ prompt }) => {
+            return {
+              stream: convertArrayToReadableStream([
+                { type: 'text-start', id: '1' },
+                { type: 'text-delta', id: '1', delta: 'Hello' },
+                { type: 'text-delta', id: '1', delta: ', ' },
+                { type: 'text-delta', id: '1', delta: `world!` },
+                { type: 'text-end', id: '1' },
+                {
+                  type: 'finish',
+                  finishReason: 'stop',
+                  usage: {
+                    inputTokens: 3,
+                    outputTokens: 10,
+                    totalTokens: 13,
+                    reasoningTokens: 2,
+                    cachedInputTokens: 4,
+                  },
+                },
+              ]),
+            };
+          },
+        });
+
+        const { stream } = await asLanguageModelV3(v2Model).doStream({
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'test' }] }],
+        });
+
+        expect(await convertReadableStreamToArray(stream))
+          .toMatchInlineSnapshot(`
+            [
+              {
+                "id": "1",
+                "type": "text-start",
+              },
+              {
+                "delta": "Hello",
+                "id": "1",
+                "type": "text-delta",
+              },
+              {
+                "delta": ", ",
+                "id": "1",
+                "type": "text-delta",
+              },
+              {
+                "delta": "world!",
+                "id": "1",
+                "type": "text-delta",
+              },
+              {
+                "id": "1",
+                "type": "text-end",
+              },
+              {
+                "finishReason": {
+                  "raw": undefined,
+                  "unified": "stop",
+                },
+                "type": "finish",
+                "usage": {
+                  "inputTokens": {
+                    "cacheRead": 4,
+                    "cacheWrite": undefined,
+                    "noCache": undefined,
+                    "total": 3,
+                  },
+                  "outputTokens": {
+                    "reasoning": 2,
+                    "text": undefined,
+                    "total": 10,
+                  },
+                },
+              },
+            ]
+          `);
+      });
+    });
+
+    it('should preserve prototype methods when using class instances', async () => {
+      class TestLanguageModelV2 implements LanguageModelV2 {
+        readonly specificationVersion = 'v2' as const;
+        readonly provider = 'test-provider';
+        readonly modelId = 'test-model-id';
+        readonly supportedUrls = {};
+
+        customMethod() {
+          return 'custom-value';
+        }
+
+        async doGenerate() {
+          return {
+            content: [],
+            finishReason: 'stop' as const,
+            usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+            warnings: [],
+          };
+        }
+
+        async doStream() {
+          return { stream: new ReadableStream() };
+        }
+      }
+
+      const v2Model = new TestLanguageModelV2();
+      const result = asLanguageModelV3(v2Model) as any;
+
+      expect(result.customMethod()).toBe('custom-value');
+      expect(result.specificationVersion).toBe('v3');
+    });
+
+    it('should handle model with request/response metadata in doGenerate', async () => {
+      const v2Model = new MockLanguageModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        doGenerate: async () => ({
+          content: [{ type: 'text', text: 'Response' }],
+          finishReason: 'stop',
+          usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+          warnings: [],
+          request: { body: { prompt: 'test' } },
+          response: {
+            id: 'resp-123',
+            timestamp: new Date(),
+            headers: { 'x-custom': 'value' },
+            body: { response: 'data' },
+          },
+        }),
+      });
+
+      const result = asLanguageModelV3(v2Model);
+
+      const response = await result.doGenerate({
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'test' }] }],
+      });
+
+      expect(response.request?.body).toBeDefined();
+      expect(response.response?.headers).toBeDefined();
+    });
+
+    it('should handle model with provider metadata', async () => {
+      const v2Model = new MockLanguageModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        doGenerate: async () => ({
+          content: [{ type: 'text', text: 'Response' }],
+          finishReason: 'stop',
+          usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+          warnings: [],
+          providerMetadata: {
+            testProvider: { customField: 'value' },
+          },
+        }),
+      });
+
+      const result = asLanguageModelV3(v2Model);
+
+      const response = await result.doGenerate({
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'test' }] }],
+      });
+
+      expect(response.providerMetadata?.testProvider).toEqual({
+        customField: 'value',
+      });
+    });
+
+    it('should handle model with warnings', async () => {
+      const v2Model = new MockLanguageModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        doGenerate: async () => ({
+          content: [{ type: 'text', text: 'Response' }],
+          finishReason: 'stop',
+          usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+          warnings: [
+            {
+              type: 'unsupported-setting',
+              setting: 'temperature',
+              details: 'Temperature not supported',
+            },
+          ],
+        }),
+      });
+
+      const result = asLanguageModelV3(v2Model);
+
+      const response = await result.doGenerate({
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'test' }] }],
+      });
+
+      expect(response.warnings).toHaveLength(1);
+      expect(response.warnings[0].type).toBe('unsupported-setting');
+    });
+
+    it('should handle response with reasoning tokens in usage', async () => {
+      const v2Model = new MockLanguageModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        doGenerate: async () => ({
+          content: [{ type: 'text', text: 'Response' }],
+          finishReason: 'stop',
+          usage: {
+            inputTokens: 10,
+            outputTokens: 5,
+            totalTokens: 20,
+            reasoningTokens: 5,
+          },
+          warnings: [],
+        }),
+      });
+
+      const result = asLanguageModelV3(v2Model);
+
+      const response = await result.doGenerate({
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'test' }] }],
+      });
+
+      expect(response.usage?.outputTokens?.reasoning).toBe(5);
+    });
+
+    it('should handle response with cached input tokens in usage', async () => {
+      const v2Model = new MockLanguageModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        doGenerate: async () => ({
+          content: [{ type: 'text', text: 'Response' }],
+          finishReason: 'stop',
+          usage: {
+            inputTokens: 10,
+            outputTokens: 5,
+            totalTokens: 15,
+            cachedInputTokens: 8,
+          },
+          warnings: [],
+        }),
+      });
+
+      const result = asLanguageModelV3(v2Model);
+
+      const response = await result.doGenerate({
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'test' }] }],
+      });
+
+      expect(response.usage?.inputTokens?.cacheRead).toBe(8);
+    });
+
+    it('should handle response with different finish reasons', async () => {
+      const finishReasons: Array<
+        | 'stop'
+        | 'length'
+        | 'content-filter'
+        | 'tool-calls'
+        | 'error'
+        | 'other'
+        | 'unknown'
+      > = [
+        'stop',
+        'length',
+        'content-filter',
+        'tool-calls',
+        'error',
+        'other',
+        'unknown',
+      ];
+
+      for (const finishReason of finishReasons) {
+        const v2Model = new MockLanguageModelV2({
+          provider: 'test-provider',
+          modelId: 'test-model-id',
+          doGenerate: async () => ({
+            content: [{ type: 'text', text: 'Response' }],
+            finishReason,
+            usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+            warnings: [],
+          }),
+        });
+
+        const result = asLanguageModelV3(v2Model);
+
+        const response = await result.doGenerate({
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'test' }] }],
+        });
+
+        expect(response.finishReason).toStrictEqual({
+          raw: undefined,
+          unified: finishReason === 'unknown' ? 'other' : finishReason,
+        });
+      }
+    });
+
+    it('should handle doStream with response headers', async () => {
+      const v2Model = new MockLanguageModelV2({
+        provider: 'test-provider',
+        modelId: 'test-model-id',
+        doStream: async () => ({
+          stream: new ReadableStream(),
+          response: {
+            headers: { 'x-custom': 'stream-header' },
+          },
+        }),
+      });
+
+      const result = asLanguageModelV3(v2Model);
+
+      const { response } = await result.doStream({
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'test' }] }],
+      });
+
+      expect(response?.headers).toEqual({ 'x-custom': 'stream-header' });
+    });
+  });
+});

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