ai 6.0.33 → 6.0.34

package/src/prompt/standardize-prompt.ts

@@ -0,0 +1,99 @@
+import { InvalidPromptError } from '@ai-sdk/provider';
+import {
+  ModelMessage,
+  safeValidateTypes,
+  SystemModelMessage,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { modelMessageSchema } from './message';
+import { Prompt } from './prompt';
+import { asArray } from '../util/as-array';
+
+export type StandardizedPrompt = {
+  /**
+   * System message.
+   */
+  system?: string | SystemModelMessage | Array<SystemModelMessage>;
+
+  /**
+   * Messages.
+   */
+  messages: ModelMessage[];
+};
+
+export async function standardizePrompt(
+  prompt: Prompt,
+): Promise<StandardizedPrompt> {
+  if (prompt.prompt == null && prompt.messages == null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: 'prompt or messages must be defined',
+    });
+  }
+
+  if (prompt.prompt != null && prompt.messages != null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: 'prompt and messages cannot be defined at the same time',
+    });
+  }
+
+  // validate that system is a string or a SystemModelMessage
+  if (
+    prompt.system != null &&
+    typeof prompt.system !== 'string' &&
+    !asArray(prompt.system).every(
+      message =>
+        typeof message === 'object' &&
+        message !== null &&
+        'role' in message &&
+        message.role === 'system',
+    )
+  ) {
+    throw new InvalidPromptError({
+      prompt,
+      message:
+        'system must be a string, SystemModelMessage, or array of SystemModelMessage',
+    });
+  }
+
+  let messages: ModelMessage[];
+
+  if (prompt.prompt != null && typeof prompt.prompt === 'string') {
+    messages = [{ role: 'user', content: prompt.prompt }];
+  } else if (prompt.prompt != null && Array.isArray(prompt.prompt)) {
+    messages = prompt.prompt;
+  } else if (prompt.messages != null) {
+    messages = prompt.messages;
+  } else {
+    throw new InvalidPromptError({
+      prompt,
+      message: 'prompt or messages must be defined',
+    });
+  }
+
+  if (messages.length === 0) {
+    throw new InvalidPromptError({
+      prompt,
+      message: 'messages must not be empty',
+    });
+  }
+
+  const validationResult = await safeValidateTypes({
+    value: messages,
+    schema: z.array(modelMessageSchema),
+  });
+
+  if (!validationResult.success) {
+    throw new InvalidPromptError({
+      prompt,
+      message: 'The messages do not match the ModelMessage[] schema.',
+      cause: validationResult.error,
+    });
+  }
+
+  return {
+    messages,
+    system: prompt.system,
+  };
+}

package/src/prompt/wrap-gateway-error.ts

@@ -0,0 +1,29 @@
+import { GatewayAuthenticationError } from '@ai-sdk/gateway';
+import { AISDKError } from '@ai-sdk/provider';
+
+export function wrapGatewayError(error: unknown): unknown {
+  if (!GatewayAuthenticationError.isInstance(error)) return error;
+
+  const isProductionEnv = process?.env.NODE_ENV === 'production';
+  const moreInfoURL = 'https://ai-sdk.dev/unauthenticated-ai-gateway';
+
+  if (isProductionEnv) {
+    return new AISDKError({
+      name: 'GatewayError',
+      message: `Unauthenticated. Configure AI_GATEWAY_API_KEY or use a provider module. Learn more: ${moreInfoURL}`,
+    });
+  }
+
+  return Object.assign(
+    new Error(`\u001b[1m\u001b[31mUnauthenticated request to AI Gateway.\u001b[0m
+
+To authenticate, set the \u001b[33mAI_GATEWAY_API_KEY\u001b[0m environment variable with your API key.
+
+Alternatively, you can use a provider module instead of the AI Gateway.
+
+Learn more: \u001b[34m${moreInfoURL}\u001b[0m
+
+`),
+    { name: 'GatewayAuthenticationError' },
+  );
+}

package/src/registry/custom-provider.test.ts

