@fairyhunter13/ai-sdk 6.0.116-fork.1

package/src/test/mock-video-model-v4.ts

@@ -0,0 +1,28 @@
+import { Experimental_VideoModelV4 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class MockVideoModelV4 implements Experimental_VideoModelV4 {
+  readonly specificationVersion = 'v4';
+  readonly provider: Experimental_VideoModelV4['provider'];
+  readonly modelId: Experimental_VideoModelV4['modelId'];
+  readonly maxVideosPerCall: Experimental_VideoModelV4['maxVideosPerCall'];
+
+  doGenerate: Experimental_VideoModelV4['doGenerate'];
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    maxVideosPerCall = 1,
+    doGenerate = notImplemented,
+  }: {
+    provider?: Experimental_VideoModelV4['provider'];
+    modelId?: Experimental_VideoModelV4['modelId'];
+    maxVideosPerCall?: Experimental_VideoModelV4['maxVideosPerCall'];
+    doGenerate?: Experimental_VideoModelV4['doGenerate'];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.maxVideosPerCall = maxVideosPerCall;
+    this.doGenerate = doGenerate;
+  }
+}

package/src/test/not-implemented.ts

@@ -0,0 +1,3 @@
+export function notImplemented(): never {
+  throw new Error('Not implemented');
+}

package/src/text-stream/create-text-stream-response.ts

@@ -0,0 +1,30 @@
+import { prepareHeaders } from '../util/prepare-headers';
+
+/**
+ * Creates a Response object from a text stream.
+ * Each text chunk is encoded as UTF-8 and sent as a separate chunk.
+ * Sets a `Content-Type` header to `text/plain; charset=utf-8`.
+ *
+ * @param options - The options for creating the response.
+ * @param options.status - Optional HTTP status code (default: 200).
+ * @param options.statusText - Optional HTTP status text.
+ * @param options.headers - Optional response headers.
+ * @param options.textStream - The text stream to send.
+ * @returns A Response object with the text stream body.
+ */
+export function createTextStreamResponse({
+  status,
+  statusText,
+  headers,
+  textStream,
+}: ResponseInit & {
+  textStream: ReadableStream<string>;
+}): Response {
+  return new Response(textStream.pipeThrough(new TextEncoderStream()), {
+    status: status ?? 200,
+    statusText,
+    headers: prepareHeaders(headers, {
+      'content-type': 'text/plain; charset=utf-8',
+    }),
+  });
+}

package/src/text-stream/index.ts

@@ -0,0 +1,2 @@
+export { createTextStreamResponse } from './create-text-stream-response';
+export { pipeTextStreamToResponse } from './pipe-text-stream-to-response';

package/src/text-stream/pipe-text-stream-to-response.ts

@@ -0,0 +1,38 @@
+import { ServerResponse } from 'node:http';
+import { prepareHeaders } from '../util/prepare-headers';
+import { writeToServerResponse } from '../util/write-to-server-response';
+
+/**
+ * Writes a text stream to a Node.js ServerResponse object.
+ * Each text chunk is encoded as UTF-8 and written as a separate chunk.
+ * Sets a `Content-Type` header to `text/plain; charset=utf-8`.
+ *
+ * @param options - The options for piping the stream.
+ * @param options.response - The Node.js ServerResponse to write to.
+ * @param options.status - Optional HTTP status code.
+ * @param options.statusText - Optional HTTP status text.
+ * @param options.headers - Optional response headers.
+ * @param options.textStream - The text stream to pipe.
+ */
+export function pipeTextStreamToResponse({
+  response,
+  status,
+  statusText,
+  headers,
+  textStream,
+}: {
+  response: ServerResponse;
+  textStream: ReadableStream<string>;
+} & ResponseInit): void {
+  writeToServerResponse({
+    response,
+    status,
+    statusText,
+    headers: Object.fromEntries(
+      prepareHeaders(headers, {
+        'content-type': 'text/plain; charset=utf-8',
+      }).entries(),
+    ),
+    stream: textStream.pipeThrough(new TextEncoderStream()),
+  });
+}

package/src/transcribe/index.ts

