ai 6.0.33 → 6.0.35

package/src/model/resolve-model.test.ts

@@ -0,0 +1,244 @@
+import { gateway } from '@ai-sdk/gateway';
+import { EmbeddingModelV2, LanguageModelV2 } from '@ai-sdk/provider';
+import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
+
+import { MockEmbeddingModelV3 } from '../test/mock-embedding-model-v3';
+import { MockLanguageModelV3 } from '../test/mock-language-model-v3';
+import { customProvider } from '../registry/custom-provider';
+import { MockImageModelV2 } from '../test/mock-image-model-v2';
+import {
+  resolveEmbeddingModel,
+  resolveImageModel,
+  resolveLanguageModel,
+} from './resolve-model';
+
+describe('resolveLanguageModel', () => {
+  describe('when a language model v3 is provided', () => {
+    it('should return the language model v3', () => {
+      const resolvedModel = resolveLanguageModel(
+        new MockLanguageModelV3({
+          provider: 'test-provider',
+          modelId: 'test-model-id',
+        }),
+      );
+
+      expect(resolvedModel.provider).toBe('test-provider');
+      expect(resolvedModel.modelId).toBe('test-model-id');
+      expect(resolvedModel.specificationVersion).toBe('v3');
+    });
+  });
+
+  describe('when a language model v2 is provided', () => {
+    it('should adapt to v3 and preserve prototype methods', async () => {
+      class TestLanguageModelV2 implements LanguageModelV2 {
+        readonly specificationVersion = 'v2' as const;
+        readonly provider = 'test-provider';
+        readonly modelId = 'test-model-id';
+        readonly supportedUrls = {};
+
+        async doGenerate() {
+          return {
+            content: [],
+            finishReason: 'stop' as const,
+            usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+            warnings: [],
+          };
+        }
+
+        async doStream() {
+          return { stream: new ReadableStream() };
+        }
+      }
+
+      const v2 = new TestLanguageModelV2();
+      const resolvedModel = resolveLanguageModel(v2);
+
+      expect(resolvedModel.provider).toBe('test-provider');
+      expect(resolvedModel.modelId).toBe('test-model-id');
+      expect(resolvedModel.specificationVersion).toBe('v3');
+
+      await resolvedModel.doGenerate({
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'hello' }] }],
+      });
+
+      const { stream } = await resolvedModel.doStream({
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'hello' }] }],
+      });
+      expect(stream).toBeInstanceOf(ReadableStream);
+    });
+  });
+
+  describe('when a string is provided and the global default provider is not set', () => {
+    it('should return a gateway language model', () => {
+      const resolvedModel = resolveLanguageModel('test-model-id');
+
+      expect(resolvedModel.provider).toBe('gateway');
+      expect(resolvedModel.modelId).toBe('test-model-id');
+    });
+  });
+
+  describe('when a string is provided and the global default provider is set', () => {
+    beforeEach(() => {
+      globalThis.AI_SDK_DEFAULT_PROVIDER = customProvider({
+        languageModels: {
+          'test-model-id': new MockLanguageModelV3({
+            provider: 'global-test-provider',
+            modelId: 'actual-test-model-id',
+          }),
+        },
+      });
+    });
+
+    afterEach(() => {
+      delete globalThis.AI_SDK_DEFAULT_PROVIDER;
+    });
+
+    it('should return a language model from the global default provider', () => {
+      const resolvedModel = resolveLanguageModel('test-model-id');
+
+      expect(resolvedModel.provider).toBe('global-test-provider');
+      expect(resolvedModel.modelId).toBe('actual-test-model-id');
+    });
+  });
+});
+
+describe('resolveEmbeddingModel', () => {
+  describe('when an embedding model v2 is provided', () => {
+    it('should adapt to v3 and preserve prototype methods', 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;
+
+        async doEmbed() {
+          return { embeddings: [[0.1, 0.2, 0.3]] };
+        }
+      }
+
+      const v2 = new TestEmbeddingModelV2();
+      const resolvedModel = resolveEmbeddingModel(v2);
+
+      expect(resolvedModel.provider).toBe('test-provider');
+      expect(resolvedModel.modelId).toBe('test-model-id');
+      expect(resolvedModel.specificationVersion).toBe('v3');
+
+      const result = await resolvedModel.doEmbed({ values: ['hello'] });
+      expect(result.embeddings).toHaveLength(1);
+    });
+  });
+
+  describe('when a embedding model v3 is provided', () => {
+    it('should return the embedding model v3', () => {
+      const resolvedModel = resolveEmbeddingModel(
+        new MockEmbeddingModelV3({
+          provider: 'test-provider',
+          modelId: 'test-model-id',
+        }),
+      );
+
+      expect(resolvedModel.provider).toBe('test-provider');
+      expect(resolvedModel.modelId).toBe('test-model-id');
+      expect(resolvedModel.specificationVersion).toBe('v3');
+    });
+  });
+
+  describe('when a string is provided and the global default provider is not set', () => {
+    it('should return a gateway embedding model', () => {
+      const resolvedModel = resolveEmbeddingModel('test-model-id');
+
+      expect(resolvedModel.provider).toBe('gateway');
+      expect(resolvedModel.modelId).toBe('test-model-id');
+    });
+  });
+
+  describe('when a string is provided and the global default provider is set', () => {
+    beforeEach(() => {
+      globalThis.AI_SDK_DEFAULT_PROVIDER = customProvider({
+        embeddingModels: {
+          'test-model-id': new MockEmbeddingModelV3({
+            provider: 'global-test-provider',
+            modelId: 'actual-test-model-id',
+          }),
+        },
+      });
+    });
+
+    afterEach(() => {
+      delete globalThis.AI_SDK_DEFAULT_PROVIDER;
+    });
+
+    it('should return a embedding model from the global default provider', () => {
+      const resolvedModel = resolveEmbeddingModel('test-model-id');
+
+      expect(resolvedModel.provider).toBe('global-test-provider');
+      expect(resolvedModel.modelId).toBe('actual-test-model-id');
+    });
+  });
+});
+
+describe('resolveImageModel', () => {
+  describe('when an image model v2 is provided', () => {
+    it('should return the image model v2', () => {
+      const resolvedModel = resolveImageModel(
+        new MockImageModelV2({
+          provider: 'test-provider',
+          modelId: 'test-model-id',
+        }),
+      );
+
+      expect(resolvedModel.provider).toBe('test-provider');
+      expect(resolvedModel.modelId).toBe('test-model-id');
+    });
+  });
+
+  describe('when a string is provided and the global default provider is not set', () => {
+    it('should return a gateway image model', () => {
+      const resolvedModel = resolveImageModel(
+        new MockImageModelV2({
+          provider: 'gateway',
+          modelId: 'test-model-id',
+        }),
+      );
+
+      const imageModelSpy = vi
+        .spyOn(gateway, 'imageModel')
+        .mockReturnValue(resolvedModel);
+
+      try {
+        const resolvedModel = resolveImageModel('test-model-id');
+
+        expect(resolvedModel).toBe(resolvedModel);
+      } finally {
+        imageModelSpy.mockRestore();
+      }
+    });
+  });
+
+  describe('when a string is provided and the global default provider is set', () => {
+    beforeEach(() => {
+      globalThis.AI_SDK_DEFAULT_PROVIDER = customProvider({
+        imageModels: {
+          'test-model-id': resolveImageModel(
+            new MockImageModelV2({
+              provider: 'global-test-provider',
+              modelId: 'actual-test-model-id',
+            }),
+          ),
+        },
+      });
+    });
+
+    afterEach(() => {
+      delete globalThis.AI_SDK_DEFAULT_PROVIDER;
+    });
+
+    it('should return an image model from the global default provider', () => {
+      const resolvedModel = resolveImageModel('test-model-id');
+
+      expect(resolvedModel.provider).toBe('global-test-provider');
+      expect(resolvedModel.modelId).toBe('actual-test-model-id');
+    });
+  });
+});

