@fairyhunter13/ai-sdk 6.0.116-fork.1

package/src/error/no-transcript-generated-error.ts

@@ -0,0 +1,30 @@
+import { AISDKError } from '@ai-sdk/provider';
+import { TranscriptionModelResponseMetadata } from '../types/transcription-model-response-metadata';
+
+const name = 'AI_NoTranscriptGeneratedError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+/**
+ * Error that is thrown when no transcript was generated.
+ */
+export class NoTranscriptGeneratedError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly responses: Array<TranscriptionModelResponseMetadata>;
+
+  constructor(options: {
+    responses: Array<TranscriptionModelResponseMetadata>;
+  }) {
+    super({
+      name,
+      message: 'No transcript generated.',
+    });
+
+    this.responses = options.responses;
+  }
+
+  static isInstance(error: unknown): error is NoTranscriptGeneratedError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/error/no-video-generated-error.ts

@@ -0,0 +1,57 @@
+import { AISDKError } from '@ai-sdk/provider';
+import { VideoModelResponseMetadata } from '../types/video-model-response-metadata';
+
+const name = 'AI_NoVideoGeneratedError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class NoVideoGeneratedError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly responses: Array<VideoModelResponseMetadata>;
+
+  constructor({
+    message = 'No video generated.',
+    cause,
+    responses,
+  }: {
+    message?: string;
+    cause?: unknown;
+    responses: Array<VideoModelResponseMetadata>;
+  }) {
+    super({ name, message, cause });
+
+    this.responses = responses;
+  }
+
+  static isInstance(error: unknown): error is NoVideoGeneratedError {
+    return AISDKError.hasMarker(error, marker);
+  }
+
+  /**
+   * @deprecated use `isInstance` instead
+   */
+  static isNoVideoGeneratedError(
+    error: unknown,
+  ): error is NoVideoGeneratedError {
+    return error instanceof Error &&
+      error.name === name &&
+      typeof (error as NoVideoGeneratedError).responses !== 'undefined'
+      ? true
+      : false;
+  }
+
+  /**
+   * @deprecated Do not use this method. It will be removed in the next major version.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      stack: this.stack,
+
+      cause: this.cause,
+      responses: this.responses,
+    };
+  }
+}

package/src/error/tool-call-not-found-for-approval-error.ts

@@ -0,0 +1,32 @@
+import { AISDKError } from '@ai-sdk/provider';
+
+const name = 'AI_ToolCallNotFoundForApprovalError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class ToolCallNotFoundForApprovalError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly toolCallId: string;
+  readonly approvalId: string;
+
+  constructor({
+    toolCallId,
+    approvalId,
+  }: {
+    toolCallId: string;
+    approvalId: string;
+  }) {
+    super({
+      name,
+      message: `Tool call "${toolCallId}" not found for approval request "${approvalId}".`,
+    });
+
+    this.toolCallId = toolCallId;
+    this.approvalId = approvalId;
+  }
+
+  static isInstance(error: unknown): error is ToolCallNotFoundForApprovalError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/error/tool-call-repair-error.ts

@@ -0,0 +1,30 @@
+import { AISDKError, getErrorMessage } from '@ai-sdk/provider';
+import { InvalidToolInputError } from './invalid-tool-input-error';
+import { NoSuchToolError } from './no-such-tool-error';
+
+const name = 'AI_ToolCallRepairError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class ToolCallRepairError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly originalError: NoSuchToolError | InvalidToolInputError;
+
+  constructor({
+    cause,
+    originalError,
+    message = `Error repairing tool call: ${getErrorMessage(cause)}`,
+  }: {
+    message?: string;
+    cause: unknown;
+    originalError: NoSuchToolError | InvalidToolInputError;
+  }) {
+    super({ name, message, cause });
+    this.originalError = originalError;
+  }
+
+  static isInstance(error: unknown): error is ToolCallRepairError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/error/ui-message-stream-error.ts

@@ -0,0 +1,48 @@
+import { AISDKError } from '@ai-sdk/provider';
+
+const name = 'AI_UIMessageStreamError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+/**
+ * Error thrown when a UI message stream contains invalid or out-of-sequence chunks.
+ *
+ * This typically occurs when:
+ * - A delta chunk is received without a corresponding start chunk
+ * - An end chunk is received without a corresponding start chunk
+ * - A tool invocation is not found for the given toolCallId
+ *
+ * @see https://ai-sdk.dev/docs/reference/ai-sdk-errors/ai-ui-message-stream-error
+ */
+export class UIMessageStreamError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  /**
+   * The type of chunk that caused the error (e.g., 'text-delta', 'reasoning-end').
+   */
+  readonly chunkType: string;
+
+  /**
+   * The ID associated with the failing chunk (part ID or toolCallId).
+   */
+  readonly chunkId: string;
+
+  constructor({
+    chunkType,
+    chunkId,
+    message,
+  }: {
+    chunkType: string;
+    chunkId: string;
+    message: string;
+  }) {
+    super({ name, message });
+
+    this.chunkType = chunkType;
+    this.chunkId = chunkId;
+  }
+
+  static isInstance(error: unknown): error is UIMessageStreamError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/error/unsupported-model-version-error.ts