@@ -0,0 +1,2 @@
+export { transcribe as experimental_transcribe } from './transcribe';
+export type { TranscriptionResult as Experimental_TranscriptionResult } from './transcribe-result';

package/src/transcribe/transcribe-result.ts

@@ -0,0 +1,60 @@
+import { JSONObject } from '@ai-sdk/provider';
+import { TranscriptionModelResponseMetadata } from '../types/transcription-model-response-metadata';
+import { Warning } from '../types/warning';
+
+/**
+ * The result of a `transcribe` call.
+ * It contains the transcript and additional information.
+ */
+export interface TranscriptionResult {
+  /**
+   * The complete transcribed text from the audio.
+   */
+  readonly text: string;
+
+  /**
+   * Array of transcript segments with timing information.
+   * Each segment represents a portion of the transcribed text with start and end times.
+   */
+  readonly segments: Array<{
+    /**
+     * The text content of this segment.
+     */
+    readonly text: string;
+    /**
+     * The start time of this segment in seconds.
+     */
+    readonly startSecond: number;
+    /**
+     * The end time of this segment in seconds.
+     */
+    readonly endSecond: number;
+  }>;
+
+  /**
+   * The detected language of the audio content, as an ISO-639-1 code (e.g., 'en' for English).
+   * May be undefined if the language couldn't be detected.
+   */
+  readonly language: string | undefined;
+
+  /**
+   * The total duration of the audio file in seconds.
+   * May be undefined if the duration couldn't be determined.
+   */
+  readonly durationInSeconds: number | undefined;
+
+  /**
+   * 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<TranscriptionModelResponseMetadata>;
+
+  /**
+   * Provider metadata from the provider.
+   */
+  readonly providerMetadata: Record<string, JSONObject>;
+}

package/src/transcribe/transcribe.ts