package/src/model/resolve-model.ts

@@ -0,0 +1,126 @@
+import { gateway } from '@ai-sdk/gateway';
+import {
+  EmbeddingModelV3,
+  ImageModelV3,
+  LanguageModelV3,
+  ProviderV3,
+  SpeechModelV3,
+  TranscriptionModelV3,
+} from '@ai-sdk/provider';
+import { UnsupportedModelVersionError } from '../error';
+import { EmbeddingModel } from '../types/embedding-model';
+import { LanguageModel } from '../types/language-model';
+import { SpeechModel } from '../types/speech-model';
+import { TranscriptionModel } from '../types/transcription-model';
+import { asEmbeddingModelV3 } from './as-embedding-model-v3';
+import { asImageModelV3 } from './as-image-model-v3';
+import { asLanguageModelV3 } from './as-language-model-v3';
+import { asSpeechModelV3 } from './as-speech-model-v3';
+import { asTranscriptionModelV3 } from './as-transcription-model-v3';
+import { ImageModel } from '../types/image-model';
+
+export function resolveLanguageModel(model: LanguageModel): LanguageModelV3 {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+
+    return asLanguageModelV3(model);
+  }
+
+  return getGlobalProvider().languageModel(model);
+}
+
+export function resolveEmbeddingModel(model: EmbeddingModel): EmbeddingModelV3 {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+
+    return asEmbeddingModelV3(model);
+  }
+
+  return getGlobalProvider().embeddingModel(model);
+}
+
+export function resolveTranscriptionModel(
+  model: TranscriptionModel,
+): TranscriptionModelV3 | undefined {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+    return asTranscriptionModelV3(model);
+  }
+
+  return getGlobalProvider().transcriptionModel?.(model);
+}
+
+export function resolveSpeechModel(
+  model: SpeechModel,
+): SpeechModelV3 | undefined {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+    return asSpeechModelV3(model);
+  }
+
+  return getGlobalProvider().speechModel?.(model);
+}
+
+export function resolveImageModel(model: ImageModel): ImageModelV3 {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+
+    return asImageModelV3(model);
+  }
+
+  return getGlobalProvider().imageModel(model);
+}
+
+function getGlobalProvider(): ProviderV3 {
+  return globalThis.AI_SDK_DEFAULT_PROVIDER ?? gateway;
+}