@@ -0,0 +1,23 @@
+import { AISDKError } from '@ai-sdk/provider';
+
+/**
+ * Error that is thrown when a model with an unsupported version is used.
+ */
+export class UnsupportedModelVersionError extends AISDKError {
+  readonly version: string;
+  readonly provider: string;
+  readonly modelId: string;
+
+  constructor(options: { version: string; provider: string; modelId: string }) {
+    super({
+      name: 'AI_UnsupportedModelVersionError',
+      message:
+        `Unsupported model version ${options.version} for provider "${options.provider}" and model "${options.modelId}". ` +
+        `AI SDK 5 only supports models that implement specification version "v2".`,
+    });
+
+    this.version = options.version;
+    this.provider = options.provider;
+    this.modelId = options.modelId;
+  }
+}

package/src/error/verify-no-object-generated-error.ts

@@ -0,0 +1,27 @@
+import { expect } from 'vitest';
+
+import {
+  FinishReason,
+  LanguageModelResponseMetadata,
+  LanguageModelUsage,
+} from '../types';
+import { NoObjectGeneratedError } from './no-object-generated-error';
+
+export function verifyNoObjectGeneratedError(
+  error: unknown,
+  expected: {
+    message: string;
+    response: LanguageModelResponseMetadata & {
+      body?: string;
+    };
+    usage: LanguageModelUsage;
+    finishReason: FinishReason;
+  },
+) {
+  expect(NoObjectGeneratedError.isInstance(error)).toBeTruthy();
+  const noObjectGeneratedError = error as NoObjectGeneratedError;
+  expect(noObjectGeneratedError.message).toEqual(expected.message);
+  expect(noObjectGeneratedError.response).toEqual(expected.response);
+  expect(noObjectGeneratedError.usage).toEqual(expected.usage);
+  expect(noObjectGeneratedError.finishReason).toEqual(expected.finishReason);
+}

package/src/generate-image/generate-image-result.ts

@@ -0,0 +1,42 @@
+import { GeneratedFile } from '../generate-text';
+import { ImageModelProviderMetadata } from '../types/image-model';
+import { ImageModelResponseMetadata } from '../types/image-model-response-metadata';
+import { ImageModelUsage } from '../types/usage';
+import { Warning } from '../types/warning';
+
+/**
+ * The result of a `generateImage` call.
+ * It contains the images and additional information.
+ */
+export interface GenerateImageResult {
+  /**
+   * The first image that was generated.
+   */
+  readonly image: GeneratedFile;
+
+  /**
+   * The images that were generated.
+   */
+  readonly images: Array<GeneratedFile>;
+
+  /**
+   * Warnings for the call, e.g. unsupported settings.
+   */
+  readonly warnings: Array<Warning>;
+
+  /**
+   * Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
+   */
+  readonly responses: Array<ImageModelResponseMetadata>;
+
+  /**
+   * 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.
+   */
+  readonly providerMetadata: ImageModelProviderMetadata;
+
+  /**
+   * Combined token usage across all underlying provider calls for this image generation.
+   */
+  readonly usage: ImageModelUsage;
+}

