@ai-sdk/provider 2.0.0-canary.9 → 2.1.0-beta.0

package/dist/index.d.ts

@@ -3,6 +3,10 @@ export { JSONSchema7, JSONSchema7Definition } from 'json-schema';
 
 type SharedV2Headers = Record<string, string>;
 
+/**
+A JSON value can be a string, number, boolean, object, array, or null.
+JSON values can be serialized and deserialized by the JSON.stringify and JSON.parse methods.
+ */
 type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
 type JSONObject = {
     [key: string]: JSONValue;
@@ -88,12 +92,14 @@ type EmbeddingModelV2<VALUE> = {
     readonly modelId: string;
     /**
   Limit of how many embeddings can be generated in a single API call.
+  
+  Use Infinity for models that do not have a limit.
      */
-    readonly maxEmbeddingsPerCall: number | undefined;
+    readonly maxEmbeddingsPerCall: PromiseLike<number | undefined> | number | undefined;
     /**
   True if the model can handle multiple embedding calls in parallel.
      */
-    readonly supportsParallelCalls: boolean;
+    readonly supportsParallelCalls: PromiseLike<boolean> | boolean;
     /**
   Generates a list of embeddings for the given input text.
   
@@ -132,6 +138,12 @@ type EmbeddingModelV2<VALUE> = {
             tokens: number;
         };
         /**
+    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.
+         */
+        providerMetadata?: SharedV2ProviderMetadata;
+        /**
     Optional response information for debugging purposes.
          */
         response?: {
@@ -307,11 +319,11 @@ declare const symbol$3: unique symbol;
 declare class NoSuchModelError extends AISDKError {
     private readonly [symbol$3];
     readonly modelId: string;
-    readonly modelType: 'languageModel' | 'textEmbeddingModel' | 'imageModel';
+    readonly modelType: 'languageModel' | 'textEmbeddingModel' | 'imageModel' | 'transcriptionModel' | 'speechModel';
     constructor({ errorName, modelId, modelType, message, }: {
         errorName?: string;
         modelId: string;
-        modelType: 'languageModel' | 'textEmbeddingModel' | 'imageModel';
+        modelType: 'languageModel' | 'textEmbeddingModel' | 'imageModel' | 'transcriptionModel' | 'speechModel';
         message?: string;
     });
     static isInstance(error: unknown): error is NoSuchModelError;
@@ -369,7 +381,11 @@ declare class UnsupportedFunctionalityError extends AISDKError {
     static isInstance(error: unknown): error is UnsupportedFunctionalityError;
 }
 
-type ImageModelV1CallOptions = {
+declare function isJSONValue(value: unknown): value is JSONValue;
+declare function isJSONArray(value: unknown): value is JSONArray;
+declare function isJSONObject(value: unknown): value is JSONObject;
+
+type ImageModelV2CallOptions = {
     /**
   Prompt for the image generation.
        */
@@ -403,13 +419,13 @@ type ImageModelV1CallOptions = {
   record is keyed by the provider-specific metadata key.
   ```ts
   {
-  "openai": {
-  "style": "vivid"
-  }
+    "openai": {
+      "style": "vivid"
+    }
   }
   ```
    */
-    providerOptions: Record<string, Record<string, JSONValue>>;
+    providerOptions: SharedV2ProviderOptions;
     /**
   Abort signal for cancelling the operation.
    */
@@ -425,19 +441,25 @@ type ImageModelV1CallOptions = {
 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.
  */
-type ImageModelV1CallWarning = {
+type ImageModelV2CallWarning = {
     type: 'unsupported-setting';
-    setting: keyof ImageModelV1CallOptions;
+    setting: keyof ImageModelV2CallOptions;
     details?: string;
 } | {
     type: 'other';
     message: string;
 };
 
+type ImageModelV2ProviderMetadata = Record<string, {
+    images: JSONArray;
+} & JSONValue>;
+type GetMaxImagesPerCallFunction = (options: {
+    modelId: string;
+}) => PromiseLike<number | undefined> | number | undefined;
 /**
-Image generation model specification version 1.
+Image generation model specification version 2.
  */
-type ImageModelV1 = {
+type ImageModelV2 = {
     /**
   The image model must specify which image model interface
   version it implements. This will allow us to evolve the image
@@ -445,7 +467,7 @@ type ImageModelV1 = {
   implementation versions can be handled as a discriminated union
   on our side.
      */
-    readonly specificationVersion: 'v1';
+    readonly specificationVersion: 'v2';
     /**
   Name of the provider for logging purposes.
      */
@@ -456,13 +478,15 @@ type ImageModelV1 = {
     readonly modelId: string;
     /**
   Limit of how many images can be generated in a single API call.
-  If undefined, we will max generate one image per 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;
+    readonly maxImagesPerCall: number | undefined | GetMaxImagesPerCallFunction;
     /**
   Generates an array of images.
      */
-    doGenerate(options: ImageModelV1CallOptions): PromiseLike<{
+    doGenerate(options: ImageModelV2CallOptions): PromiseLike<{
         /**
     Generated images as base64 encoded strings or binary data.
     The images should be returned without any unnecessary conversion.
@@ -474,7 +498,25 @@ type ImageModelV1 = {
         /**
     Warnings for the call, e.g. unsupported settings.
          */
-        warnings: Array<ImageModelV1CallWarning>;
+        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.
          */
@@ -495,10 +537,6 @@ type ImageModelV1 = {
     }>;
 };
 
-declare function isJSONValue(value: unknown): value is JSONValue;
-declare function isJSONArray(value: unknown): value is JSONArray;
-declare function isJSONObject(value: unknown): value is JSONObject;
-
 /**
 A tool has a name, a description, and a set of parameters.
 
@@ -523,7 +561,11 @@ type LanguageModelV2FunctionTool = {
   The parameters that the tool expects. The language model uses this to
   understand the tool's input requirements and to provide matching suggestions.
      */
-    parameters: JSONSchema7;
+    inputSchema: JSONSchema7;
+    /**
+  The provider-specific options for the tool.
+     */
+    providerOptions?: SharedV2ProviderOptions;
 };
 
 /**
@@ -549,7 +591,7 @@ type LanguageModelV2Message = ({
     content: Array<LanguageModelV2TextPart | LanguageModelV2FilePart>;
 } | {
     role: 'assistant';
-    content: Array<LanguageModelV2TextPart | LanguageModelV2FilePart | LanguageModelV2ReasoningPart | LanguageModelV2RedactedReasoningPart | LanguageModelV2ToolCallPart>;
+    content: Array<LanguageModelV2TextPart | LanguageModelV2FilePart | LanguageModelV2ReasoningPart | LanguageModelV2ToolCallPart | LanguageModelV2ToolResultPart>;
 } | {
     role: 'tool';
     content: Array<LanguageModelV2ToolResultPart>;
@@ -587,26 +629,6 @@ interface LanguageModelV2ReasoningPart {
      */
     text: string;
     /**
-  An optional signature for verifying that the reasoning originated from the model.
-     */
-    signature?: string;
-    /**
-     * Additional provider-specific options. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerOptions?: SharedV2ProviderOptions;
-}
-/**
-Redacted reasoning content part of a prompt.
- */
-interface LanguageModelV2RedactedReasoningPart {
-    type: 'redacted-reasoning';
-    /**
-  Redacted reasoning data.
-     */
-    data: string;
-    /**
      * Additional provider-specific options. They are passed through
      * to the provider from the AI SDK and enable provider-specific
      * functionality that can be fully encapsulated in the provider.
@@ -657,7 +679,12 @@ interface LanguageModelV2ToolCallPart {
     /**
   Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
      */
-    args: unknown;
+    input: unknown;
+    /**
+     * Whether the tool call will be executed by the provider.
+     * If this flag is not set or is false, the tool call will be executed by the client.
+     */
+    providerExecuted?: boolean;
     /**
      * Additional provider-specific options. They are passed through
      * to the provider from the AI SDK and enable provider-specific
@@ -679,43 +706,49 @@ interface LanguageModelV2ToolResultPart {
     */
     toolName: string;
     /**
-  Result of the tool call. This is a JSON-serializable object.
+  Result of the tool call.
      */
-    result: unknown;
-    /**
-  Optional flag if the result is an error or an error message.
-     */
-    isError?: boolean;
+    output: LanguageModelV2ToolResultOutput;
     /**
-  Tool results as an array of parts. This enables advanced tool results including images.
-  When this is used, the `result` field should be ignored (if the provider supports content).
+     * Additional provider-specific options. They are passed through
+     * to the provider from the AI SDK and enable provider-specific
+     * functionality that can be fully encapsulated in the provider.
      */
-    content?: Array<{
+    providerOptions?: SharedV2ProviderOptions;
+}
+type LanguageModelV2ToolResultOutput = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'json';
+    value: JSONValue;
+} | {
+    type: 'error-text';
+    value: string;
+} | {
+    type: 'error-json';
+    value: JSONValue;
+} | {
+    type: 'content';
+    value: Array<{
         type: 'text';
         /**
 Text content.
-         */
+*/
         text: string;
     } | {
-        type: 'image';
+        type: 'media';
         /**
-base-64 encoded image data
-         */
+Base-64 encoded media data.
+*/
         data: string;
         /**
-IANA media type of the image.
-
+IANA media type.
 @see https://www.iana.org/assignments/media-types/media-types.xhtml
-         */
-        mediaType?: string;
+*/
+        mediaType: string;
     }>;
-    /**
-     * Additional provider-specific options. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerOptions?: SharedV2ProviderOptions;
-}
+};
 
 /**
 The configuration of a tool that is defined by the provider.
@@ -726,11 +759,11 @@ type LanguageModelV2ProviderDefinedTool = {
      */
     type: 'provider-defined';
     /**
-  The ID of the tool. Should follow the format `<provider-name>.<tool-name>`.
+  The ID of the tool. Should follow the format `<provider-name>.<unique-tool-name>`.
      */
     id: `${string}.${string}`;
     /**
-  The name of the tool. Unique within this model call.
+  The name of the tool that the user must use in the tool set.
      */
     name: string;
     /**
@@ -752,13 +785,6 @@ type LanguageModelV2ToolChoice = {
 
 type LanguageModelV2CallOptions = {
     /**
-  Whether the user provided the input as messages or as
-  a prompt. This can help guide non-chat models in the
-  expansion, bc different expansions can be needed for
-  chat/non-chat use cases.
-     */
-    inputFormat: 'messages' | 'prompt';
-    /**
   A language mode prompt is a standardized prompt type.
   
   Note: This is **not** the user-facing prompt. The AI SDK methods will map the
@@ -772,9 +798,7 @@ type LanguageModelV2CallOptions = {
      */
     maxOutputTokens?: number;
     /**
-  Temperature setting.
-  
-  It is recommended to set either `temperature` or `topP`, but not both.
+  Temperature setting. The range depends on the provider and model.
    */
     temperature?: number;
     /**
@@ -785,8 +809,6 @@ type LanguageModelV2CallOptions = {
     stopSequences?: string[];
     /**
   Nucleus sampling.
-  
-  It is recommended to set either `temperature` or `topP`, but not both.
    */
     topP?: number;
     /**
@@ -842,6 +864,10 @@ type LanguageModelV2CallOptions = {
   */
     toolChoice?: LanguageModelV2ToolChoice;
     /**
+  Include raw chunks in the stream. Only applicable for streaming calls.
+   */
+    includeRawChunks?: boolean;
+    /**
   Abort signal for cancelling the operation.
    */
     abortSignal?: AbortSignal;
@@ -904,16 +930,11 @@ Reasoning that the model has generated.
  */
 type LanguageModelV2Reasoning = {
     type: 'reasoning';
-    reasoningType: 'text';
     text: string;
-} | {
-    type: 'reasoning';
-    reasoningType: 'signature';
-    signature: string;
-} | {
-    type: 'reasoning';
-    reasoningType: 'redacted';
-    data: string;
+    /**
+     * Optional provider-specific metadata for the reasoning part.
+     */
+    providerMetadata?: SharedV2ProviderMetadata;
 };
 
 /**
@@ -922,7 +943,7 @@ A source that has been used as input to generate the response.
 type LanguageModelV2Source = {
     type: 'source';
     /**
-     * A URL source. This is return by web search RAG models.
+     * The type of source - URL sources reference web content.
      */
     sourceType: 'url';
     /**
@@ -941,6 +962,32 @@ type LanguageModelV2Source = {
      * Additional provider metadata for the source.
      */
     providerMetadata?: SharedV2ProviderMetadata;
+} | {
+    type: 'source';
+    /**
+     * The type of source - document sources reference files/documents.
+     */
+    sourceType: 'document';
+    /**
+     * The ID of the source.
+     */
+    id: string;
+    /**
+     * IANA media type of the document (e.g., 'application/pdf').
+     */
+    mediaType: string;
+    /**
+     * The title of the document.
+     */
+    title: string;
+    /**
+     * Optional filename of the document.
+     */
+    filename?: string;
+    /**
+     * Additional provider metadata for the source.
+     */
+    providerMetadata?: SharedV2ProviderMetadata;
 };
 
 /**
@@ -952,24 +999,72 @@ type LanguageModelV2Text = {
   The text content.
      */
     text: string;
+    providerMetadata?: SharedV2ProviderMetadata;
 };
 
 /**
-Tool calls that the model has generated.
-     */
+ * Tool calls that the model has generated.
+ */
 type LanguageModelV2ToolCall = {
     type: 'tool-call';
-    toolCallType: 'function';
+    /**
+     * The identifier of the tool call. It must be unique across all tool calls.
+     */
+    toolCallId: string;
+    /**
+     * The name of the tool that should be called.
+     */
+    toolName: string;
+    /**
+     * Stringified JSON object with the tool call arguments. Must match the
+     * parameters schema of the tool.
+     */
+    input: string;
+    /**
+     * Whether the tool call will be executed by the provider.
+     * If this flag is not set or is false, the tool call will be executed by the client.
+     */
+    providerExecuted?: boolean;
+    /**
+     * Additional provider-specific metadata for the tool call.
+     */
+    providerMetadata?: SharedV2ProviderMetadata;
+};
+
+/**
+Result of a tool call that has been executed by the provider.
+ */
+type LanguageModelV2ToolResult = {
+    type: 'tool-result';
+    /**
+     * The ID of the tool call that this result is associated with.
+     */
     toolCallId: string;
+    /**
+     * Name of the tool that generated this result.
+     */
     toolName: string;
     /**
-  Stringified JSON object with the tool call arguments. Must match the
-  parameters schema of the tool.
+     * Result of the tool call. This is a JSON-serializable object.
+     */
+    result: unknown;
+    /**
+     * Optional flag if the result is an error or an error message.
+     */
+    isError?: boolean;
+    /**
+     * Whether the tool result was generated by the provider.
+     * If this flag is set to true, the tool result was generated by the provider.
+     * If this flag is not set or is false, the tool result was generated by the client.
+     */
+    providerExecuted?: boolean;
+    /**
+     * Additional provider-specific metadata for the tool result.
      */
-    args: string;
+    providerMetadata?: SharedV2ProviderMetadata;
 };
 
-type LanguageModelV2Content = LanguageModelV2Text | LanguageModelV2Reasoning | LanguageModelV2File | LanguageModelV2Source | LanguageModelV2ToolCall;
+type LanguageModelV2Content = LanguageModelV2Text | LanguageModelV2Reasoning | LanguageModelV2File | LanguageModelV2Source | LanguageModelV2ToolCall | LanguageModelV2ToolResult;
 
 /**
 Reason why a language model finished generating a response.
@@ -1000,38 +1095,91 @@ interface LanguageModelV2ResponseMetadata {
     modelId?: string;
 }
 
-type LanguageModelV2ToolCallDelta = {
-    type: 'tool-call-delta';
-    toolCallType: 'function';
-    toolCallId: string;
-    toolName: string;
-    argsTextDelta: string;
-};
-
 /**
- * Usage information for a language model call.
+Usage information for a language model call.
+
+If your API return additional usage information, you can add it to the
+provider metadata under your provider's key.
  */
 type LanguageModelV2Usage = {
     /**
-     * The number of input (prompt) tokens used.
+  The number of input (prompt) tokens used.
      */
     inputTokens: number | undefined;
     /**
-     * The number of output (completion) tokens used.
+  The number of output (completion) tokens used.
      */
     outputTokens: number | undefined;
+    /**
+  The total number of tokens as reported by the provider.
+  This number might be different from the sum of `inputTokens` and `outputTokens`
+  and e.g. include reasoning tokens or other overhead.
+     */
+    totalTokens: number | undefined;
+    /**
+  The number of reasoning tokens used.
+     */
+    reasoningTokens?: number | undefined;
+    /**
+  The number of cached input tokens.
+     */
+    cachedInputTokens?: number | undefined;
 };
 
-type LanguageModelV2StreamPart = LanguageModelV2Content | LanguageModelV2ToolCallDelta | {
+type LanguageModelV2StreamPart = {
+    type: 'text-start';
+    providerMetadata?: SharedV2ProviderMetadata;
+    id: string;
+} | {
+    type: 'text-delta';
+    id: string;
+    providerMetadata?: SharedV2ProviderMetadata;
+    delta: string;
+} | {
+    type: 'text-end';
+    providerMetadata?: SharedV2ProviderMetadata;
+    id: string;
+} | {
+    type: 'reasoning-start';
+    providerMetadata?: SharedV2ProviderMetadata;
+    id: string;
+} | {
+    type: 'reasoning-delta';
+    id: string;
+    providerMetadata?: SharedV2ProviderMetadata;
+    delta: string;
+} | {
+    type: 'reasoning-end';
+    id: string;
+    providerMetadata?: SharedV2ProviderMetadata;
+} | {
+    type: 'tool-input-start';
+    id: string;
+    toolName: string;
+    providerMetadata?: SharedV2ProviderMetadata;
+    providerExecuted?: boolean;
+} | {
+    type: 'tool-input-delta';
+    id: string;
+    delta: string;
+    providerMetadata?: SharedV2ProviderMetadata;
+} | {
+    type: 'tool-input-end';
+    id: string;
+    providerMetadata?: SharedV2ProviderMetadata;
+} | LanguageModelV2ToolCall | LanguageModelV2ToolResult | LanguageModelV2File | LanguageModelV2Source | {
     type: 'stream-start';
     warnings: Array<LanguageModelV2CallWarning>;
 } | ({
     type: 'response-metadata';
 } & LanguageModelV2ResponseMetadata) | {
     type: 'finish';
+    usage: LanguageModelV2Usage;
     finishReason: LanguageModelV2FinishReason;
     providerMetadata?: SharedV2ProviderMetadata;
-    usage: LanguageModelV2Usage;
+} | {
+    type: 'raw';
+    rawValue: unknown;
 } | {
     type: 'error';
     error: unknown;
@@ -1042,11 +1190,7 @@ Specification for a language model that implements the language model interface
  */
 type LanguageModelV2 = {
     /**
-  The language model must specify which language model interface
-  version it implements. This will allow us to evolve the language
-  model interface and retain backwards compatibility. The different
-  implementation versions can be handled as a discriminated union
-  on our side.
+  The language model must specify which language model interface version it implements.
      */
     readonly specificationVersion: 'v2';
     /**
@@ -1058,17 +1202,18 @@ type LanguageModelV2 = {
      */
     readonly modelId: string;
     /**
-     * Returns a map of supported URL patterns for the model.
-     * The keys are media type patterns or full media types (e.g. `*\/*` for everything, `audio/*`, `video/*`, or `application/pdf`).
-     * and the values are arrays of regular expressions that match the URL paths.
-     *
-     * The matching should be against lower-case URLs.
-     *
-     * Matched URLs are supported natively by the model and are not downloaded.
-     *
-     * @returns A promise resolving to a map of supported URL patterns.
+  Supported URL patterns by media type for the provider.
+  
+  The keys are media type patterns or full media types (e.g. `*\/*` for everything, `audio/*`, `video/*`, or `application/pdf`).
+  and the values are arrays of regular expressions that match the URL paths.
+  
+  The matching should be against lower-case URLs.
+  
+  Matched URLs are supported natively by the model and are not downloaded.
+  
+  @returns A map of supported URL patterns by media type (as a promise or a plain object).
      */
-    getSupportedUrls(): PromiseLike<Record<string, RegExp[]>>;
+    supportedUrls: PromiseLike<Record<string, RegExp[]>> | Record<string, RegExp[]>;
     /**
   Generates a language model output (non-streaming).
   
@@ -1162,6 +1307,27 @@ type LanguageModelV2Middleware = {
      * Middleware specification version. Use `v2` for the current version.
      */
     middlewareVersion?: 'v2' | undefined;
+    /**
+     * Override the provider name if desired.
+     * @param options.model - The language model instance.
+     */
+    overrideProvider?: (options: {
+        model: LanguageModelV2;
+    }) => string;
+    /**
+     * Override the model ID if desired.
+     * @param options.model - The language model instance.
+     */
+    overrideModelId?: (options: {
+        model: LanguageModelV2;
+    }) => string;
+    /**
+     * Override the supported URLs if desired.
+     * @param options.model - The language model instance.
+     */
+    overrideSupportedUrls?: (options: {
+        model: LanguageModelV2;
+    }) => PromiseLike<Record<string, RegExp[]>> | Record<string, RegExp[]>;
     /**
      * Transforms the parameters before they are passed to the language model.
      * @param options - Object containing the type of operation and the parameters.
@@ -1172,6 +1338,7 @@ type LanguageModelV2Middleware = {
     transformParams?: (options: {
         type: 'generate' | 'stream';
         params: LanguageModelV2CallOptions;
+        model: LanguageModelV2;
     }) => PromiseLike<LanguageModelV2CallOptions>;
     /**
      * Wraps the generate operation of the language model.
@@ -1208,467 +1375,65 @@ type LanguageModelV2Middleware = {
     }) => PromiseLike<Awaited<ReturnType<LanguageModelV2['doStream']>>>;
 };
 
-/**
- * Additional provider-specific metadata. They are passed through
- * to the provider from the AI SDK and enable provider-specific
- * functionality that can be fully encapsulated in the provider.
- *
- * This enables us to quickly ship provider-specific functionality
- * without affecting the core AI SDK.
- *
- * The outer record is keyed by the provider name, and the inner
- * record is keyed by the provider-specific metadata key.
- *
- * ```ts
- * {
- *   "anthropic": {
- *     "cacheControl": { "type": "ephemeral" }
- *   }
- * }
- * ```
- */
-type LanguageModelV1ProviderMetadata = Record<string, Record<string, JSONValue>>;
-
-/**
- * A source that has been used as input to generate the response.
- */
-type LanguageModelV1Source = {
-    /**
-     * A URL source. This is return by web search RAG models.
-     */
-    sourceType: 'url';
+type SpeechModelV2ProviderOptions = Record<string, Record<string, JSONValue>>;
+type SpeechModelV2CallOptions = {
     /**
-     * The ID of the source.
+     * Text to convert to speech.
      */
-    id: string;
+    text: string;
     /**
-     * The URL of the source.
+     * The voice to use for speech synthesis.
+     * This is provider-specific and may be a voice ID, name, or other identifier.
      */
-    url: string;
+    voice?: string;
     /**
-     * The title of the source.
+     * The desired output format for the audio e.g. "mp3", "wav", etc.
      */
-    title?: string;
+    outputFormat?: string;
     /**
-     * Additional provider metadata for the source.
+     * Instructions for the speech generation e.g. "Speak in a slow and steady tone".
      */
-    providerMetadata?: LanguageModelV1ProviderMetadata;
-};
-
-type LanguageModelV1CallSettings = {
+    instructions?: string;
     /**
-  Maximum number of tokens to generate.
+     * The speed of the speech generation.
      */
-    maxTokens?: number;
+    speed?: number;
     /**
-  Temperature setting.
-  
-  It is recommended to set either `temperature` or `topP`, but not both.
+     * The language for speech generation. This should be an ISO 639-1 language code (e.g. "en", "es", "fr")
+     * or "auto" for automatic language detection. Provider support varies.
      */
-    temperature?: number;
+    language?: string;
     /**
-  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[];
-    /**
-  Nucleus sampling.
-  
-  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.
-     */
-    presencePenalty?: number;
-    /**
-  Frequency penalty setting. It affects the likelihood of the model
-  to repeatedly use the same words or phrases.
-     */
-    frequencyPenalty?: number;
-    /**
-  Response format. The output can either be text or JSON. Default is text.
-  
-  If JSON is selected, a schema can optionally be provided to guide the LLM.
-     */
-    responseFormat?: {
-        type: 'text';
-    } | {
-        type: 'json';
-        /**
-         * JSON schema that the generated output should conform to.
-         */
-        schema?: JSONSchema7;
-        /**
-         * Name of output that should be generated. Used by some providers for additional LLM guidance.
-         */
-        name?: string;
-        /**
-         * Description of the output that should be generated. Used by some providers for additional LLM guidance.
-         */
-        description?: string;
-    };
-    /**
-  The seed (integer) to use for random sampling. If set and supported
-  by the model, calls will generate deterministic results.
+     * 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": {}
+     * }
+     * ```
      */
-    seed?: number;
+    providerOptions?: SpeechModelV2ProviderOptions;
     /**
-  Abort signal for cancelling the operation.
+     * Abort signal for cancelling the operation.
      */
     abortSignal?: AbortSignal;
     /**
-  Additional HTTP headers to be sent with the request.
-  Only applicable for HTTP-based providers.
+     * Additional HTTP headers to be sent with the request.
+     * Only applicable for HTTP-based providers.
      */
     headers?: Record<string, string | undefined>;
 };
 
 /**
-A tool has a name, a description, and a set of parameters.
-
-Note: this is **not** the user-facing tool definition. The AI SDK methods will
-map the user-facing tool definitions to this format.
- */
-type LanguageModelV1FunctionTool = {
-    /**
-  The type of the tool (always 'function').
-     */
-    type: 'function';
-    /**
-  The name of the tool. Unique within this model call.
-     */
-    name: string;
-    /**
-  A description of the tool. The language model uses this to understand the
-  tool's purpose and to provide better completion suggestions.
-     */
-    description?: string;
-    /**
-  The parameters that the tool expects. The language model uses this to
-  understand the tool's input requirements and to provide matching suggestions.
-     */
-    parameters: JSONSchema7;
-};
-
-/**
-A prompt is a list of messages.
-
-Note: Not all models and prompt formats support multi-modal inputs and
-tool calls. The validation happens at runtime.
-
-Note: This is not a user-facing prompt. The AI SDK methods will map the
-user-facing prompt types such as chat or instruction prompts to this format.
- */
-type LanguageModelV1Prompt = Array<LanguageModelV1Message>;
-type LanguageModelV1Message = ({
-    role: 'system';
-    content: string;
-} | {
-    role: 'user';
-    content: Array<LanguageModelV1TextPart | LanguageModelV1ImagePart | LanguageModelV1FilePart>;
-} | {
-    role: 'assistant';
-    content: Array<LanguageModelV1TextPart | LanguageModelV1FilePart | LanguageModelV1ReasoningPart | LanguageModelV1RedactedReasoningPart | LanguageModelV1ToolCallPart>;
-} | {
-    role: 'tool';
-    content: Array<LanguageModelV1ToolResultPart>;
-}) & {
-    /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerMetadata?: LanguageModelV1ProviderMetadata;
-};
-/**
-Text content part of a prompt. It contains a string of text.
- */
-interface LanguageModelV1TextPart {
-    type: 'text';
-    /**
-  The text content.
-     */
-    text: string;
-    /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerMetadata?: LanguageModelV1ProviderMetadata;
-}
-/**
-Reasoning content part of a prompt. It contains a string of reasoning text.
- */
-interface LanguageModelV1ReasoningPart {
-    type: 'reasoning';
-    /**
-  The reasoning text.
-     */
-    text: string;
-    /**
-  An optional signature for verifying that the reasoning originated from the model.
-     */
-    signature?: string;
-    /**
-  Additional provider-specific metadata. They are passed through
-  to the provider from the AI SDK and enable provider-specific
-  functionality that can be fully encapsulated in the provider.
-     */
-    providerMetadata?: LanguageModelV1ProviderMetadata;
-}
-/**
-Redacted reasoning content part of a prompt.
- */
-interface LanguageModelV1RedactedReasoningPart {
-    type: 'redacted-reasoning';
-    /**
-  Redacted reasoning data.
-     */
-    data: string;
-    /**
-  Additional provider-specific metadata. They are passed through
-  to the provider from the AI SDK and enable provider-specific
-  functionality that can be fully encapsulated in the provider.
-     */
-    providerMetadata?: LanguageModelV1ProviderMetadata;
-}
-/**
-Image content part of a prompt. It contains an image.
- */
-interface LanguageModelV1ImagePart {
-    type: 'image';
-    /**
-  Image data as a Uint8Array (e.g. from a Blob or Buffer) or a URL.
-     */
-    image: Uint8Array | URL;
-    /**
-  Optional mime type of the image.
-     */
-    mimeType?: string;
-    /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerMetadata?: LanguageModelV1ProviderMetadata;
-}
-/**
-File content part of a prompt. It contains a file.
- */
-interface LanguageModelV1FilePart {
-    type: 'file';
-    /**
-     * Optional filename of the file.
-     */
-    filename?: string;
-    /**
-  File data as base64 encoded string or as a URL.
-     */
-    data: string | URL;
-    /**
-  Mime type of the file.
-     */
-    mimeType: string;
-    /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerMetadata?: LanguageModelV1ProviderMetadata;
-}
-/**
-Tool call content part of a prompt. It contains a tool call (usually generated by the AI model).
- */
-interface LanguageModelV1ToolCallPart {
-    type: 'tool-call';
-    /**
-  ID of the tool call. This ID is used to match the tool call with the tool result.
-   */
-    toolCallId: string;
-    /**
-  Name of the tool that is being called.
-   */
-    toolName: string;
-    /**
-  Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
-     */
-    args: unknown;
-    /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerMetadata?: LanguageModelV1ProviderMetadata;
-}
-/**
-Tool result content part of a prompt. It contains the result of the tool call with the matching ID.
- */
-interface LanguageModelV1ToolResultPart {
-    type: 'tool-result';
-    /**
-  ID of the tool call that this result is associated with.
-   */
-    toolCallId: string;
-    /**
-  Name of the tool that generated this result.
-    */
-    toolName: string;
-    /**
-  Result of the tool call. This is a JSON-serializable object.
-     */
-    result: unknown;
-    /**
-  Optional flag if the result is an error or an error message.
-     */
-    isError?: boolean;
-    /**
-  Tool results as an array of parts. This enables advanced tool results including images.
-  When this is used, the `result` field should be ignored (if the provider supports content).
-     */
-    content?: Array<{
-        type: 'text';
-        /**
-Text content.
-         */
-        text: string;
-    } | {
-        type: 'image';
-        /**
-base-64 encoded image data
-         */
-        data: string;
-        /**
-Mime type of the image.
-         */
-        mimeType?: string;
-    }>;
-    /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerMetadata?: LanguageModelV1ProviderMetadata;
-}
-
-/**
-The configuration of a tool that is defined by the provider.
- */
-type LanguageModelV1ProviderDefinedTool = {
-    /**
-  The type of the tool (always 'provider-defined').
-     */
-    type: 'provider-defined';
-    /**
-  The ID of the tool. Should follow the format `<provider-name>.<tool-name>`.
-     */
-    id: `${string}.${string}`;
-    /**
-  The name of the tool. Unique within this model call.
-     */
-    name: string;
-    /**
-  The arguments for configuring the tool. Must match the expected arguments defined by the provider for this tool.
-    */
-    args: Record<string, unknown>;
-};
-
-type LanguageModelV1ToolChoice = {
-    type: 'auto';
-} | {
-    type: 'none';
-} | {
-    type: 'required';
-} | {
-    type: 'tool';
-    toolName: string;
-};
-
-type LanguageModelV1CallOptions = LanguageModelV1CallSettings & {
-    /**
-  Whether the user provided the input as messages or as
-  a prompt. This can help guide non-chat models in the
-  expansion, bc different expansions can be needed for
-  chat/non-chat use cases.
-     */
-    inputFormat: 'messages' | 'prompt';
-    /**
-  The mode affects the behavior of the language model. It is required to
-  support provider-independent streaming and generation of structured objects.
-  The model can take this information and e.g. configure json mode, the correct
-  low level grammar, etc. It can also be used to optimize the efficiency of the
-  streaming, e.g. tool-delta stream parts are only needed in the
-  object-tool mode.
-  
-  @deprecated mode will be removed in v2.
-  All necessary settings will be directly supported through the call settings,
-  in particular responseFormat, toolChoice, and tools.
-     */
-    mode: {
-        type: 'regular';
-        /**
-The tools that are available for the model.
-         */
-        tools?: Array<LanguageModelV1FunctionTool | LanguageModelV1ProviderDefinedTool>;
-        /**
-Specifies how the tool should be selected. Defaults to 'auto'.
-         */
-        toolChoice?: LanguageModelV1ToolChoice;
-    } | {
-        type: 'object-json';
-        /**
-         * JSON schema that the generated output should conform to.
-         */
-        schema?: JSONSchema7;
-        /**
-         * Name of output that should be generated. Used by some providers for additional LLM guidance.
-         */
-        name?: string;
-        /**
-         * Description of the output that should be generated. Used by some providers for additional LLM guidance.
-         */
-        description?: string;
-    } | {
-        type: 'object-tool';
-        tool: LanguageModelV1FunctionTool;
-    };
-    /**
-  A language mode prompt is a standardized prompt type.
-  
-  Note: This is **not** the user-facing prompt. The AI SDK methods will map the
-  user-facing prompt types such as chat or instruction prompts to this format.
-  That approach allows us to evolve the user  facing prompts without breaking
-  the language model interface.
-     */
-    prompt: LanguageModelV1Prompt;
-    /**
-  Additional provider-specific metadata.
-  The metadata is passed through to the provider from the AI SDK and enables
-  provider-specific functionality that can be fully encapsulated in the provider.
-     */
-    providerMetadata?: LanguageModelV1ProviderMetadata;
-};
-
-/**
-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.
+ * 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.
  */
-type LanguageModelV1CallWarning = {
+type SpeechModelV2CallWarning = {
     type: 'unsupported-setting';
-    setting: keyof LanguageModelV1CallSettings;
-    details?: string;
-} | {
-    type: 'unsupported-tool';
-    tool: LanguageModelV1FunctionTool | LanguageModelV1ProviderDefinedTool;
+    setting: keyof SpeechModelV2CallOptions;
     details?: string;
 } | {
     type: 'other';
@@ -1676,341 +1441,82 @@ type LanguageModelV1CallWarning = {
 };
 
 /**
-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
-- `unknown`: the model has not transmitted a finish reason
- */
-type LanguageModelV1FinishReason = 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other' | 'unknown';
-
-type LanguageModelV1FunctionToolCall = {
-    toolCallType: 'function';
-    toolCallId: string;
-    toolName: string;
-    /**
-  Stringified JSON object with the tool call arguments. Must match the
-  parameters schema of the tool.
-     */
-    args: string;
-};
-
-/**
-Log probabilities for each token and its top log probabilities.
- */
-type LanguageModelV1LogProbs = Array<{
-    token: string;
-    logprob: number;
-    topLogprobs: Array<{
-        token: string;
-        logprob: number;
-    }>;
-}>;
-
-/**
-Specification for a language model that implements the language model interface version 1.
+ * Speech model specification version 2.
  */
-type LanguageModelV1 = {
+type SpeechModelV2 = {
     /**
-  The language model must specify which language model interface
-  version it implements. This will allow us to evolve the language
-  model interface and retain backwards compatibility. The different
-  implementation versions can be handled as a discriminated union
-  on our side.
+     * The speech model must specify which speech model interface
+     * version it implements. This will allow us to evolve the speech
+     * model interface and retain backwards compatibility. The different
+     * implementation versions can be handled as a discriminated union
+     * on our side.
      */
-    readonly specificationVersion: 'v1';
+    readonly specificationVersion: 'v2';
     /**
-  Name of the provider for logging purposes.
+     * Name of the provider for logging purposes.
      */
     readonly provider: string;
     /**
-  Provider-specific model ID for logging purposes.
+     * Provider-specific model ID for logging purposes.
      */
     readonly modelId: string;
     /**
-  Default object generation mode that should be used with this model when
-  no mode is specified. Should be the mode with the best results for this
-  model. `undefined` can be returned if object generation is not supported.
-  
-  This is needed to generate the best objects possible w/o requiring the
-  user to explicitly specify the object generation mode.
-     */
-    readonly defaultObjectGenerationMode: LanguageModelV1ObjectGenerationMode;
-    /**
-  Flag whether this model supports image URLs. Default is `true`.
-  
-  When the flag is set to `false`, the AI SDK will download the image and
-  pass the image data to the model.
-     */
-    readonly supportsImageUrls?: boolean;
-    /**
-  Flag whether this model supports grammar-guided generation,
-  i.e. follows JSON schemas for object generation
-  when the response format is set to 'json' or
-  when the `object-json` mode is used.
-  
-  This means that the model guarantees that the generated JSON
-  will be a valid JSON object AND that the object will match the
-  JSON schema.
-  
-  Please note that `generateObject` and `streamObject` will work
-  regardless of this flag, but might send different prompts and
-  use further optimizations if this flag is set to `true`.
-  
-  Defaults to `false`.
-  */
-    readonly supportsStructuredOutputs?: boolean;
-    /**
-  Checks if the model supports the given URL for file parts natively.
-  If the model does not support the URL,
-  the AI SDK will download the file and pass the file data to the model.
-  
-  When undefined, the AI SDK will download the file.
-     */
-    supportsUrl?(url: URL): boolean;
-    /**
-  Generates a language model output (non-streaming).
-  
-  Naming: "do" prefix to prevent accidental direct usage of the method
-  by the user.
-     */
-    doGenerate(options: LanguageModelV1CallOptions): PromiseLike<{
-        /**
-    Text that the model has generated.
-    Can be undefined if the model did not generate any text.
-         */
-        text?: string;
-        /**
-    Reasoning that the model has generated.
-    Can be undefined if the model does not support reasoning.
-         */
-        reasoning?: string | Array<{
-            type: 'text';
-            text: string;
-            /**
-An optional signature for verifying that the reasoning originated from the model.
- */
-            signature?: string;
-        } | {
-            type: 'redacted';
-            data: string;
-        }>;
-        /**
-    Generated files as base64 encoded strings or binary data.
-    The files should be returned without any unnecessary conversion.
-    If the API returns base64 encoded strings, the files should be returned
-    as base64 encoded strings. If the API returns binary data, the files should
-    be returned as binary data.
-         */
-        files?: Array<{
-            data: string | Uint8Array;
-            mimeType: string;
-        }>;
-        /**
-    Tool calls that the model has generated.
-    Can be undefined if the model did not generate any tool calls.
-         */
-        toolCalls?: Array<LanguageModelV1FunctionToolCall>;
-        /**
-    Finish reason.
-         */
-        finishReason: LanguageModelV1FinishReason;
-        /**
-      Usage information.
-         */
-        usage: {
-            promptTokens: number;
-            completionTokens: number;
-        };
-        /**
-    Raw prompt and setting information for observability provider integration.
-         */
-        rawCall: {
-            /**
-      Raw prompt after expansion and conversion to the format that the
-      provider uses to send the information to their API.
-             */
-            rawPrompt: unknown;
-            /**
-      Raw settings that are used for the API call. Includes provider-specific
-      settings.
-             */
-            rawSettings: Record<string, unknown>;
-        };
-        /**
-    Optional response information for telemetry and debugging purposes.
-         */
-        rawResponse?: {
-            /**
-      Response headers.
-            */
-            headers?: Record<string, string>;
-            /**
-      Response body.
-            */
-            body?: unknown;
-        };
-        /**
-    Optional request information for telemetry and debugging purposes.
-         */
-        request?: {
-            /**
-      Raw request HTTP body that was sent to the provider API as a string (JSON should be stringified).
-      Non-HTTP(s) providers should not set this.
-             */
-            body?: string;
-        };
-        /**
-    Optional response information for telemetry and debugging purposes.
-         */
-        response?: {
-            /**
-      ID for the generated response, if the provider sends one.
-           */
-            id?: string;
-            /**
-      Timestamp for the start of the generated response, if the provider sends one.
-           */
-            timestamp?: Date;
-            /**
-      The ID of the response model that was used to generate the response, if the provider sends one.
-           */
-            modelId?: string;
-        };
-        warnings?: LanguageModelV1CallWarning[];
+     * Generates speech audio from text.
+     */
+    doGenerate(options: SpeechModelV2CallOptions): PromiseLike<{
         /**
-    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.
+         * Generated audio as an ArrayBuffer.
+         * The audio should be returned without any unnecessary conversion.
+         * If the API returns base64 encoded strings, the audio should be returned
+         * as base64 encoded strings. If the API returns binary data, the audio
+         * should be returned as binary data.
          */
-        providerMetadata?: LanguageModelV1ProviderMetadata;
+        audio: string | Uint8Array;
         /**
-    Sources that have been used as input to generate the response.
+         * Warnings for the call, e.g. unsupported settings.
          */
-        sources?: LanguageModelV1Source[];
+        warnings: Array<SpeechModelV2CallWarning>;
         /**
-    Logprobs for the completion.
-    `undefined` if the mode does not support logprobs or if was not enabled
-    
-    @deprecated will be changed into a provider-specific extension in v2
+         * Optional request information for telemetry and debugging purposes.
          */
-        logprobs?: LanguageModelV1LogProbs;
-    }>;
-    /**
-  Generates a language model output (streaming).
-  
-  Naming: "do" prefix to prevent accidental direct usage of the method
-  by the user.
-     *
-  @return A stream of higher-level language model output parts.
-     */
-    doStream(options: LanguageModelV1CallOptions): PromiseLike<{
-        stream: ReadableStream<LanguageModelV1StreamPart>;
+        request?: {
+            /**
+             * Response body (available only for providers that use HTTP requests).
+             */
+            body?: unknown;
+        };
         /**
-    Raw prompt and setting information for observability provider integration.
+         * Response information for telemetry and debugging purposes.
          */
-        rawCall: {
+        response: {
             /**
-      Raw prompt after expansion and conversion to the format that the
-      provider uses to send the information to their API.
+             * Timestamp for the start of the generated response.
              */
-            rawPrompt: unknown;
+            timestamp: Date;
             /**
-      Raw settings that are used for the API call. Includes provider-specific
-      settings.
+             * The ID of the response model that was used to generate the response.
              */
-            rawSettings: Record<string, unknown>;
-        };
-        /**
-    Optional raw response data.
-         */
-        rawResponse?: {
+            modelId: string;
             /**
-      Response headers.
+             * Response headers.
              */
-            headers?: Record<string, string>;
-        };
-        /**
-    Optional request information for telemetry and debugging purposes.
-         */
-        request?: {
+            headers?: SharedV2Headers;
             /**
-      Raw request HTTP body that was sent to the provider API as a string (JSON should be stringified).
-      Non-HTTP(s) providers should not set this.
-         */
-            body?: string;
+             * Response body.
+             */
+            body?: unknown;
         };
         /**
-    Warnings for the call, e.g. unsupported settings.
+         * 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.
          */
-        warnings?: Array<LanguageModelV1CallWarning>;
+        providerMetadata?: Record<string, Record<string, JSONValue>>;
     }>;
 };
-type LanguageModelV1StreamPart = {
-    type: 'text-delta';
-    textDelta: string;
-} | {
-    type: 'reasoning';
-    textDelta: string;
-} | {
-    type: 'reasoning-signature';
-    signature: string;
-} | {
-    type: 'redacted-reasoning';
-    data: string;
-} | {
-    type: 'source';
-    source: LanguageModelV1Source;
-} | {
-    type: 'file';
-    mimeType: 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;
-} | ({
-    type: 'tool-call';
-} & LanguageModelV1FunctionToolCall) | {
-    type: 'tool-call-delta';
-    toolCallType: 'function';
-    toolCallId: string;
-    toolName: string;
-    argsTextDelta: string;
-} | {
-    type: 'response-metadata';
-    id?: string;
-    timestamp?: Date;
-    modelId?: string;
-} | {
-    type: 'finish';
-    finishReason: LanguageModelV1FinishReason;
-    providerMetadata?: LanguageModelV1ProviderMetadata;
-    usage: {
-        promptTokens: number;
-        completionTokens: number;
-    };
-    logprobs?: LanguageModelV1LogProbs;
-} | {
-    type: 'error';
-    error: unknown;
-};
-/**
-The object generation modes available for use with a model. `undefined`
-represents no support for object generation.
-   */
-type LanguageModelV1ObjectGenerationMode = 'json' | 'tool' | undefined;
 
-type TranscriptionModelV1ProviderOptions = Record<string, Record<string, JSONValue>>;
-type TranscriptionModelV1CallOptions = {
+type TranscriptionModelV2ProviderOptions = Record<string, Record<string, JSONValue>>;
+type TranscriptionModelV2CallOptions = {
     /**
   Audio data to transcribe.
   Accepts a `Uint8Array` or `string`, where `string` is a base64 encoded audio file.
@@ -2036,7 +1542,7 @@ type TranscriptionModelV1CallOptions = {
   }
   ```
    */
-    providerOptions?: TranscriptionModelV1ProviderOptions;
+    providerOptions?: TranscriptionModelV2ProviderOptions;
     /**
   Abort signal for cancelling the operation.
    */
@@ -2052,9 +1558,9 @@ type TranscriptionModelV1CallOptions = {
 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.
  */
-type TranscriptionModelV1CallWarning = {
+type TranscriptionModelV2CallWarning = {
     type: 'unsupported-setting';
-    setting: keyof TranscriptionModelV1CallOptions;
+    setting: keyof TranscriptionModelV2CallOptions;
     details?: string;
 } | {
     type: 'other';
@@ -2062,9 +1568,9 @@ type TranscriptionModelV1CallWarning = {
 };
 
 /**
-Transcription model specification version 1.
+Transcription model specification version 2.
  */
-type TranscriptionModelV1 = {
+type TranscriptionModelV2 = {
     /**
   The transcription model must specify which transcription model interface
   version it implements. This will allow us to evolve the transcription
@@ -2072,7 +1578,7 @@ type TranscriptionModelV1 = {
   implementation versions can be handled as a discriminated union
   on our side.
      */
-    readonly specificationVersion: 'v1';
+    readonly specificationVersion: 'v2';
     /**
   Name of the provider for logging purposes.
      */
@@ -2084,7 +1590,7 @@ type TranscriptionModelV1 = {
     /**
   Generates a transcript.
      */
-    doGenerate(options: TranscriptionModelV1CallOptions): PromiseLike<{
+    doGenerate(options: TranscriptionModelV2CallOptions): PromiseLike<{
         /**
          * The complete transcribed text from the audio.
          */
@@ -2120,7 +1626,7 @@ type TranscriptionModelV1 = {
         /**
     Warnings for the call, e.g. unsupported settings.
          */
-        warnings: Array<TranscriptionModelV1CallWarning>;
+        warnings: Array<TranscriptionModelV2CallWarning>;
         /**
     Optional request information for telemetry and debugging purposes.
          */
@@ -2161,145 +1667,10 @@ type TranscriptionModelV1 = {
     }>;
 };
 
-type SpeechModelV1ProviderOptions = Record<string, Record<string, JSONValue>>;
-type SpeechModelV1CallOptions = {
-    /**
-     * Text to convert to speech.
-     */
-    text: string;
-    /**
-     * The voice to use for speech synthesis.
-     * This is provider-specific and may be a voice ID, name, or other identifier.
-     */
-    voice?: string;
-    /**
-     * The desired output format for the audio e.g. "mp3", "wav", etc.
-     */
-    outputFormat?: string;
-    /**
-     * Instructions for the speech generation e.g. "Speak in a slow and steady tone".
-     */
-    instructions?: string;
-    /**
-     * The speed of the speech generation.
-     */
-    speed?: 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": {}
-     * }
-     * ```
-     */
-    providerOptions?: SpeechModelV1ProviderOptions;
-    /**
-     * 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>;
-};
-
-/**
- * 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.
- */
-type SpeechModelV1CallWarning = {
-    type: 'unsupported-setting';
-    setting: keyof SpeechModelV1CallOptions;
-    details?: string;
-} | {
-    type: 'other';
-    message: string;
-};
-
-/**
- * Speech model specification version 1.
- */
-type SpeechModelV1 = {
-    /**
-     * The speech model must specify which speech model interface
-     * version it implements. This will allow us to evolve the speech
-     * model interface and retain backwards compatibility. The different
-     * implementation versions can be handled as a discriminated union
-     * on our side.
-     */
-    readonly specificationVersion: 'v1';
-    /**
-     * Name of the provider for logging purposes.
-     */
-    readonly provider: string;
-    /**
-     * Provider-specific model ID for logging purposes.
-     */
-    readonly modelId: string;
-    /**
-     * Generates speech audio from text.
-     */
-    doGenerate(options: SpeechModelV1CallOptions): PromiseLike<{
-        /**
-         * Generated audio as an ArrayBuffer.
-         * The audio should be returned without any unnecessary conversion.
-         * If the API returns base64 encoded strings, the audio should be returned
-         * as base64 encoded strings. If the API returns binary data, the audio
-         * should be returned as binary data.
-         */
-        audio: string | Uint8Array;
-        /**
-         * Warnings for the call, e.g. unsupported settings.
-         */
-        warnings: Array<SpeechModelV1CallWarning>;
-        /**
-         * Optional request information for telemetry and debugging purposes.
-         */
-        request?: {
-            /**
-             * Response body (available only for providers that use HTTP requests).
-             */
-            body?: unknown;
-        };
-        /**
-         * 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?: SharedV2Headers;
-            /**
-             * Response body.
-             */
-            body?: unknown;
-        };
-        /**
-         * 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.
-         */
-        providerMetadata?: Record<string, Record<string, JSONValue>>;
-    }>;
-};
-
 /**
  * Provider for language, text embedding, and image generation models.
  */
-interface ProviderV1 {
+interface ProviderV2 {
     /**
   Returns the language model with the given id.
   The model id is then passed to the provider function to get the model.
@@ -2310,7 +1681,7 @@ interface ProviderV1 {
   
   @throws {NoSuchModelError} If no such model exists.
      */
-    languageModel(modelId: string): LanguageModelV1;
+    languageModel(modelId: string): LanguageModelV2;
     /**
   Returns the text embedding model with the given id.
   The model id is then passed to the provider function to get the model.
@@ -2330,7 +1701,7 @@ interface ProviderV1 {
   
   @returns {ImageModel} The image model associated with the id
   */
-    readonly imageModel?: (modelId: string) => ImageModelV1;
+    imageModel(modelId: string): ImageModelV2;
     /**
   Returns the transcription model with the given id.
   The model id is then passed to the provider function to get the model.
@@ -2338,8 +1709,8 @@ interface ProviderV1 {
   @param {string} modelId - The id of the model to return.
   
   @returns {TranscriptionModel} The transcription model associated with the id
-  */
-    readonly transcriptionModel?: (modelId: string) => TranscriptionModelV1;
+    */
+    transcriptionModel?(modelId: string): TranscriptionModelV2;
     /**
   Returns the speech model with the given id.
   The model id is then passed to the provider function to get the model.
@@ -2347,45 +1718,8 @@ interface ProviderV1 {
   @param {string} modelId - The id of the model to return.
   
   @returns {SpeechModel} The speech model associated with the id
-  */
-    readonly speechModel?: (modelId: string) => SpeechModelV1;
-}
-
-/**
- * Provider for language, text embedding, and image generation models.
- */
-interface ProviderV2 {
-    /**
-  Returns the language model with the given id.
-  The model id is then passed to the provider function to get the model.
-  
-  @param {string} modelId - The id of the model to return.
-  
-  @returns {LanguageModel} The language model associated with the id
-  
-  @throws {NoSuchModelError} If no such model exists.
-     */
-    languageModel(modelId: string): LanguageModelV2;
-    /**
-  Returns the text embedding model with the given id.
-  The model id is then passed to the provider function to get the model.
-  
-  @param {string} modelId - The id of the model to return.
-  
-  @returns {LanguageModel} The language model associated with the id
-  
-  @throws {NoSuchModelError} If no such model exists.
-     */
-    textEmbeddingModel(modelId: string): EmbeddingModelV2<string>;
-    /**
-  Returns the image model with the given id.
-  The model id is then passed to the provider function to get the model.
-  
-  @param {string} modelId - The id of the model to return.
-  
-  @returns {ImageModel} The image model associated with the id
-  */
-    readonly imageModel: (modelId: string) => ImageModelV1;
+    */
+    speechModel?(modelId: string): SpeechModelV2;
 }
 
-export { AISDKError, APICallError, type EmbeddingModelV2, type EmbeddingModelV2Embedding, EmptyResponseBodyError, type ImageModelV1, type ImageModelV1CallOptions, type ImageModelV1CallWarning, InvalidArgumentError, InvalidPromptError, InvalidResponseDataError, type JSONArray, type JSONObject, JSONParseError, type JSONValue, type LanguageModelV1, type LanguageModelV1CallOptions, type LanguageModelV1CallWarning, type LanguageModelV1FilePart, type LanguageModelV1FinishReason, type LanguageModelV1FunctionTool, type LanguageModelV1FunctionToolCall, type LanguageModelV1ImagePart, type LanguageModelV1LogProbs, type LanguageModelV1Message, type LanguageModelV1ObjectGenerationMode, type LanguageModelV1Prompt, type LanguageModelV1ProviderDefinedTool, type LanguageModelV1ProviderMetadata, type LanguageModelV1ReasoningPart, type LanguageModelV1RedactedReasoningPart, type LanguageModelV1Source, type LanguageModelV1StreamPart, type LanguageModelV1TextPart, type LanguageModelV1ToolCallPart, type LanguageModelV1ToolChoice, type LanguageModelV1ToolResultPart, type LanguageModelV2, type LanguageModelV2CallOptions, type LanguageModelV2CallWarning, type LanguageModelV2Content, type LanguageModelV2DataContent, type LanguageModelV2File, type LanguageModelV2FilePart, type LanguageModelV2FinishReason, type LanguageModelV2FunctionTool, type LanguageModelV2Message, type LanguageModelV2Middleware, type LanguageModelV2Prompt, type LanguageModelV2ProviderDefinedTool, type LanguageModelV2Reasoning, type LanguageModelV2ReasoningPart, type LanguageModelV2RedactedReasoningPart, type LanguageModelV2ResponseMetadata, type LanguageModelV2Source, type LanguageModelV2StreamPart, type LanguageModelV2Text, type LanguageModelV2TextPart, type LanguageModelV2ToolCall, type LanguageModelV2ToolCallDelta, type LanguageModelV2ToolCallPart, type LanguageModelV2ToolChoice, type LanguageModelV2ToolResultPart, type LanguageModelV2Usage, LoadAPIKeyError, LoadSettingError, NoContentGeneratedError, NoSuchModelError, type ProviderV1, type ProviderV2, type SharedV2Headers, type SharedV2ProviderMetadata, type SharedV2ProviderOptions, type SpeechModelV1, type SpeechModelV1CallOptions, type SpeechModelV1CallWarning, TooManyEmbeddingValuesForCallError, type TranscriptionModelV1, type TranscriptionModelV1CallOptions, type TranscriptionModelV1CallWarning, TypeValidationError, UnsupportedFunctionalityError, getErrorMessage, isJSONArray, isJSONObject, isJSONValue };
+export { AISDKError, APICallError, type EmbeddingModelV2, type EmbeddingModelV2Embedding, EmptyResponseBodyError, type ImageModelV2, type ImageModelV2CallOptions, type ImageModelV2CallWarning, type ImageModelV2ProviderMetadata, InvalidArgumentError, InvalidPromptError, InvalidResponseDataError, type JSONArray, type JSONObject, JSONParseError, type JSONValue, type LanguageModelV2, type LanguageModelV2CallOptions, type LanguageModelV2CallWarning, type LanguageModelV2Content, type LanguageModelV2DataContent, type LanguageModelV2File, type LanguageModelV2FilePart, type LanguageModelV2FinishReason, type LanguageModelV2FunctionTool, type LanguageModelV2Message, type LanguageModelV2Middleware, type LanguageModelV2Prompt, type LanguageModelV2ProviderDefinedTool, type LanguageModelV2Reasoning, type LanguageModelV2ReasoningPart, type LanguageModelV2ResponseMetadata, type LanguageModelV2Source, type LanguageModelV2StreamPart, type LanguageModelV2Text, type LanguageModelV2TextPart, type LanguageModelV2ToolCall, type LanguageModelV2ToolCallPart, type LanguageModelV2ToolChoice, type LanguageModelV2ToolResultOutput, type LanguageModelV2ToolResultPart, type LanguageModelV2Usage, LoadAPIKeyError, LoadSettingError, NoContentGeneratedError, NoSuchModelError, type ProviderV2, type SharedV2Headers, type SharedV2ProviderMetadata, type SharedV2ProviderOptions, type SpeechModelV2, type SpeechModelV2CallOptions, type SpeechModelV2CallWarning, TooManyEmbeddingValuesForCallError, type TranscriptionModelV2, type TranscriptionModelV2CallOptions, type TranscriptionModelV2CallWarning, TypeValidationError, UnsupportedFunctionalityError, getErrorMessage, isJSONArray, isJSONObject, isJSONValue };