@@ -0,0 +1,187 @@
+import { JSONObject } from '@ai-sdk/provider';
+import { ProviderOptions, withUserAgentSuffix } from '@ai-sdk/provider-utils';
+import { NoTranscriptGeneratedError } from '../error/no-transcript-generated-error';
+import { logWarnings } from '../logger/log-warnings';
+import { DataContent } from '../prompt';
+import { convertDataContentToUint8Array } from '../prompt/data-content';
+import { TranscriptionModel } from '../types/transcription-model';
+import { TranscriptionModelResponseMetadata } from '../types/transcription-model-response-metadata';
+import {
+  audioMediaTypeSignatures,
+  detectMediaType,
+} from '../util/detect-media-type';
+import { createDownload } from '../util/download/create-download';
+import { prepareRetries } from '../util/prepare-retries';
+import { TranscriptionResult } from './transcribe-result';
+import { VERSION } from '../version';
+import { resolveTranscriptionModel } from '../model/resolve-model';
+import { Warning } from '../types';
+/**
+ * Generates transcripts using a transcription model.
+ *
+ * @param model - The transcription model to use.
+ * @param audio - The audio data to transcribe as DataContent (string | Uint8Array | ArrayBuffer | Buffer) or a URL.
+ * @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 transcript.
+ */
+const defaultDownload = createDownload();
+
+export async function transcribe({
+  model,
+  audio,
+  providerOptions = {},
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers,
+  download: downloadFn = defaultDownload,
+}: {
+  /**
+   * The transcription model to use.
+   */
+  model: TranscriptionModel;
+
+  /**
+   * The audio data to transcribe.
+   */
+  audio: DataContent | URL;
+
+  /**
+   * 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": {
+   *     "temperature": 0
+   *   }
+   * }
+   * ```
+   */
+  providerOptions?: ProviderOptions;
+
+  /**
+   * Maximum number of retries per transcript 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>;
+
+  /**
+   * Custom download function for fetching audio from URLs.
+   * Use `createDownload()` from `ai` to create a download function with custom size limits.
+   *
+   * @default createDownload() (2 GiB limit)
+   */
+  download?: (options: {
+    url: URL;
+    abortSignal?: AbortSignal;
+  }) => Promise<{ data: Uint8Array; mediaType: string | undefined }>;
+}): Promise<TranscriptionResult> {
+  const resolvedModel = resolveTranscriptionModel(model);
+  if (!resolvedModel) {
+    throw new Error('Model could not be resolved');
+  }
+
+  const { retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal,
+  });
+
+  const headersWithUserAgent = withUserAgentSuffix(
+    headers ?? {},
+    `ai/${VERSION}`,
+  );
+
+  const audioData =
+    audio instanceof URL
+      ? (await downloadFn({ url: audio, abortSignal })).data
+      : convertDataContentToUint8Array(audio);
+
+  const result = await retry(() =>
+    resolvedModel.doGenerate({
+      audio: audioData,
+      abortSignal,
+      headers: headersWithUserAgent,
+      providerOptions,
+      mediaType:
+        detectMediaType({
+          data: audioData,
+          signatures: audioMediaTypeSignatures,
+        }) ?? 'audio/wav',
+    }),
+  );
+
+  logWarnings({
+    warnings: result.warnings,
+    provider: resolvedModel.provider,
+    model: resolvedModel.modelId,
+  });
+
+  if (!result.text) {
+    throw new NoTranscriptGeneratedError({ responses: [result.response] });
+  }
+
+  return new DefaultTranscriptionResult({
+    text: result.text,
+    segments: result.segments,
+    language: result.language,
+    durationInSeconds: result.durationInSeconds,
+    warnings: result.warnings,
+    responses: [result.response],
+    providerMetadata: result.providerMetadata,
+  });
+}
+
+class DefaultTranscriptionResult implements TranscriptionResult {
+  readonly text: string;
+  readonly segments: Array<{
+    text: string;
+    startSecond: number;
+    endSecond: number;
+  }>;
+  readonly language: string | undefined;
+  readonly durationInSeconds: number | undefined;
+  readonly warnings: Array<Warning>;
+  readonly responses: Array<TranscriptionModelResponseMetadata>;
+  readonly providerMetadata: Record<string, JSONObject>;
+
+  constructor(options: {
+    text: string;
+    segments: Array<{
+      text: string;
+      startSecond: number;
+      endSecond: number;
+    }>;
+    language: string | undefined;
+    durationInSeconds: number | undefined;
+    warnings: Array<Warning>;
+    responses: Array<TranscriptionModelResponseMetadata>;
+    providerMetadata: Record<string, JSONObject> | undefined;
+  }) {
+    this.text = options.text;
+    this.segments = options.segments;
+    this.language = options.language;
+    this.durationInSeconds = options.durationInSeconds;
+    this.warnings = options.warnings;
+    this.responses = options.responses;
+    this.providerMetadata = options.providerMetadata ?? {};
+  }
+}

package/src/types/embedding-model-middleware.ts

@@ -0,0 +1,15 @@
+import { EmbeddingModelV4Middleware } from '@ai-sdk/provider';
+
+/**
+ * Middleware for embedding models.
+ * Accepts both V3 and V4 middleware types for backward compatibility.
+ *
+ * Uses EmbeddingModelV4Middleware as the base but relaxes specificationVersion
+ * to accept any string (including 'v3') and makes it optional.
+ */
+export type EmbeddingModelMiddleware = Omit<
+  EmbeddingModelV4Middleware,
+  'specificationVersion'
+> & {
+  readonly specificationVersion?: string;
+};

package/src/types/embedding-model.ts

@@ -0,0 +1,20 @@
+import {
+  EmbeddingModelV2,
+  EmbeddingModelV3,
+  EmbeddingModelV4,
+  EmbeddingModelV4Embedding,
+} from '@ai-sdk/provider';
+
+/**
+ * Embedding model that is used by the AI SDK.
+ */
+export type EmbeddingModel =
+  | string
+  | EmbeddingModelV4
+  | EmbeddingModelV3
+  | EmbeddingModelV2<string>;
+
+/**
+ * Embedding.
+ */
+export type Embedding = EmbeddingModelV4Embedding;

package/src/types/image-model-middleware.ts