@@ -0,0 +1,211 @@
+import { NoSuchModelError } from '@ai-sdk/provider';
+import { describe, expect, it, vi } from 'vitest';
+import { MockEmbeddingModelV3 } from '../test/mock-embedding-model-v3';
+import { MockImageModelV3 } from '../test/mock-image-model-v3';
+import { MockLanguageModelV3 } from '../test/mock-language-model-v3';
+import { MockRerankingModelV3 } from '../test/mock-reranking-model-v3';
+import { MockSpeechModelV3 } from '../test/mock-speech-model-v3';
+import { MockTranscriptionModelV3 } from '../test/mock-transcription-model-v3';
+import { customProvider } from './custom-provider';
+
+const mockLanguageModel = new MockLanguageModelV3();
+const mockEmbeddingModel = new MockEmbeddingModelV3();
+const mockRerankingModel = new MockRerankingModelV3();
+const mockFallbackProvider = {
+  specificationVersion: 'v3' as const,
+  languageModel: vi.fn(),
+  embeddingModel: vi.fn(),
+  imageModel: vi.fn(),
+  transcriptionModel: vi.fn(),
+  speechModel: vi.fn(),
+  rerankingModel: vi.fn(),
+};
+
+describe('languageModel', () => {
+  it('should return the language model if it exists', () => {
+    const provider = customProvider({
+      languageModels: { 'test-model': mockLanguageModel },
+    });
+
+    expect(provider.languageModel('test-model')).toBe(mockLanguageModel);
+  });
+
+  it('should use fallback provider if model not found and fallback exists', () => {
+    mockFallbackProvider.languageModel.mockReturnValue(mockLanguageModel);
+
+    const provider = customProvider({
+      fallbackProvider: mockFallbackProvider,
+    });
+
+    expect(provider.languageModel('test-model')).toBe(mockLanguageModel);
+    expect(mockFallbackProvider.languageModel).toHaveBeenCalledWith(
+      'test-model',
+    );
+  });
+
+  it('should throw NoSuchModelError if model not found and no fallback', () => {
+    const provider = customProvider({});
+    expect(() => provider.languageModel('test-model')).toThrow(
+      NoSuchModelError,
+    );
+  });
+});
+
+describe('embeddingModel', () => {
+  it('should return the embedding model if it exists', () => {
+    const provider = customProvider({
+      embeddingModels: { 'test-model': mockEmbeddingModel },
+    });
+
+    expect(provider.embeddingModel('test-model')).toBe(mockEmbeddingModel);
+  });
+
+  it('should use fallback provider if model not found and fallback exists', () => {
+    mockFallbackProvider.embeddingModel.mockReturnValue(mockEmbeddingModel);
+
+    const provider = customProvider({
+      fallbackProvider: mockFallbackProvider,
+    });
+
+    expect(provider.embeddingModel('test-model')).toBe(mockEmbeddingModel);
+    expect(mockFallbackProvider.embeddingModel).toHaveBeenCalledWith(
+      'test-model',
+    );
+  });
+
+  it('should throw NoSuchModelError if model not found and no fallback', () => {
+    const provider = customProvider({});
+
+    expect(() => provider.embeddingModel('test-model')).toThrow(
+      NoSuchModelError,
+    );
+  });
+});
+
+describe('imageModel', () => {
+  const mockImageModel = new MockImageModelV3();
+
+  it('should return the image model if it exists', () => {
+    const provider = customProvider({
+      imageModels: { 'test-model': mockImageModel },
+    });
+
+    expect(provider.imageModel('test-model')).toBe(mockImageModel);
+  });
+
+  it('should use fallback provider if model not found and fallback exists', () => {
+    mockFallbackProvider.imageModel = vi.fn().mockReturnValue(mockImageModel);
+
+    const provider = customProvider({
+      fallbackProvider: mockFallbackProvider,
+    });
+
+    expect(provider.imageModel('test-model')).toBe(mockImageModel);
+    expect(mockFallbackProvider.imageModel).toHaveBeenCalledWith('test-model');
+  });
+
+  it('should throw NoSuchModelError if model not found and no fallback', () => {
+    const provider = customProvider({});
+
+    expect(() => provider.imageModel('test-model')).toThrow(NoSuchModelError);
+  });
+});
+
+describe('transcriptionModel', () => {
+  const mockTranscriptionModel = new MockTranscriptionModelV3();
+
+  it('should return the transcription model if it exists', () => {
+    const provider = customProvider({
+      transcriptionModels: { 'test-model': mockTranscriptionModel },
+    });
+
+    expect(provider.transcriptionModel('test-model')).toBe(
+      mockTranscriptionModel,
+    );
+  });
+
+  it('should use fallback provider if model not found and fallback exists', () => {
+    mockFallbackProvider.transcriptionModel = vi
+      .fn()
+      .mockReturnValue(mockTranscriptionModel);
+
+    const provider = customProvider({
+      fallbackProvider: mockFallbackProvider,
+    });
+
+    expect(provider.transcriptionModel('test-model')).toBe(
+      mockTranscriptionModel,
+    );
+    expect(mockFallbackProvider.transcriptionModel).toHaveBeenCalledWith(
+      'test-model',
+    );
+  });
+
+  it('should throw NoSuchModelError if model not found and no fallback', () => {
+    const provider = customProvider({});
+
+    expect(() => provider.transcriptionModel('test-model')).toThrow(
+      NoSuchModelError,
+    );
+  });
+});
+
+describe('speechModel', () => {
+  const mockSpeechModel = new MockSpeechModelV3();
+
+  it('should return the speech model if it exists', () => {
+    const provider = customProvider({
+      speechModels: { 'test-model': mockSpeechModel },
+    });
+
+    expect(provider.speechModel('test-model')).toBe(mockSpeechModel);
+  });
+
+  it('should use fallback provider if model not found and fallback exists', () => {
+    mockFallbackProvider.speechModel = vi.fn().mockReturnValue(mockSpeechModel);
+
+    const provider = customProvider({
+      fallbackProvider: mockFallbackProvider,
+    });
+
+    expect(provider.speechModel('test-model')).toBe(mockSpeechModel);
+    expect(mockFallbackProvider.speechModel).toHaveBeenCalledWith('test-model');
+  });
+
+  it('should throw NoSuchModelError if model not found and no fallback', () => {
+    const provider = customProvider({});
+
+    expect(() => provider.speechModel('test-model')).toThrow(NoSuchModelError);
+  });
+});
+
+describe('rerankingModel', () => {
+  it('should return the reranking model if it exists', () => {
+    const provider = customProvider({
+      rerankingModels: { 'test-model': mockRerankingModel },
+    });
+
+    expect(provider.rerankingModel('test-model')).toBe(mockRerankingModel);
+  });
+
+  it('should use fallback provider if model not found and fallback exists', () => {
+    mockFallbackProvider.rerankingModel.mockReturnValue(mockRerankingModel);
+
+    const provider = customProvider({
+      fallbackProvider: mockFallbackProvider,
+    });
+
+    expect(provider.rerankingModel('test-model')).toBe(mockRerankingModel);
+    expect(mockFallbackProvider.rerankingModel).toHaveBeenCalledWith(
+      'test-model',
+    );
+  });
+
+  it('should throw NoSuchModelError if model not found and no fallback', () => {
+    const provider = customProvider({});
+
+    expect(() => provider.rerankingModel('test-model')).toThrow(
+      NoSuchModelError,
+    );
+  });
+});