package/src/prompt/call-settings.ts

@@ -0,0 +1,148 @@
+/**
+Timeout configuration for API calls. Can be specified as:
+- A number representing milliseconds
+- An object with `totalMs` property for the total timeout in milliseconds
+- An object with `stepMs` property for the timeout of each step in milliseconds
+- An object with `chunkMs` property for the timeout between stream chunks (streaming only)
+ */
+export type TimeoutConfiguration =
+  | number
+  | { totalMs?: number; stepMs?: number; chunkMs?: number };
+
+/**
+Extracts the total timeout value in milliseconds from a TimeoutConfiguration.
+
+@param timeout - The timeout configuration.
+@returns The total timeout in milliseconds, or undefined if no timeout is configured.
+ */
+export function getTotalTimeoutMs(
+  timeout: TimeoutConfiguration | undefined,
+): number | undefined {
+  if (timeout == null) {
+    return undefined;
+  }
+  if (typeof timeout === 'number') {
+    return timeout;
+  }
+  return timeout.totalMs;
+}
+
+/**
+Extracts the step timeout value in milliseconds from a TimeoutConfiguration.
+
+@param timeout - The timeout configuration.
+@returns The step timeout in milliseconds, or undefined if no step timeout is configured.
+ */
+export function getStepTimeoutMs(
+  timeout: TimeoutConfiguration | undefined,
+): number | undefined {
+  if (timeout == null || typeof timeout === 'number') {
+    return undefined;
+  }
+  return timeout.stepMs;
+}
+
+/**
+Extracts the chunk timeout value in milliseconds from a TimeoutConfiguration.
+This timeout is for streaming only - it aborts if no new chunk is received within the specified duration.
+
+@param timeout - The timeout configuration.
+@returns The chunk timeout in milliseconds, or undefined if no chunk timeout is configured.
+ */
+export function getChunkTimeoutMs(
+  timeout: TimeoutConfiguration | undefined,
+): number | undefined {
+  if (timeout == null || typeof timeout === 'number') {
+    return undefined;
+  }
+  return timeout.chunkMs;
+}
+
+export type CallSettings = {
+  /**
+Maximum number of tokens to generate.
+   */
+  maxOutputTokens?: number;
+
+  /**
+Temperature setting. The range depends on the provider and model.
+
+It is recommended to set either `temperature` or `topP`, but not both.
+   */
+  temperature?: number;
+
+  /**
+Nucleus sampling. This is a number between 0 and 1.
+
+E.g. 0.1 would mean that only tokens with the top 10% probability mass
+are considered.
+
+It is recommended to set either `temperature` or `topP`, but not both.
+   */
+  topP?: number;
+
+  /**
+Only sample from the top K options for each subsequent token.
+
+Used to remove "long tail" low probability responses.
+Recommended for advanced use cases only. You usually only need to use temperature.
+   */
+  topK?: number;
+
+  /**
+Presence penalty setting. It affects the likelihood of the model to
+repeat information that is already in the prompt.
+
+The presence penalty is a number between -1 (increase repetition)
+and 1 (maximum penalty, decrease repetition). 0 means no penalty.
+   */
+  presencePenalty?: number;
+
+  /**
+Frequency penalty setting. It affects the likelihood of the model
+to repeatedly use the same words or phrases.
+
+The frequency penalty is a number between -1 (increase repetition)
+and 1 (maximum penalty, decrease repetition). 0 means no penalty.
+   */
+  frequencyPenalty?: number;
+
+  /**
+Stop sequences.
+If set, the model will stop generating text when one of the stop sequences is generated.
+Providers may have limits on the number of stop sequences.
+   */
+  stopSequences?: string[];
+
+  /**
+The seed (integer) to use for random sampling. If set and supported
+by the model, calls will generate deterministic results.
+   */
+  seed?: number;
+
+  /**
+Maximum number of retries. Set to 0 to disable retries.
+
+@default 2
+   */
+  maxRetries?: number;
+
+  /**
+Abort signal.
+   */
+  abortSignal?: AbortSignal;
+
+  /**
+Timeout in milliseconds. The call will be aborted if it takes longer
+than the specified timeout. Can be used alongside abortSignal.
+
+Can be specified as a number (milliseconds) or as an object with `totalMs`.
+   */
+  timeout?: TimeoutConfiguration;
+
+  /**
+Additional HTTP headers to be sent with the request.
+Only applicable for HTTP-based providers.
+   */
+  headers?: Record<string, string | undefined>;
+};