@@ -0,0 +1,15 @@
+import { ImageModelV4Middleware } from '@ai-sdk/provider';
+
+/**
+ * Middleware for image models.
+ * Accepts both V3 and V4 middleware types for backward compatibility.
+ *
+ * Uses ImageModelV4Middleware as the base but relaxes specificationVersion
+ * to accept any string (including 'v3') and makes it optional.
+ */
+export type ImageModelMiddleware = Omit<
+  ImageModelV4Middleware,
+  'specificationVersion'
+> & {
+  readonly specificationVersion?: string;
+};

package/src/types/image-model-response-metadata.ts

@@ -0,0 +1,16 @@
+export type ImageModelResponseMetadata = {
+  /**
+   * 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>;
+};

package/src/types/image-model.ts

@@ -0,0 +1,19 @@
+import {
+  ImageModelV2,
+  ImageModelV3,
+  ImageModelV4,
+  ImageModelV4ProviderMetadata,
+  ImageModelV2ProviderMetadata,
+} from '@ai-sdk/provider';
+
+/**
+ * Image model that is used by the AI SDK.
+ */
+export type ImageModel = string | ImageModelV4 | ImageModelV3 | ImageModelV2;
+
+/**
+ * Metadata from the model provider for this call.
+ */
+export type ImageModelProviderMetadata =
+  | ImageModelV4ProviderMetadata
+  | ImageModelV2ProviderMetadata;

package/src/types/index.ts

@@ -0,0 +1,29 @@
+export type { JSONSchema7 } from '@ai-sdk/provider';
+export type { Embedding, EmbeddingModel } from './embedding-model';
+export type { EmbeddingModelMiddleware } from './embedding-model-middleware';
+export type { ImageModel, ImageModelProviderMetadata } from './image-model';
+export type { ImageModelMiddleware } from './image-model-middleware';
+export type { ImageModelResponseMetadata } from './image-model-response-metadata';
+export type { JSONValue } from './json-value';
+export type {
+  CallWarning,
+  FinishReason,
+  LanguageModel,
+  ToolChoice,
+} from './language-model';
+export type { LanguageModelMiddleware } from './language-model-middleware';
+export type { LanguageModelRequestMetadata } from './language-model-request-metadata';
+export type { LanguageModelResponseMetadata } from './language-model-response-metadata';
+export type { Provider } from './provider';
+export type { ProviderMetadata } from './provider-metadata';
+export type { RerankingModel } from './reranking-model';
+export type { SpeechModel } from './speech-model';
+export type { SpeechModelResponseMetadata } from './speech-model-response-metadata';
+export type { TranscriptionModel } from './transcription-model';
+export type { TranscriptionModelResponseMetadata } from './transcription-model-response-metadata';
+export type {
+  EmbeddingModelUsage,
+  ImageModelUsage,
+  LanguageModelUsage,
+} from './usage';
+export type { Warning } from './warning';

package/src/types/json-value.ts

@@ -0,0 +1,15 @@
+import { JSONValue as OriginalJSONValue } from '@ai-sdk/provider';
+import { z } from 'zod/v4';
+
+export const jsonValueSchema: z.ZodType<JSONValue> = z.lazy(() =>
+  z.union([
+    z.null(),
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.record(z.string(), jsonValueSchema.optional()),
+    z.array(jsonValueSchema),
+  ]),
+);
+
+export type JSONValue = OriginalJSONValue;

package/src/types/language-model-middleware.ts

@@ -0,0 +1,15 @@
+import { LanguageModelV4Middleware } from '@ai-sdk/provider';
+
+/**
+ * Middleware for language models.
+ * Accepts both V3 and V4 middleware types for backward compatibility.
+ *
+ * Uses LanguageModelV4Middleware as the base but relaxes specificationVersion
+ * to accept any string (including 'v3') and makes it optional.
+ */
+export type LanguageModelMiddleware = Omit<
+  LanguageModelV4Middleware,
+  'specificationVersion'
+> & {
+  readonly specificationVersion?: string;
+};

package/src/types/language-model-request-metadata.ts

@@ -0,0 +1,6 @@
+export type LanguageModelRequestMetadata = {
+  /**
+   * Request HTTP body that was sent to the provider API.
+   */
+  body?: unknown;
+};

package/src/types/language-model-response-metadata.ts

@@ -0,0 +1,21 @@
+export type LanguageModelResponseMetadata = {
+  /**
+   * ID for the generated response.
+   */
+  id: string;
+
+  /**
+   * 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 (available only for providers that use HTTP requests).
+   */
+  headers?: Record<string, string>;
+};

package/src/types/language-model.ts

@@ -0,0 +1,106 @@
+import { GatewayModelId } from '@ai-sdk/gateway';
+import {
+  LanguageModelV2,
+  LanguageModelV3,
+  LanguageModelV4,
+  SharedV4Warning,
+  LanguageModelV4Source,
+} from '@ai-sdk/provider';
+
+declare global {
+  /**
+   * Global interface that can be augmented by third-party packages to register custom model IDs.
+   *
+   * You can register model IDs in two ways:
+   *
+   * 1. Register based on Model IDs from a provider package:
+   * @example
+   * ```typescript
+   * import { openai } from '@ai-sdk/openai';
+   * type OpenAIResponsesModelId = Parameters<typeof openai>[0];
+   *
+   * declare global {
+   *   interface RegisteredProviderModels {
+   *     openai: OpenAIResponsesModelId;
+   *   }
+   * }
+   * ```
+   *
+   * 2. Register individual model IDs directly as keys:
+   * @example
+   * ```typescript
+   * declare global {
+   *   interface RegisteredProviderModels {
+   *     'my-provider:my-model': any;
+   *     'my-provider:another-model': any;
+   *   }
+   * }
+   * ```
+   */
+  interface RegisteredProviderModels {}
+}
+
+/**
+ * Global provider model ID type that defaults to GatewayModelId but can be augmented
+ * by third-party packages via declaration merging.
+ */
+export type GlobalProviderModelId = [keyof RegisteredProviderModels] extends [
+  never,
+]
+  ? GatewayModelId
+  :
+      | keyof RegisteredProviderModels
+      | RegisteredProviderModels[keyof RegisteredProviderModels];
+
+/**
+ * Language model that is used by the AI SDK.
+ */
+export type LanguageModel =
+  | GlobalProviderModelId
+  | LanguageModelV4
+  | LanguageModelV3
+  | LanguageModelV2;
+
+/**
+ * Reason why a language model finished generating a response.
+ *
+ * Can be one of the following:
+ * - `stop`: model generated stop sequence
+ * - `length`: model generated maximum number of tokens
+ * - `content-filter`: content filter violation stopped the model
+ * - `tool-calls`: model triggered tool calls
+ * - `error`: model stopped because of an error
+ * - `other`: model stopped for other reasons
+ */
+export type FinishReason =
+  | 'stop'
+  | 'length'
+  | 'content-filter'
+  | 'tool-calls'
+  | 'error'
+  | 'other';
+
+/**
+ * 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 CallWarning = SharedV4Warning;
+
+/**
+ * A source that has been used as input to generate the response.
+ */
+export type Source = LanguageModelV4Source;
+
+/**
+ * Tool choice for the generation. It supports the following settings:
+ *
+ * - `auto` (default): the model can choose whether and which tools to call.
+ * - `required`: the model must call a tool. It can choose which tool to call.
+ * - `none`: the model must not call tools
+ * - `{ type: 'tool', toolName: string (typed) }`: the model must call the specified tool
+ */
+export type ToolChoice<TOOLS extends Record<string, unknown>> =
+  | 'auto'
+  | 'none'
+  | 'required'
+  | { type: 'tool'; toolName: Extract<keyof TOOLS, string> };

package/src/types/provider-metadata.ts

@@ -0,0 +1,16 @@
+import { SharedV4ProviderMetadata } from '@ai-sdk/provider';
+import { z } from 'zod/v4';
+import { jsonValueSchema } from './json-value';
+
+/**
+ * Additional provider-specific metadata that is returned from the provider.
+ *
+ * This is needed to enable provider-specific functionality that can be
+ * fully encapsulated in the provider.
+ */
+export type ProviderMetadata = SharedV4ProviderMetadata;
+
+export const providerMetadataSchema: z.ZodType<ProviderMetadata> = z.record(
+  z.string(),
+  z.record(z.string(), jsonValueSchema.optional()),
+);