package/src/registry/custom-provider.ts

@@ -0,0 +1,155 @@
+import {
+  EmbeddingModelV3,
+  ImageModelV3,
+  LanguageModelV3,
+  NoSuchModelError,
+  ProviderV2,
+  ProviderV3,
+  RerankingModelV3,
+  SpeechModelV3,
+  TranscriptionModelV3,
+} from '@ai-sdk/provider';
+import { asProviderV3 } from '../model/as-provider-v3';
+
+/**
+ * Creates a custom provider with specified language models, text embedding models, image models, transcription models, speech models, and an optional fallback provider.
+ *
+ * @param {Object} options - The options for creating the custom provider.
+ * @param {Record<string, LanguageModel>} [options.languageModels] - A record of language models, where keys are model IDs and values are LanguageModel instances.
+ * @param {Record<string, EmbeddingModel>} [options.embeddingModels] - A record of text embedding models, where keys are model IDs and values are EmbeddingModel instances.
+ * @param {Record<string, ImageModel>} [options.imageModels] - A record of image models, where keys are model IDs and values are ImageModel instances.
+ * @param {Record<string, TranscriptionModel>} [options.transcriptionModels] - A record of transcription models, where keys are model IDs and values are TranscriptionModel instances.
+ * @param {Record<string, SpeechModel>} [options.speechModels] - A record of speech models, where keys are model IDs and values are SpeechModel instances.
+ * @param {Record<string, RerankingModel>} [options.rerankingModels] - A record of reranking models, where keys are model IDs and values are RerankingModel instances.
+ * @param {Provider} [options.fallbackProvider] - An optional fallback provider to use when a requested model is not found in the custom provider.
+ * @returns {Provider} A Provider object with languageModel, embeddingModel, imageModel, transcriptionModel, and speechModel methods.
+ *
+ * @throws {NoSuchModelError} Throws when a requested model is not found and no fallback provider is available.
+ */
+export function customProvider<
+  LANGUAGE_MODELS extends Record<string, LanguageModelV3>,
+  EMBEDDING_MODELS extends Record<string, EmbeddingModelV3>,
+  IMAGE_MODELS extends Record<string, ImageModelV3>,
+  TRANSCRIPTION_MODELS extends Record<string, TranscriptionModelV3>,
+  SPEECH_MODELS extends Record<string, SpeechModelV3>,
+  RERANKING_MODELS extends Record<string, RerankingModelV3>,
+>({
+  languageModels,
+  embeddingModels,
+  imageModels,
+  transcriptionModels,
+  speechModels,
+  rerankingModels,
+  fallbackProvider: fallbackProviderArg,
+}: {
+  languageModels?: LANGUAGE_MODELS;
+  embeddingModels?: EMBEDDING_MODELS;
+  imageModels?: IMAGE_MODELS;
+  transcriptionModels?: TRANSCRIPTION_MODELS;
+  speechModels?: SPEECH_MODELS;
+  rerankingModels?: RERANKING_MODELS;
+  fallbackProvider?: ProviderV3 | ProviderV2;
+}): ProviderV3 & {
+  languageModel(modelId: ExtractModelId<LANGUAGE_MODELS>): LanguageModelV3;
+  embeddingModel(modelId: ExtractModelId<EMBEDDING_MODELS>): EmbeddingModelV3;
+  imageModel(modelId: ExtractModelId<IMAGE_MODELS>): ImageModelV3;
+  transcriptionModel(
+    modelId: ExtractModelId<TRANSCRIPTION_MODELS>,
+  ): TranscriptionModelV3;
+  rerankingModel(modelId: ExtractModelId<RERANKING_MODELS>): RerankingModelV3;
+  speechModel(modelId: ExtractModelId<SPEECH_MODELS>): SpeechModelV3;
+} {
+  const fallbackProvider = fallbackProviderArg
+    ? asProviderV3(fallbackProviderArg)
+    : undefined;
+
+  return {
+    specificationVersion: 'v3',
+    languageModel(modelId: ExtractModelId<LANGUAGE_MODELS>): LanguageModelV3 {
+      if (languageModels != null && modelId in languageModels) {
+        return languageModels[modelId];
+      }
+
+      if (fallbackProvider) {
+        return (fallbackProvider as ProviderV3).languageModel(modelId);
+      }
+
+      throw new NoSuchModelError({ modelId, modelType: 'languageModel' });
+    },
+
+    embeddingModel(
+      modelId: ExtractModelId<EMBEDDING_MODELS>,
+    ): EmbeddingModelV3 {
+      if (embeddingModels != null && modelId in embeddingModels) {
+        return embeddingModels[modelId];
+      }
+
+      if (fallbackProvider) {
+        return (fallbackProvider as ProviderV3).embeddingModel(modelId);
+      }
+
+      throw new NoSuchModelError({ modelId, modelType: 'embeddingModel' });
+    },
+
+    imageModel(modelId: ExtractModelId<IMAGE_MODELS>): ImageModelV3 {
+      if (imageModels != null && modelId in imageModels) {
+        return imageModels[modelId];
+      }
+
+      if (fallbackProvider?.imageModel) {
+        return (fallbackProvider as ProviderV3).imageModel(modelId);
+      }
+
+      throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
+    },
+
+    transcriptionModel(
+      modelId: ExtractModelId<TRANSCRIPTION_MODELS>,
+    ): TranscriptionModelV3 {
+      if (transcriptionModels != null && modelId in transcriptionModels) {
+        return transcriptionModels[modelId];
+      }
+
+      if (fallbackProvider?.transcriptionModel) {
+        return (fallbackProvider as ProviderV3).transcriptionModel!(modelId);
+      }
+
+      throw new NoSuchModelError({ modelId, modelType: 'transcriptionModel' });
+    },
+
+    speechModel(modelId: ExtractModelId<SPEECH_MODELS>): SpeechModelV3 {
+      if (speechModels != null && modelId in speechModels) {
+        return speechModels[modelId];
+      }
+
+      if (fallbackProvider?.speechModel) {
+        return (fallbackProvider as ProviderV3).speechModel!(modelId);
+      }
+
+      throw new NoSuchModelError({ modelId, modelType: 'speechModel' });
+    },
+    rerankingModel(
+      modelId: ExtractModelId<RERANKING_MODELS>,
+    ): RerankingModelV3 {
+      if (rerankingModels != null && modelId in rerankingModels) {
+        return rerankingModels[modelId];
+      }
+
+      if (fallbackProvider?.rerankingModel) {
+        return fallbackProvider.rerankingModel(modelId);
+      }
+
+      throw new NoSuchModelError({ modelId, modelType: 'rerankingModel' });
+    },
+  };
+}
+
+/**
+ * @deprecated Use `customProvider` instead.
+ */
+export const experimental_customProvider = customProvider;
+
+type ExtractModelId<MODELS extends Record<string, unknown>> = Extract<
+  keyof MODELS,
+  string
+>;

