@ai-sdk/provider 3.0.2 → 3.0.4

package/src/errors/invalid-argument-error.ts

@@ -0,0 +1,32 @@
+import { AISDKError } from './ai-sdk-error';
+
+const name = 'AI_InvalidArgumentError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+/**
+ * A function argument is invalid.
+ */
+export class InvalidArgumentError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly argument: string;
+
+  constructor({
+    message,
+    cause,
+    argument,
+  }: {
+    argument: string;
+    message: string;
+    cause?: unknown;
+  }) {
+    super({ name, message, cause });
+
+    this.argument = argument;
+  }
+
+  static isInstance(error: unknown): error is InvalidArgumentError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/errors/invalid-prompt-error.ts

@@ -0,0 +1,33 @@
+import { AISDKError } from './ai-sdk-error';
+
+const name = 'AI_InvalidPromptError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+/**
+ * A prompt is invalid. This error should be thrown by providers when they cannot
+ * process a prompt.
+ */
+export class InvalidPromptError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly prompt: unknown;
+
+  constructor({
+    prompt,
+    message,
+    cause,
+  }: {
+    prompt: unknown;
+    message: string;
+    cause?: unknown;
+  }) {
+    super({ name, message: `Invalid prompt: ${message}`, cause });
+
+    this.prompt = prompt;
+  }
+
+  static isInstance(error: unknown): error is InvalidPromptError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/errors/invalid-response-data-error.ts

@@ -0,0 +1,31 @@
+import { AISDKError } from './ai-sdk-error';
+
+const name = 'AI_InvalidResponseDataError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+/**
+ * Server returned a response with invalid data content.
+ * This should be thrown by providers when they cannot parse the response from the API.
+ */
+export class InvalidResponseDataError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly data: unknown;
+
+  constructor({
+    data,
+    message = `Invalid response data: ${JSON.stringify(data)}.`,
+  }: {
+    data: unknown;
+    message?: string;
+  }) {
+    super({ name, message });
+
+    this.data = data;
+  }
+
+  static isInstance(error: unknown): error is InvalidResponseDataError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/errors/json-parse-error.ts

@@ -0,0 +1,29 @@
+import { AISDKError } from './ai-sdk-error';
+import { getErrorMessage } from './get-error-message';
+
+const name = 'AI_JSONParseError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class JSONParseError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly text: string;
+
+  constructor({ text, cause }: { text: string; cause: unknown }) {
+    super({
+      name,
+      message:
+        `JSON parsing failed: ` +
+        `Text: ${text}.\n` +
+        `Error message: ${getErrorMessage(cause)}`,
+      cause,
+    });
+
+    this.text = text;
+  }
+
+  static isInstance(error: unknown): error is JSONParseError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/errors/load-api-key-error.ts

@@ -0,0 +1,17 @@
+import { AISDKError } from './ai-sdk-error';
+
+const name = 'AI_LoadAPIKeyError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class LoadAPIKeyError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  constructor({ message }: { message: string }) {
+    super({ name, message });
+  }
+
+  static isInstance(error: unknown): error is LoadAPIKeyError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/errors/load-setting-error.ts

@@ -0,0 +1,17 @@
+import { AISDKError } from './ai-sdk-error';
+
+const name = 'AI_LoadSettingError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class LoadSettingError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  constructor({ message }: { message: string }) {
+    super({ name, message });
+  }
+
+  static isInstance(error: unknown): error is LoadSettingError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/errors/no-content-generated-error.ts

@@ -0,0 +1,22 @@
+import { AISDKError } from './ai-sdk-error';
+
+const name = 'AI_NoContentGeneratedError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+/**
+Thrown when the AI provider fails to generate any content.
+ */
+export class NoContentGeneratedError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  constructor({
+    message = 'No content generated.',
+  }: { message?: string } = {}) {
+    super({ name, message });
+  }
+
+  static isInstance(error: unknown): error is NoContentGeneratedError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/errors/no-such-model-error.ts

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

package/src/errors/too-many-embedding-values-for-call-error.ts