package/src/generate-image/generate-image.ts

@@ -0,0 +1,361 @@
+import {
+  ImageModelV4,
+  ImageModelV4CallOptions,
+  ImageModelV4File,
+  ImageModelV4ProviderMetadata,
+} from '@ai-sdk/provider';
+import {
+  convertBase64ToUint8Array,
+  DataContent,
+  ProviderOptions,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { NoImageGeneratedError } from '../error/no-image-generated-error';
+import {
+  DefaultGeneratedFile,
+  GeneratedFile,
+} from '../generate-text/generated-file';
+import { logWarnings } from '../logger/log-warnings';
+import { resolveImageModel } from '../model/resolve-model';
+import type { ImageModel } from '../types/image-model';
+import { ImageModelResponseMetadata } from '../types/image-model-response-metadata';
+import { addImageModelUsage, ImageModelUsage } from '../types/usage';
+import { Warning } from '../types/warning';
+import {
+  detectMediaType,
+  imageMediaTypeSignatures,
+} from '../util/detect-media-type';
+import { prepareRetries } from '../util/prepare-retries';
+import { VERSION } from '../version';
+import { GenerateImageResult } from './generate-image-result';
+import { convertDataContentToUint8Array } from '../prompt/data-content';
+import { splitDataUrl } from '../prompt/split-data-url';
+
+export type GenerateImagePrompt =
+  | string
+  | {
+      images: Array<DataContent>;
+      text?: string;
+      mask?: DataContent;
+    };
+
+/**
+ * Generates images using an image model.
+ *
+ * @param model - The image model to use.
+ * @param prompt - The prompt that should be used to generate the image.
+ * @param n - Number of images to generate. Default: 1.
+ * @param maxImagesPerCall - Maximum number of images to generate in a single API call.
+ * @param size - Size of the images to generate. Must have the format `{width}x{height}`.
+ * @param aspectRatio - Aspect ratio of the images to generate. Must have the format `{width}:{height}`.
+ * @param seed - Seed for the image generation.
+ * @param providerOptions - Additional provider-specific options that are passed through to the provider
+ * as body parameters.
+ * @param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+ * @param abortSignal - An optional abort signal that can be used to cancel the call.
+ * @param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+ *
+ * @returns A result object that contains the generated images.
+ */
+export async function generateImage({
+  model: modelArg,
+  prompt: promptArg,
+  n = 1,
+  maxImagesPerCall,
+  size,
+  aspectRatio,
+  seed,
+  providerOptions,
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers,
+}: {
+  /**
+   * The image model to use.
+   */
+  model: ImageModel;
+
+  /**
+   * The prompt that should be used to generate the image.
+   */
+  prompt: GenerateImagePrompt;
+
+  /**
+   * Number of images to generate.
+   */
+  n?: number;
+
+  /**
+   * Maximum number of images to generate in a single API call. If not provided, the model's default will be used.
+   */
+  maxImagesPerCall?: number;
+
+  /**
+   * Size of the images to generate. Must have the format `{width}x{height}`. If not provided, the default size will be used.
+   */
+  size?: `${number}x${number}`;
+
+  /**
+   * Aspect ratio of the images to generate. Must have the format `{width}:{height}`. If not provided, the default aspect ratio will be used.
+   */
+  aspectRatio?: `${number}:${number}`;
+
+  /**
+   * Seed for the image generation. If not provided, the default seed will be used.
+   */
+  seed?: number;
+
+  /**
+   * 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?: ProviderOptions;
+
+  /**
+   * Maximum number of retries per image model call. Set to 0 to disable retries.
+   *
+   * @default 2
+   */
+  maxRetries?: number;
+
+  /**
+   * Abort signal.
+   */
+  abortSignal?: AbortSignal;
+
+  /**
+   * Additional headers to include in the request.
+   * Only applicable for HTTP-based providers.
+   */
+  headers?: Record<string, string>;
+}): Promise<GenerateImageResult> {
+  const model = resolveImageModel(modelArg);
+
+  const headersWithUserAgent = withUserAgentSuffix(
+    headers ?? {},
+    `ai/${VERSION}`,
+  );
+
+  const { retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal,
+  });
+
+  // default to 1 if the model has not specified limits on
+  // how many images can be generated in a single call
+  const maxImagesPerCallWithDefault =
+    maxImagesPerCall ?? (await invokeModelMaxImagesPerCall(model)) ?? 1;
+
+  // parallelize calls to the model:
+  const callCount = Math.ceil(n / maxImagesPerCallWithDefault);
+  const callImageCounts = Array.from({ length: callCount }, (_, i) => {
+    if (i < callCount - 1) {
+      return maxImagesPerCallWithDefault;
+    }
+
+    const remainder = n % maxImagesPerCallWithDefault;
+    return remainder === 0 ? maxImagesPerCallWithDefault : remainder;
+  });
+
+  const results = await Promise.all(
+    callImageCounts.map(async callImageCount =>
+      retry(() => {
+        const { prompt, files, mask } = normalizePrompt(promptArg);
+
+        return model.doGenerate({
+          prompt,
+          files,
+          mask,
+          n: callImageCount,
+          abortSignal,
+          headers: headersWithUserAgent,
+          size,
+          aspectRatio,
+          seed,
+          providerOptions: providerOptions ?? {},
+        });
+      }),
+    ),
+  );
+
+  // collect result images, warnings, and response metadata
+  const images: Array<DefaultGeneratedFile> = [];
+  const warnings: Array<Warning> = [];
+  const responses: Array<ImageModelResponseMetadata> = [];
+  const providerMetadata: ImageModelV4ProviderMetadata = {};
+  let totalUsage: ImageModelUsage = {
+    inputTokens: undefined,
+    outputTokens: undefined,
+    totalTokens: undefined,
+  };
+  for (const result of results) {
+    images.push(
+      ...result.images.map(
+        image =>
+          new DefaultGeneratedFile({
+            data: image,
+            mediaType:
+              detectMediaType({
+                data: image,
+                signatures: imageMediaTypeSignatures,
+              }) ?? 'image/png',
+          }),
+      ),
+    );
+    warnings.push(...result.warnings);
+
+    if (result.usage != null) {
+      totalUsage = addImageModelUsage(totalUsage, result.usage);
+    }
+
+    if (result.providerMetadata) {
+      for (const [providerName, metadata] of Object.entries<{
+        images: unknown;
+      }>(result.providerMetadata)) {
+        if (providerName === 'gateway') {
+          const currentEntry = providerMetadata[providerName];
+          if (currentEntry != null && typeof currentEntry === 'object') {
+            providerMetadata[providerName] = {
+              ...(currentEntry as object),
+              ...metadata,
+            } as ImageModelV4ProviderMetadata[string];
+          } else {
+            providerMetadata[providerName] =
+              metadata as ImageModelV4ProviderMetadata[string];
+          }
+          const imagesValue = (
+            providerMetadata[providerName] as { images?: unknown }
+          ).images;
+          if (Array.isArray(imagesValue) && imagesValue.length === 0) {
+            delete (providerMetadata[providerName] as { images?: unknown })
+              .images;
+          }
+        } else {
+          providerMetadata[providerName] ??= { images: [] };
+          providerMetadata[providerName].images.push(
+            ...result.providerMetadata[providerName].images,
+          );
+        }
+      }
+    }
+
+    responses.push(result.response);
+  }
+
+  logWarnings({ warnings, provider: model.provider, model: model.modelId });
+
+  if (!images.length) {
+    throw new NoImageGeneratedError({ responses });
+  }
+
+  return new DefaultGenerateImageResult({
+    images,
+    warnings,
+    responses,
+    providerMetadata,
+    usage: totalUsage,
+  });
+}
+
+class DefaultGenerateImageResult implements GenerateImageResult {
+  readonly images: Array<GeneratedFile>;
+  readonly warnings: Array<Warning>;
+  readonly responses: Array<ImageModelResponseMetadata>;
+  readonly providerMetadata: ImageModelV4ProviderMetadata;
+  readonly usage: ImageModelUsage;
+
+  constructor(options: {
+    images: Array<GeneratedFile>;
+    warnings: Array<Warning>;
+    responses: Array<ImageModelResponseMetadata>;
+    providerMetadata: ImageModelV4ProviderMetadata;
+    usage: ImageModelUsage;
+  }) {
+    this.images = options.images;
+    this.warnings = options.warnings;
+    this.responses = options.responses;
+    this.providerMetadata = options.providerMetadata;
+    this.usage = options.usage;
+  }
+
+  get image() {
+    return this.images[0];
+  }
+}
+
+async function invokeModelMaxImagesPerCall(model: ImageModelV4) {
+  const isFunction = model.maxImagesPerCall instanceof Function;
+
+  if (!isFunction) {
+    return model.maxImagesPerCall;
+  }
+
+  return model.maxImagesPerCall({
+    modelId: model.modelId,
+  });
+}
+
+function normalizePrompt(
+  prompt: GenerateImagePrompt,
+): Pick<ImageModelV4CallOptions, 'prompt' | 'files' | 'mask'> {
+  if (typeof prompt === 'string') {
+    return { prompt, files: undefined, mask: undefined };
+  }
+
+  return {
+    prompt: prompt.text,
+    files: prompt.images.map(toImageModelV4File),
+    mask: prompt.mask ? toImageModelV4File(prompt.mask) : undefined,
+  };
+}
+
+function toImageModelV4File(dataContent: DataContent): ImageModelV4File {
+  if (typeof dataContent === 'string' && dataContent.startsWith('http')) {
+    return {
+      type: 'url',
+      url: dataContent,
+    };
+  }
+
+  // Handle data URLs
+  if (typeof dataContent === 'string' && dataContent.startsWith('data:')) {
+    const { mediaType: dataUrlMediaType, base64Content } =
+      splitDataUrl(dataContent);
+
+    if (base64Content != null) {
+      const uint8Data = convertBase64ToUint8Array(base64Content);
+      return {
+        type: 'file',
+        data: uint8Data,
+        mediaType:
+          dataUrlMediaType ||
+          detectMediaType({
+            data: uint8Data,
+            signatures: imageMediaTypeSignatures,
+          }) ||
+          'image/png',
+      };
+    }
+  }
+
+  const uint8Data = convertDataContentToUint8Array(dataContent);
+  return {
+    type: 'file',
+    data: uint8Data,
+    mediaType:
+      detectMediaType({
+        data: uint8Data,
+        signatures: imageMediaTypeSignatures,
+      }) || 'image/png',
+  };
+}

package/src/generate-image/index.ts

@@ -0,0 +1,18 @@
+export { generateImage } from './generate-image';
+export type { GenerateImageResult } from './generate-image-result';
+
+// deprecated exports
+
+import { generateImage } from './generate-image';
+/**
+ * @deprecated Use `generateImage` instead.
+ */
+const experimental_generateImage = generateImage;
+export { experimental_generateImage };
+
+import type { GenerateImageResult } from './generate-image-result';
+/**
+ * @deprecated Use `GenerateImageResult` instead.
+ */
+type Experimental_GenerateImageResult = GenerateImageResult;
+export type { Experimental_GenerateImageResult };