package/src/registry/index.ts

@@ -0,0 +1,7 @@
+export { customProvider, experimental_customProvider } from './custom-provider';
+export { NoSuchProviderError } from './no-such-provider-error';
+export {
+  createProviderRegistry,
+  experimental_createProviderRegistry,
+} from './provider-registry';
+export type { ProviderRegistryProvider } from './provider-registry';

package/src/registry/no-such-provider-error.ts

@@ -0,0 +1,41 @@
+import { AISDKError, NoSuchModelError } from '@ai-sdk/provider';
+
+const name = 'AI_NoSuchProviderError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class NoSuchProviderError extends NoSuchModelError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly providerId: string;
+  readonly availableProviders: string[];
+
+  constructor({
+    modelId,
+    modelType,
+    providerId,
+    availableProviders,
+    message = `No such provider: ${providerId} (available providers: ${availableProviders.join()})`,
+  }: {
+    modelId: string;
+    modelType:
+      | 'languageModel'
+      | 'embeddingModel'
+      | 'imageModel'
+      | 'transcriptionModel'
+      | 'speechModel'
+      | 'rerankingModel';
+    providerId: string;
+    availableProviders: string[];
+    message?: string;
+  }) {
+    super({ errorName: name, modelId, modelType, message });
+
+    this.providerId = providerId;
+    this.availableProviders = availableProviders;
+  }
+
+  static isInstance(error: unknown): error is NoSuchProviderError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}