@@ -0,0 +1,40 @@
+import { AISDKError } from './ai-sdk-error';
+
+const name = 'AI_TooManyEmbeddingValuesForCallError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class TooManyEmbeddingValuesForCallError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly provider: string;
+  readonly modelId: string;
+  readonly maxEmbeddingsPerCall: number;
+  readonly values: Array<unknown>;
+
+  constructor(options: {
+    provider: string;
+    modelId: string;
+    maxEmbeddingsPerCall: number;
+    values: Array<unknown>;
+  }) {
+    super({
+      name,
+      message:
+        `Too many values for a single embedding call. ` +
+        `The ${options.provider} model "${options.modelId}" can only embed up to ` +
+        `${options.maxEmbeddingsPerCall} values per call, but ${options.values.length} values were provided.`,
+    });
+
+    this.provider = options.provider;
+    this.modelId = options.modelId;
+    this.maxEmbeddingsPerCall = options.maxEmbeddingsPerCall;
+    this.values = options.values;
+  }
+
+  static isInstance(
+    error: unknown,
+  ): error is TooManyEmbeddingValuesForCallError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/errors/type-validation-error.ts

@@ -0,0 +1,51 @@
+import { AISDKError } from './ai-sdk-error';
+import { getErrorMessage } from './get-error-message';
+
+const name = 'AI_TypeValidationError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class TypeValidationError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly value: unknown;
+
+  constructor({ value, cause }: { value: unknown; cause: unknown }) {
+    super({
+      name,
+      message:
+        `Type validation failed: ` +
+        `Value: ${JSON.stringify(value)}.\n` +
+        `Error message: ${getErrorMessage(cause)}`,
+      cause,
+    });
+
+    this.value = value;
+  }
+
+  static isInstance(error: unknown): error is TypeValidationError {
+    return AISDKError.hasMarker(error, marker);
+  }
+
+  /**
+   * Wraps an error into a TypeValidationError.
+   * If the cause is already a TypeValidationError with the same value, it returns the cause.
+   * Otherwise, it creates a new TypeValidationError.
+   *
+   * @param {Object} params - The parameters for wrapping the error.
+   * @param {unknown} params.value - The value that failed validation.
+   * @param {unknown} params.cause - The original error or cause of the validation failure.
+   * @returns {TypeValidationError} A TypeValidationError instance.
+   */
+  static wrap({
+    value,
+    cause,
+  }: {
+    value: unknown;
+    cause: unknown;
+  }): TypeValidationError {
+    return TypeValidationError.isInstance(cause) && cause.value === value
+      ? cause
+      : new TypeValidationError({ value, cause });
+  }
+}

package/src/errors/unsupported-functionality-error.ts

@@ -0,0 +1,26 @@
+import { AISDKError } from './ai-sdk-error';
+
+const name = 'AI_UnsupportedFunctionalityError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class UnsupportedFunctionalityError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly functionality: string;
+
+  constructor({
+    functionality,
+    message = `'${functionality}' functionality not supported.`,
+  }: {
+    functionality: string;
+    message?: string;
+  }) {
+    super({ name, message });
+    this.functionality = functionality;
+  }
+
+  static isInstance(error: unknown): error is UnsupportedFunctionalityError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/image-model/index.ts

@@ -0,0 +1,2 @@
+export * from './v3/index';
+export * from './v2/index';

package/src/image-model/v2/image-model-v2-call-options.ts

@@ -0,0 +1,60 @@
+import { SharedV2ProviderOptions } from '../../shared';
+
+export type ImageModelV2CallOptions = {
+  /**
+Prompt for the image generation.
+     */
+  prompt: string;
+
+  /**
+Number of images to generate.
+ */
+  n: number;
+
+  /**
+Size of the images to generate.
+Must have the format `{width}x{height}`.
+`undefined` will use the provider's default size.
+ */
+  size: `${number}x${number}` | undefined;
+
+  /**
+Aspect ratio of the images to generate.
+Must have the format `{width}:{height}`.
+`undefined` will use the provider's default aspect ratio.
+ */
+  aspectRatio: `${number}:${number}` | undefined;
+
+  /**
+Seed for the image generation.
+`undefined` will use the provider's default seed.
+ */
+  seed: number | undefined;
+
+  /**
+Additional provider-specific options that are passed through to the provider
+as body parameters.
+
+The outer record is keyed by the provider name, and the inner
+record is keyed by the provider-specific metadata key.
+```ts
+{
+  "openai": {
+    "style": "vivid"
+  }
+}
+```
+ */
+  providerOptions: SharedV2ProviderOptions;
+
+  /**
+Abort signal for cancelling the operation.
+ */
+  abortSignal?: AbortSignal;
+
+  /**
+Additional HTTP headers to be sent with the request.
+Only applicable for HTTP-based providers.
+ */
+  headers?: Record<string, string | undefined>;
+};

package/src/image-model/v2/image-model-v2-call-warning.ts

@@ -0,0 +1,16 @@
+import { ImageModelV2CallOptions } from './image-model-v2-call-options';
+
+/**
+Warning from the model provider for this call. The call will proceed, but e.g.
+some settings might not be supported, which can lead to suboptimal results.
+ */
+export type ImageModelV2CallWarning =
+  | {
+      type: 'unsupported-setting';
+      setting: keyof ImageModelV2CallOptions;
+      details?: string;
+    }
+  | {
+      type: 'other';
+      message: string;
+    };

package/src/image-model/v2/image-model-v2.ts

@@ -0,0 +1,104 @@
+import { JSONArray, JSONValue } from '../../json-value';
+import { ImageModelV2CallOptions } from './image-model-v2-call-options';
+import { ImageModelV2CallWarning } from './image-model-v2-call-warning';
+
+export type ImageModelV2ProviderMetadata = Record<
+  string,
+  {
+    images: JSONArray;
+  } & JSONValue
+>;
+
+type GetMaxImagesPerCallFunction = (options: {
+  modelId: string;
+}) => PromiseLike<number | undefined> | number | undefined;
+
+/**
+Image generation model specification version 2.
+ */
+export type ImageModelV2 = {
+  /**
+The image model must specify which image model interface
+version it implements. This will allow us to evolve the image
+model interface and retain backwards compatibility. The different
+implementation versions can be handled as a discriminated union
+on our side.
+   */
+  readonly specificationVersion: 'v2';
+
+  /**
+Name of the provider for logging purposes.
+   */
+  readonly provider: string;
+
+  /**
+Provider-specific model ID for logging purposes.
+   */
+  readonly modelId: string;
+
+  /**
+Limit of how many images can be generated in a single API call.
+Can be set to a number for a fixed limit, to undefined to use
+the global limit, or a function that returns a number or undefined, 
+optionally as a promise. 
+   */
+  readonly maxImagesPerCall: number | undefined | GetMaxImagesPerCallFunction;
+
+  /**
+Generates an array of images.
+   */
+  doGenerate(options: ImageModelV2CallOptions): PromiseLike<{
+    /**
+Generated images as base64 encoded strings or binary data.
+The images should be returned without any unnecessary conversion.
+If the API returns base64 encoded strings, the images should be returned
+as base64 encoded strings. If the API returns binary data, the images should
+be returned as binary data.
+     */
+    images: Array<string> | Array<Uint8Array>;
+
+    /**
+Warnings for the call, e.g. unsupported settings.
+     */
+    warnings: Array<ImageModelV2CallWarning>;
+
+    /**
+Additional provider-specific metadata. They are passed through
+from the provider to the AI SDK and enable provider-specific
+results that can be fully encapsulated in the provider.
+
+The outer record is keyed by the provider name, and the inner
+record is provider-specific metadata. It always includes an
+`images` key with image-specific metadata
+
+```ts
+{
+  "openai": {
+    "images": ["revisedPrompt": "Revised prompt here."]
+  }
+}
+```
+      */
+    providerMetadata?: ImageModelV2ProviderMetadata;
+
+    /**
+Response information for telemetry and debugging purposes.
+     */
+    response: {
+      /**
+Timestamp for the start of the generated response.
+      */
+      timestamp: Date;
+
+      /**
+The ID of the response model that was used to generate the response.
+      */
+      modelId: string;
+
+      /**
+Response headers.
+      */
+      headers: Record<string, string> | undefined;
+    };
+  }>;
+};

package/src/image-model/v2/index.ts

@@ -0,0 +1,6 @@
+export type {
+  ImageModelV2,
+  ImageModelV2ProviderMetadata,
+} from './image-model-v2';
+export type { ImageModelV2CallOptions } from './image-model-v2-call-options';
+export type { ImageModelV2CallWarning } from './image-model-v2-call-warning';

package/src/image-model/v3/image-model-v3-call-options.ts

@@ -0,0 +1,74 @@
+import { SharedV3ProviderOptions } from '../../shared';
+import { ImageModelV3File } from './image-model-v3-file';
+
+export type ImageModelV3CallOptions = {
+  /**
+   * Prompt for the image generation. Some operations, like upscaling, may not require a prompt.
+   */
+  prompt: string | undefined;
+
+  /**
+   * Number of images to generate.
+   */
+  n: number;
+
+  /**
+   * Size of the images to generate.
+   * Must have the format `{width}x{height}`.
+   * `undefined` will use the provider's default size.
+   */
+  size: `${number}x${number}` | undefined;
+
+  /**
+   * Aspect ratio of the images to generate.
+   * Must have the format `{width}:{height}`.
+   * `undefined` will use the provider's default aspect ratio.
+   */
+  aspectRatio: `${number}:${number}` | undefined;
+
+  /**
+   * Seed for the image generation.
+   * `undefined` will use the provider's default seed.
+   */
+  seed: number | undefined;
+
+  /**
+   * Array of images for image editing or variation generation.
+   * The images should be provided as base64 encoded strings or binary data.
+   */
+  files: ImageModelV3File[] | undefined;
+
+  /**
+   * Mask image for inpainting operations.
+   * The mask should be provided as base64 encoded strings or binary data.
+   */
+  mask: ImageModelV3File | undefined;
+
+  /**
+   * Additional provider-specific options that are passed through to the provider
+   * as body parameters.
+   *
+   * The outer record is keyed by the provider name, and the inner
+   * record is keyed by the provider-specific metadata key.
+   *
+   * ```ts
+   * {
+   *   "openai": {
+   *     "style": "vivid"
+   *   }
+   * }
+   * ```
+   */
+  providerOptions: SharedV3ProviderOptions;
+
+  /**
+   * Abort signal for cancelling the operation.
+   */
+  abortSignal?: AbortSignal;
+
+  /**
+   * Additional HTTP headers to be sent with the request.
+   * Only applicable for HTTP-based providers.
+   */
+  headers?: Record<string, string | undefined>;
+};

package/src/image-model/v3/image-model-v3-file.ts

@@ -0,0 +1,44 @@
+import { SharedV3ProviderMetadata } from '../../shared';
+
+/**
+ * An image file that can be used for image editing or variation generation.
+ */
+export type ImageModelV3File =
+  | {
+      type: 'file';
+
+      /**
+       * The IANA media type of the file, e.g. `image/png`. Any string is supported.
+       *
+       * @see https://www.iana.org/assignments/media-types/media-types.xhtml
+       */
+      mediaType: string;
+
+      /**
+       * Generated file data as base64 encoded strings or binary data.
+       *
+       * The file data should be returned without any unnecessary conversion.
+       * If the API returns base64 encoded strings, the file data should be returned
+       * as base64 encoded strings. If the API returns binary data, the file data should
+       * be returned as binary data.
+       */
+      data: string | Uint8Array;
+
+      /**
+       * Optional provider-specific metadata for the file part.
+       */
+      providerOptions?: SharedV3ProviderMetadata;
+    }
+  | {
+      type: 'url';
+
+      /**
+       * The URL of the image file.
+       */
+      url: string;
+
+      /**
+       * Optional provider-specific metadata for the file part.
+       */
+      providerOptions?: SharedV3ProviderMetadata;
+    };

package/src/image-model/v3/image-model-v3-usage.ts

@@ -0,0 +1,19 @@
+/**
+Usage information for an image model call.
+ */
+export type ImageModelV3Usage = {
+  /**
+  The number of input (prompt) tokens used.
+   */
+  inputTokens: number | undefined;
+
+  /**
+  The number of output tokens used, if reported by the provider.
+   */
+  outputTokens: number | undefined;
+
+  /**
+  The total number of tokens as reported by the provider.
+   */
+  totalTokens: number | undefined;
+};