@lmnr-ai/lmnr 0.8.48 → 0.8.50

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { C as __exportAll, S as TracingLevel, _ as MaskInputOptions, a as HumanEvaluator, b as SpanType, c as InitializeOptions, d as LaminarClient, f as Dataset, g as LaminarSpanContext, h as Event, i as EvaluatorFunctionReturn, l as EvaluationDataset, m as EvaluationDatapointDatasetLink, o as evaluate, p as EvaluationDatapoint, r as EvaluatorFunction, s as StringUUID, t as Datapoint, u as LaminarDataset, v as PushDatapointsResponse, x as TraceType, y as SessionRecordingOptions } from "./evaluations-CbHnDCAY.cjs";
+import { S as TracingLevel, _ as MaskInputOptions, a as HumanEvaluator, b as SpanType, c as InitializeOptions, d as LaminarClient, f as Dataset, g as LaminarSpanContext, h as Event, i as EvaluatorFunctionReturn, l as EvaluationDataset, m as EvaluationDatapointDatasetLink, o as evaluate, p as EvaluationDatapoint, r as EvaluatorFunction, s as StringUUID, t as Datapoint, u as LaminarDataset, v as PushDatapointsResponse, x as TraceType, y as SessionRecordingOptions } from "./evaluations-C8cI_XIE.cjs";
 import { ServerResponse } from "node:http";
 import { ReadableSpan, SpanExporter, SpanProcessor, TimedEvent } from "@opentelemetry/sdk-trace-base";
 import { AttributeValue, Attributes, Context, Exception, HrTime, Link, Span, Span as Span$1, SpanContext, SpanKind, SpanStatus, TimeInput, Tracer, TracerProvider } from "@opentelemetry/api";
@@ -9,7 +9,6 @@ import { $ZodType } from "zod/v4/core";
 import { ServerResponse as ServerResponse$1 } from "http";
 import { ZodType } from "zod/v4";
 import { Instrumentation } from "@opentelemetry/instrumentation";
-
 //#region src/decorators.d.ts
 interface ObserveOptions {
   name?: string;
@@ -59,7 +58,7 @@ interface ObserveOptions {
  * }, 'hello');
  * ```
  */
-declare function observe<A extends unknown[], F extends (...args: A) => ReturnType<F>>(options: ObserveOptions, fn: F, ...args: A): ReturnType<F>;
+export declare function observe<A extends unknown[], F extends (...args: A) => ReturnType<F>>(options: ObserveOptions, fn: F, ...args: A): ReturnType<F>;
 /**
  * Sets the tracing level for any spans inside the function. This is useful for
  * conditionally disabling the tracing for certain functions.
@@ -79,7 +78,7 @@ declare function observe<A extends unknown[], F extends (...args: A) => ReturnTy
  * });
  * ```
  */
-declare function withTracingLevel<A extends unknown[], F extends (...args: A) => ReturnType<F>>(tracingLevel: TracingLevel, fn: F, ...args: A): ReturnType<F>;
+export declare function withTracingLevel<A extends unknown[], F extends (...args: A) => ReturnType<F>>(tracingLevel: TracingLevel, fn: F, ...args: A): ReturnType<F>;
 /**
  * Decorator that wraps a method to automatically observe it with Laminar tracing.
  * This decorator uses the TypeScript 5.0+ standard decorator syntax.
@@ -121,7 +120,7 @@ declare function withTracingLevel<A extends unknown[], F extends (...args: A) =>
  * }
  * ```
  */
-declare function observeDecorator<This, Args extends unknown[], Return>(config: Partial<ObserveOptions> | ((thisArg: This, ...funcArgs: Args) => Partial<ObserveOptions>)): (originalMethod: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => (this: This, ...args: Args) => Return;
+export declare function observeDecorator<This, Args extends unknown[], Return>(config: Partial<ObserveOptions> | ((thisArg: This, ...funcArgs: Args) => Partial<ObserveOptions>)): (originalMethod: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => (this: This, ...args: Args) => Return;
 /**
  * Decorator that wraps a method to automatically observe it with Laminar tracing.
  * This decorator uses the legacy experimental decorator syntax
@@ -167,7 +166,7 @@ declare function observeDecorator<This, Args extends unknown[], Return>(config:
  * }
  * ```
  */
-declare function observeExperimentalDecorator(config: Partial<ObserveOptions> | ((thisArg: unknown, ...funcArgs: unknown[]) => Partial<ObserveOptions>)): (_target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function observeExperimentalDecorator(config: Partial<ObserveOptions> | ((thisArg: unknown, ...funcArgs: unknown[]) => Partial<ObserveOptions>)): (_target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
 //#endregion
 //#region src/integrations/eve.d.ts
 /**
@@ -358,7 +357,7 @@ interface LaminarReporterOptions {
  * });
  * ```
  */
-declare class LaminarReporter implements EvalReporter {
+export declare class LaminarReporter implements EvalReporter {
   private readonly options;
   private client?;
   private evalId?;
@@ -1136,11 +1135,7 @@ declare class AISDKError extends Error {
    * @param {string} params.message - The error message.
    * @param {unknown} [params.cause] - The underlying cause of the error.
    */
-  constructor({
-    name,
-    message,
-    cause
-  }: {
+  constructor({ name, message, cause }: {
     name: string;
     message: string;
     cause?: unknown;
@@ -1163,18 +1158,7 @@ declare class APICallError extends AISDKError {
   readonly responseBody?: string;
   readonly isRetryable: boolean;
   readonly data?: unknown;
-  constructor({
-    message,
-    url,
-    requestBodyValues,
-    statusCode,
-    responseHeaders,
-    responseBody,
-    cause,
-    isRetryable,
-    // server error
-    data
-  }: {
+  constructor({ message, url, requestBodyValues, statusCode, responseHeaders, responseBody, cause, isRetryable, data }: {
     message: string;
     url: string;
     requestBodyValues: unknown;
@@ -1190,13 +1174,12 @@ declare class APICallError extends AISDKError {
 declare const symbol$c$1: unique symbol;
 declare class EmptyResponseBodyError extends AISDKError {
   private readonly [symbol$c$1];
-  constructor({
-    message
-  }?: {
+  constructor({ message }?: {
     message?: string;
   });
   static isInstance(error: unknown): error is EmptyResponseBodyError;
 }
+declare function getErrorMessage(error: unknown | undefined): string;
 declare const symbol$a$1: unique symbol;
 /**
  * A prompt is invalid. This error should be thrown by providers when they cannot
@@ -1205,91 +1188,70 @@ declare const symbol$a$1: unique symbol;
 declare class InvalidPromptError extends AISDKError {
   private readonly [symbol$a$1];
   readonly prompt: unknown;
-  constructor({
-    prompt,
-    message,
-    cause
-  }: {
+  constructor({ prompt, message, cause }: {
     prompt: unknown;
     message: string;
     cause?: unknown;
   });
   static isInstance(error: unknown): error is InvalidPromptError;
 }
-declare const symbol$9$1: unique symbol;
+declare const symbol$9$2: unique symbol;
 /**
  * Server returned a response with invalid data content.
  * This should be thrown by providers when they cannot parse the response from the API.
  */
 declare class InvalidResponseDataError extends AISDKError {
-  private readonly [symbol$9$1];
+  private readonly [symbol$9$2];
   readonly data: unknown;
-  constructor({
-    data,
-    message
-  }: {
+  constructor({ data, message }: {
     data: unknown;
     message?: string;
   });
   static isInstance(error: unknown): error is InvalidResponseDataError;
 }
-declare const symbol$8$1: unique symbol;
+declare const symbol$8$2: unique symbol;
 declare class JSONParseError extends AISDKError {
-  private readonly [symbol$8$1];
+  private readonly [symbol$8$2];
   readonly text: string;
-  constructor({
-    text,
-    cause
-  }: {
+  constructor({ text, cause }: {
     text: string;
     cause: unknown;
   });
   static isInstance(error: unknown): error is JSONParseError;
 }
-declare const symbol$7$1: unique symbol;
+declare const symbol$7$2: unique symbol;
 declare class LoadAPIKeyError extends AISDKError {
-  private readonly [symbol$7$1];
-  constructor({
-    message
-  }: {
+  private readonly [symbol$7$2];
+  constructor({ message }: {
     message: string;
   });
   static isInstance(error: unknown): error is LoadAPIKeyError;
 }
-declare const symbol$6$1: unique symbol;
+declare const symbol$6$2: unique symbol;
 declare class LoadSettingError extends AISDKError {
-  private readonly [symbol$6$1];
-  constructor({
-    message
-  }: {
+  private readonly [symbol$6$2];
+  constructor({ message }: {
     message: string;
   });
   static isInstance(error: unknown): error is LoadSettingError;
 }
-declare const symbol$5$1: unique symbol;
+declare const symbol$5$2: unique symbol;
 /**
  * Thrown when the AI provider fails to generate any content.
  */
 declare class NoContentGeneratedError extends AISDKError {
-  private readonly [symbol$5$1];
-  constructor({
-    message
-  }?: {
+  private readonly [symbol$5$2];
+  constructor({ message }?: {
     message?: string;
   });
   static isInstance(error: unknown): error is NoContentGeneratedError;
 }
-declare const symbol$4$1: unique symbol;
+declare const symbol$4$2: unique symbol;
 declare class NoSuchModelError extends AISDKError {
-  private readonly [symbol$4$1];
+  private readonly [symbol$4$2];
   readonly modelId: string;
   readonly modelType: 'languageModel' | 'embeddingModel' | 'imageModel' | 'transcriptionModel' | 'speechModel' | 'rerankingModel' | 'videoModel';
-  constructor({
-    errorName,
-    modelId,
-    modelType,
-    message
-  }: {
+  constructor({ errorName, modelId, modelType, message }: {
     errorName?: string;
     modelId: string;
     modelType: 'languageModel' | 'embeddingModel' | 'imageModel' | 'transcriptionModel' | 'speechModel' | 'rerankingModel' | 'videoModel';
@@ -1297,29 +1259,25 @@ declare class NoSuchModelError extends AISDKError {
   });
   static isInstance(error: unknown): error is NoSuchModelError;
 }
-declare const symbol$3$1: unique symbol;
+declare const symbol$3$2: unique symbol;
 /**
  * Thrown when a provider reference cannot be resolved because the specified
  * provider is not found in the provider reference mapping.
  */
 declare class NoSuchProviderReferenceError extends AISDKError {
-  private readonly [symbol$3$1];
+  private readonly [symbol$3$2];
   readonly provider: string;
   readonly reference: SharedV4ProviderReference;
-  constructor({
-    provider,
-    reference,
-    message
-  }: {
+  constructor({ provider, reference, message }: {
     provider: string;
     reference: SharedV4ProviderReference;
     message?: string;
   });
   static isInstance(error: unknown): error is NoSuchProviderReferenceError;
 }
-declare const symbol$2$1: unique symbol;
+declare const symbol$2$2: unique symbol;
 declare class TooManyEmbeddingValuesForCallError extends AISDKError {
-  private readonly [symbol$2$1];
+  private readonly [symbol$2$2];
   readonly provider: string;
   readonly modelId: string;
   readonly maxEmbeddingsPerCall: number;
@@ -1332,7 +1290,7 @@ declare class TooManyEmbeddingValuesForCallError extends AISDKError {
   });
   static isInstance(error: unknown): error is TooManyEmbeddingValuesForCallError;
 }
-declare const symbol$1$2: unique symbol;
+declare const symbol$1$11: unique symbol;
 interface TypeValidationContext {
   /**
    * Field path in dot notation (e.g., "message.metadata", "message.parts[3].data")
@@ -1348,14 +1306,10 @@ interface TypeValidationContext {
   entityId?: string;
 }
 declare class TypeValidationError extends AISDKError {
-  private readonly [symbol$1$2];
+  private readonly [symbol$1$11];
   readonly value: unknown;
   readonly context?: TypeValidationContext;
-  constructor({
-    value,
-    cause,
-    context
-  }: {
+  constructor({ value, cause, context }: {
     value: unknown;
     cause: unknown;
     context?: TypeValidationContext;
@@ -1372,24 +1326,17 @@ declare class TypeValidationError extends AISDKError {
    * @param {TypeValidationContext} params.context - Optional context about what is being validated.
    * @returns {TypeValidationError} A TypeValidationError instance.
    */
-  static wrap({
-    value,
-    cause,
-    context
-  }: {
+  static wrap({ value, cause, context }: {
     value: unknown;
     cause: unknown;
     context?: TypeValidationContext;
   }): TypeValidationError;
 }
-declare const symbol$10: unique symbol;
+declare const symbol$12: unique symbol;
 declare class UnsupportedFunctionalityError extends AISDKError {
-  private readonly [symbol$10];
+  private readonly [symbol$12];
   readonly functionality: string;
-  constructor({
-    functionality,
-    message
-  }: {
+  constructor({ functionality, message }: {
     functionality: string;
     message?: string;
   });
@@ -2084,11 +2031,6 @@ type ImageModelV4Middleware = {
     model: ImageModelV4;
   }) => Promise<Awaited<ReturnType<ImageModelV4['doGenerate']>>>;
 };
-/**
- * Middleware for ImageModelV3.
- * This type defines the structure for middleware that can be used to modify
- * the behavior of ImageModelV3 operations.
- */
 /**
  * A tool has a name, a description, and a set of parameters.
  *
@@ -4165,7 +4107,7 @@ type LanguageModelV3$1 = {
   supportedUrls: PromiseLike<Record<string, RegExp[]>> | Record<string, RegExp[]>;
   /**
    * Generates a language model output (non-streaming).
-      * Naming: "do" prefix to prevent accidental direct usage of the method
+   * Naming: "do" prefix to prevent accidental direct usage of the method
    * by the user.
    */
   doGenerate(options: LanguageModelV3CallOptions$1): PromiseLike<LanguageModelV3GenerateResult$1>;
@@ -4179,11 +4121,6 @@ type LanguageModelV3$1 = {
    */
   doStream(options: LanguageModelV3CallOptions$1): PromiseLike<LanguageModelV3StreamResult$1>;
 };
-/**
- * Experimental middleware for LanguageModelV3.
- * This type defines the structure for middleware that can be used to modify
- * the behavior of LanguageModelV3 operations.
- */
 /**
  * A tool has a name, a description, and a set of parameters.
  *
@@ -4925,11 +4862,6 @@ type LanguageModelV2$1 = {
     };
   }>;
 };
-/**
- * Experimental middleware for LanguageModelV2.
- * This type defines the structure for middleware that can be used to modify
- * the behavior of LanguageModelV2 operations.
- */
 /**
  * Middleware for EmbeddingModelV4.
  * This type defines the structure for middleware that can be used to modify
@@ -4994,11 +4926,6 @@ type EmbeddingModelV4Middleware = {
     model: EmbeddingModelV4;
   }) => Promise<Awaited<ReturnType<EmbeddingModelV4['doEmbed']>>>;
 };
-/**
- * Middleware for EmbeddingModelV3.
- * This type defines the structure for middleware that can be used to modify
- * the behavior of EmbeddingModelV3 operations.
- */
 /**
  * A normalized language model call within a batch.
  */
@@ -7950,7 +7877,7 @@ type VideoModelV3 = {
   }>;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@ai-sdk+provider@2.0.3/node_modules/@ai-sdk/provider/dist/index.d.ts
+//#region ../../node_modules/.pnpm/@ai-sdk+provider@2.0.4/node_modules/@ai-sdk/provider/dist/index.d.ts
 type SharedV2Headers = Record<string, string>;
 /**
 A JSON value can be a string, number, boolean, object, array, or null.
@@ -8006,10 +7933,6 @@ type SharedV2ProviderMetadata = Record<string, Record<string, JSONValue$2>>;
  */
 type SharedV2ProviderOptions = Record<string, Record<string, JSONValue$2>>;
 /**
-An embedding is a vector, i.e. an array of numbers.
-It is e.g. used to represent a text as a vector of word embeddings.
- */
-/**
 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
@@ -8018,25 +7941,25 @@ map the user-facing tool definitions to this format.
 type LanguageModelV2FunctionTool = {
   /**
   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.
-   */
+     */
   inputSchema: JSONSchema7;
   /**
   The provider-specific options for the tool.
-   */
+     */
   providerOptions?: SharedV2ProviderOptions;
 };
 /**
@@ -8080,7 +8003,7 @@ interface LanguageModelV2TextPart {
   type: 'text';
   /**
   The text content.
-   */
+     */
   text: string;
   /**
    * Additional provider-specific options. They are passed through
@@ -8096,7 +8019,7 @@ interface LanguageModelV2ReasoningPart {
   type: 'reasoning';
   /**
   The reasoning text.
-   */
+     */
   text: string;
   /**
    * Additional provider-specific options. They are passed through
@@ -8120,9 +8043,11 @@ interface LanguageModelV2FilePart {
   data: LanguageModelV2DataContent;
   /**
   IANA media type of the file.
-   Can support wildcards, e.g. `image/*` (in which case the provider needs to take appropriate action).
-   @see https://www.iana.org/assignments/media-types/media-types.xhtml
-   */
+  
+  Can support wildcards, e.g. `image/*` (in which case the provider needs to take appropriate action).
+  
+  @see https://www.iana.org/assignments/media-types/media-types.xhtml
+     */
   mediaType: string;
   /**
    * Additional provider-specific options. They are passed through
@@ -8138,15 +8063,15 @@ interface LanguageModelV2ToolCallPart {
   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.
-   */
+     */
   input: unknown;
   /**
    * Whether the tool call will be executed by the provider.
@@ -8167,15 +8092,15 @@ interface LanguageModelV2ToolResultPart {
   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.
-   */
+     */
   output: LanguageModelV2ToolResultOutput;
   /**
    * Additional provider-specific options. They are passed through
@@ -8201,19 +8126,19 @@ type LanguageModelV2ToolResultOutput = {
   value: Array<{
     type: 'text';
     /**
-    Text content.
-    */
+Text content.
+*/
     text: string;
   } | {
     type: 'media';
     /**
-    Base-64 encoded media data.
-    */
+Base-64 encoded media data.
+*/
     data: string;
     /**
-    IANA media type.
-    @see https://www.iana.org/assignments/media-types/media-types.xhtml
-    */
+IANA media type.
+@see https://www.iana.org/assignments/media-types/media-types.xhtml
+*/
     mediaType: string;
   }>;
 };
@@ -8223,19 +8148,19 @@ The configuration of a tool that is defined by the provider.
 type LanguageModelV2ProviderDefinedTool = {
   /**
   The type of the tool (always 'provider-defined').
-   */
+     */
   type: 'provider-defined';
   /**
   The ID of the tool. Should follow the format `<provider-name>.<unique-tool-name>`.
-   */
+     */
   id: `${string}.${string}`;
   /**
   The name of the tool that the user must use in the tool set.
-   */
+     */
   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 LanguageModelV2ToolChoice = {
@@ -8251,50 +8176,53 @@ type LanguageModelV2ToolChoice = {
 type LanguageModelV2CallOptions = {
   /**
   A language mode prompt is a standardized prompt type.
-   Note: This is **not** the user-facing prompt. The AI SDK methods will map the
+  
+  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: LanguageModelV2Prompt;
   /**
   Maximum number of tokens to generate.
-   */
+     */
   maxOutputTokens?: number;
   /**
   Temperature setting. The range depends on the provider and model.
-  */
+   */
   temperature?: number;
   /**
   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.
-  */
+   */
   topP?: number;
   /**
   Only sample from the top K options for each subsequent token.
-   Used to remove "long tail" low probability responses.
+  
+  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.
-  */
+  
+  If JSON is selected, a schema can optionally be provided to guide the LLM.
+   */
   responseFormat?: {
     type: 'text';
   } | {
@@ -8315,11 +8243,11 @@ type LanguageModelV2CallOptions = {
   /**
   The seed (integer) to use for random sampling. If set and supported
   by the model, calls will generate deterministic results.
-  */
+   */
   seed?: number;
   /**
   The tools that are available for the model.
-  */
+    */
   tools?: Array<LanguageModelV2FunctionTool | LanguageModelV2ProviderDefinedTool>;
   /**
   Specifies how the tool should be selected. Defaults to 'auto'.
@@ -8327,16 +8255,16 @@ 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;
   /**
   Additional HTTP headers to be sent with the request.
   Only applicable for HTTP-based providers.
-  */
+   */
   headers?: Record<string, string | undefined>;
   /**
    * Additional provider-specific options. They are passed through
@@ -8370,16 +8298,18 @@ type LanguageModelV2File = {
   type: 'file';
   /**
   The IANA media type of the file, e.g. `image/png` or `audio/mp3`.
-   @see https://www.iana.org/assignments/media-types/media-types.xhtml
-       */
+  
+  @see https://www.iana.org/assignments/media-types/media-types.xhtml
+         */
   mediaType: string;
   /**
   Generated file data as base64 encoded strings or binary data.
-   The file data should be returned without any unnecessary conversion.
+  
+  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;
 };
 /**
@@ -8452,7 +8382,7 @@ type LanguageModelV2Text = {
   type: 'text';
   /**
   The text content.
-   */
+     */
   text: string;
   providerMetadata?: SharedV2ProviderMetadata;
 };
@@ -8533,7 +8463,7 @@ type LanguageModelV2FinishReason = 'stop' | 'length' | 'content-filter' | 'tool-
 interface LanguageModelV2ResponseMetadata {
   /**
   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.
@@ -8553,25 +8483,25 @@ provider metadata under your provider's key.
 type LanguageModelV2Usage = {
   /**
   The number of input (prompt) tokens used.
-   */
+     */
   inputTokens: number | undefined;
   /**
   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 = {
@@ -8638,65 +8568,70 @@ 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.
-   */
+     */
   readonly specificationVersion: 'v2';
   /**
   Name of the provider for logging purposes.
-   */
+     */
   readonly provider: string;
   /**
   Provider-specific model ID for logging purposes.
-   */
+     */
   readonly modelId: string;
   /**
   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`).
+  
+  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).
-   */
+  
+  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).
+     */
   supportedUrls: PromiseLike<Record<string, RegExp[]>> | Record<string, RegExp[]>;
   /**
   Generates a language model output (non-streaming).
-   Naming: "do" prefix to prevent accidental direct usage of the method
+  
+  Naming: "do" prefix to prevent accidental direct usage of the method
   by the user.
-   */
+     */
   doGenerate(options: LanguageModelV2CallOptions): PromiseLike<{
     /**
     Ordered content that the model has generated.
-     */
+         */
     content: Array<LanguageModelV2Content>;
     /**
     Finish reason.
-     */
+         */
     finishReason: LanguageModelV2FinishReason;
     /**
-    Usage information.
-     */
+      Usage information.
+         */
     usage: LanguageModelV2Usage;
     /**
     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 request information for telemetry and debugging purposes.
-     */
+         */
     request?: {
       /**
       Request HTTP body that was sent to the provider API.
-       */
+             */
       body?: unknown;
     };
     /**
     Optional response information for telemetry and debugging purposes.
-     */
+         */
     response?: LanguageModelV2ResponseMetadata & {
       /**
       Response headers.
-      */
+            */
       headers?: SharedV2Headers;
       /**
       Response HTTP body.
@@ -8705,45 +8640,41 @@ type LanguageModelV2 = {
     };
     /**
     Warnings for the call, e.g. unsupported settings.
-     */
+         */
     warnings: Array<LanguageModelV2CallWarning>;
   }>;
   /**
   Generates a language model output (streaming).
-   Naming: "do" prefix to prevent accidental direct usage of the method
+  
+  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: LanguageModelV2CallOptions): PromiseLike<{
     stream: ReadableStream<LanguageModelV2StreamPart>;
     /**
     Optional request information for telemetry and debugging purposes.
-     */
+         */
     request?: {
       /**
       Request HTTP body that was sent to the provider API.
-      */
+         */
       body?: unknown;
     };
     /**
     Optional response data.
-     */
+         */
     response?: {
       /**
       Response headers.
-       */
+             */
       headers?: SharedV2Headers;
     };
   }>;
 };
-/**
- * Experimental middleware for LanguageModelV2.
- * This type defines the structure for middleware that can be used to modify
- * the behavior of LanguageModelV2 operations.
- */
 //#endregion
-//#region ../../node_modules/.pnpm/@ai-sdk+provider@3.0.15/node_modules/@ai-sdk/provider/dist/index.d.ts
+//#region ../../node_modules/.pnpm/@ai-sdk+provider@3.0.16/node_modules/@ai-sdk/provider/dist/index.d.ts
 type SharedV3Headers = Record<string, string>;
 /**
  * A JSON value can be a string, number, boolean, object, array, or null.
@@ -9811,7 +9742,7 @@ type LanguageModelV3 = {
   supportedUrls: PromiseLike<Record<string, RegExp[]>> | Record<string, RegExp[]>;
   /**
    * Generates a language model output (non-streaming).
-      * Naming: "do" prefix to prevent accidental direct usage of the method
+   * Naming: "do" prefix to prevent accidental direct usage of the method
    * by the user.
    */
   doGenerate(options: LanguageModelV3CallOptions): PromiseLike<LanguageModelV3GenerateResult>;
@@ -9825,11 +9756,6 @@ type LanguageModelV3 = {
    */
   doStream(options: LanguageModelV3CallOptions): PromiseLike<LanguageModelV3StreamResult>;
 };
-/**
- * Experimental middleware for LanguageModelV3.
- * This type defines the structure for middleware that can be used to modify
- * the behavior of LanguageModelV3 operations.
- */
 //#endregion
 //#region src/opentelemetry-lib/tracing/processor.d.ts
 interface LaminarSpanProcessorOptions {
@@ -9897,7 +9823,7 @@ interface LaminarSpanProcessorOptions {
    */
   httpPort?: number;
 }
-declare class LaminarSpanProcessor implements SpanProcessor {
+export declare class LaminarSpanProcessor implements SpanProcessor {
   private instance;
   private logger;
   private readonly _spanIdToPath;
@@ -9948,7 +9874,7 @@ declare class LaminarSpanProcessor implements SpanProcessor {
 }
 //#endregion
 //#region src/opentelemetry-lib/tracing/attributes.d.ts
-declare const LaminarAttributes: {
+export declare const LaminarAttributes: {
   INPUT_TOKEN_COUNT: string;
   OUTPUT_TOKEN_COUNT: string;
   TOTAL_TOKEN_COUNT: string;
@@ -10041,7 +9967,7 @@ interface LaminarInitializeProps {
   spanProcessor?: SpanProcessor;
 }
 type LaminarAttributesProp = Record<(typeof LaminarAttributes)[keyof typeof LaminarAttributes], AttributeValue>;
-declare class Laminar {
+export declare class Laminar {
   private static baseHttpUrl;
   private static projectApiKey;
   private static isInitialized;
@@ -10128,25 +10054,7 @@ declare class Laminar {
    *
    * @throws {Error} - If project API key is not set
    */
-  static initialize({
-    projectApiKey,
-    baseUrl,
-    baseHttpUrl,
-    httpPort,
-    grpcPort,
-    instrumentModules,
-    disableBatch,
-    traceExportTimeoutMillis,
-    logLevel,
-    maxExportBatchSize,
-    maxExportBatchSizeBytes,
-    flushBySize,
-    forceHttp,
-    sessionRecordingOptions,
-    metadata,
-    inheritGlobalContext,
-    spanProcessor
-  }?: LaminarInitializeProps): void;
+  static initialize({ projectApiKey, baseUrl, baseHttpUrl, httpPort, grpcPort, instrumentModules, disableBatch, traceExportTimeoutMillis, logLevel, maxExportBatchSize, maxExportBatchSizeBytes, flushBySize, forceHttp, sessionRecordingOptions, metadata, inheritGlobalContext, spanProcessor }?: LaminarInitializeProps): void;
   /**
    * Initialize Laminar context from the LMNR_SPAN_CONTEXT environment variable.
    * This allows continuing traces across process boundaries.
@@ -10222,13 +10130,7 @@ declare class Laminar {
    * @param {string} options.userId - The user ID to associate with the event. If not specified,
    * the user ID of the current trace is used.
    */
-  static event({
-    name,
-    attributes,
-    timestamp,
-    sessionId,
-    userId
-  }: {
+  static event({ name, attributes, timestamp, sessionId, userId }: {
     name: string;
     attributes?: Record<string, AttributeValue>;
     timestamp?: TimeInput;
@@ -10312,18 +10214,7 @@ declare class Laminar {
    * // |  |  | ...
    * // |  | openai.chat
    */
-  static startSpan({
-    name,
-    input,
-    spanType,
-    context,
-    parentSpanContext,
-    tags,
-    userId,
-    sessionId,
-    metadata,
-    startTime
-  }: {
+  static startSpan({ name, input, spanType, context, parentSpanContext, tags, userId, sessionId, metadata, startTime }: {
     name: string;
     input?: any;
     spanType?: SpanType;
@@ -10393,19 +10284,7 @@ declare class Laminar {
    * // |  | bar
    * // |  |  | openai.chat
    */
-  static startActiveSpan({
-    name,
-    input,
-    spanType,
-    context,
-    parentSpanContext,
-    tags,
-    userId,
-    sessionId,
-    metadata,
-    startTime,
-    global
-  }: {
+  static startActiveSpan({ name, input, spanType, context, parentSpanContext, tags, userId, sessionId, metadata, startTime, global }: {
     name: string;
     input?: any;
     spanType?: SpanType;
@@ -10584,7 +10463,116 @@ declare namespace StandardJSONSchemaV1 {
   type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@ai-sdk+provider-utils@5.0.27_zod@4.4.3/node_modules/@ai-sdk/provider-utils/dist/index.d.ts
+//#region ../../node_modules/.pnpm/@workflow+serde@4.1.0/node_modules/@workflow/serde/dist/index.d.ts
+/**
+ * Symbol used to define custom serialization for user-defined class instances.
+ * The static method should accept an instance and return serializable data.
+ *
+ * @example
+ * ```ts
+ * import { WORKFLOW_SERIALIZE, WORKFLOW_DESERIALIZE } from '@workflow/serde';
+ *
+ * class MyClass {
+ *   constructor(public value: string) {}
+ *
+ *   static [WORKFLOW_SERIALIZE](instance: MyClass) {
+ *     return { value: instance.value };
+ *   }
+ *
+ *   static [WORKFLOW_DESERIALIZE](data: { value: string }) {
+ *     return new MyClass(data.value);
+ *   }
+ * }
+ * ```
+ */
+declare const WORKFLOW_SERIALIZE: unique symbol;
+/**
+ * Symbol used to define custom deserialization for user-defined class instances.
+ * The static method should accept serialized data and return a class instance.
+ *
+ * @see WORKFLOW_SERIALIZE for usage example
+ */
+declare const WORKFLOW_DESERIALIZE: unique symbol;
+//#endregion
+//#region ../../node_modules/.pnpm/eventsource-parser@3.0.8/node_modules/eventsource-parser/dist/stream.d.ts
+/**
+ * A parsed EventSource message event
+ *
+ * @public
+ */
+declare interface EventSourceMessage {
+  /**
+   * The event type sent from the server. Note that this differs from the browser `EventSource`
+   * implementation in that browsers will default this to `message`, whereas this parser will
+   * leave this as `undefined` if not explicitly declared.
+   */
+  event?: string | undefined;
+  /**
+   * ID of the message, if any was provided by the server. Can be used by clients to keep the
+   * last received message ID in sync when reconnecting.
+   */
+  id?: string | undefined;
+  /**
+   * The data received for this message
+   */
+  data: string;
+}
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of `EventSourceMessage`.
+ *
+ * @example Basic usage
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ *
+ * @example Terminate stream on parsing errors
+ * ```
+ * const eventStream =
+ *  response.body
+ *   .pipeThrough(new TextDecoderStream())
+ *   .pipeThrough(new EventSourceParserStream({terminateOnError: true}))
+ * ```
+ *
+ * @public
+ */
+declare class EventSourceParserStream extends TransformStream<string, EventSourceMessage> {
+  constructor({ onError, onRetry, onComment }?: StreamOptions);
+}
+/**
+ * Options for the EventSourceParserStream.
+ *
+ * @public
+ */
+declare interface StreamOptions {
+  /**
+   * Behavior when a parsing error occurs.
+   *
+   * - A custom function can be provided to handle the error.
+   * - `'terminate'` will error the stream and stop parsing.
+   * - Any other value will ignore the error and continue parsing.
+   *
+   * @defaultValue `undefined`
+   */
+  onError?: ("terminate" | ((error: Error) => void)) | undefined;
+  /**
+   * Callback for when a reconnection interval is sent from the server.
+   *
+   * @param retry - The number of milliseconds to wait before reconnecting.
+   */
+  onRetry?: ((retry: number) => void) | undefined;
+  /**
+   * Callback for when a comment is encountered in the stream.
+   *
+   * @param comment - The comment encountered in the stream.
+   */
+  onComment?: ((comment: string) => void) | undefined;
+}
+declare namespace index_d_exports$1 {
+  export { Arrayable, AssistantContent, AssistantModelMessage, Context$1 as Context, CustomPart, DEFAULT_MAX_DOWNLOAD_SIZE, DataContent, DelayedPromise, DownloadError, DynamicTool, TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE as EXPERIMENTAL_TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE, TRANSCRIPTION_STREAM_START_FRAME_TYPE as EXPERIMENTAL_TRANSCRIPTION_STREAM_START_FRAME_TYPE, EventSourceMessage, EventSourceParserStream, ExecutableTool, SandboxProcess as Experimental_SandboxProcess, SandboxSession as Experimental_SandboxSession, ToolCallerDefinition as Experimental_ToolCallerDefinition, ToolCallerTool as Experimental_ToolCallerTool, TranscriptionStreamClientFrame as Experimental_TranscriptionStreamClientFrame, TranscriptionStreamStartFrame as Experimental_TranscriptionStreamStartFrame, FetchFunction, FileData, FileDataData, FileDataReference, FileDataText, FileDataUrl, FilePart, FlexibleSchema, FunctionTool, HasRequiredKey, IdGenerator, ImagePart, InferSchema, InferToolContext, InferToolInput, InferToolOutput, InferToolSetContext, LazySchema, MaybePromiseLike, ModelMessage, ParseResult, ProviderDefinedTool, ProviderDefinedToolFactory, ProviderDefinedToolFactoryWithOutputSchema, ProviderExecutedTool, ProviderExecutedToolFactory, ProviderOptions, ProviderReference$1 as ProviderReference, ReasoningFilePart, ReasoningPart, Resolvable, ResponseHandler, RetryDelayProvider, RetryErrorFactory, RetryErrorReason$1 as RetryErrorReason, RetryFunction, Schema, SerializationError, ShouldRetryFunction, StandardJSONSchemaV1, StandardSchemaV1, StandardTypedV1, StreamingToolCallDelta, StreamingToolCallTracker, StreamingToolCallTrackerOptions, SystemModelMessage, TextPart, Tool, ToolApprovalRequest, ToolApprovalResponse, ToolCall, ToolCallPart, ToolContent, ToolExecuteFunction, ToolExecutionOptions, ToolModelMessage, ToolNameMapping, ToolNeedsApprovalFunction, ToolResult, ToolResultOutput, ToolResultPart, ToolSet, UserContent, UserModelMessage, VERSION, ValidationResult, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, WebSocketConnection, WebSocketConstructor, WebSocketLike, asArray, asSchema, cancelResponseBody, combineHeaders, connectToWebSocket, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertImageModelFileToDataUri, convertInlineFileDataToUint8Array, convertToBase64, convertToFormData, convertUint8ArrayToBase64, createBinaryResponseHandler, createEventSourceResponseHandler, createIdGenerator, createJsonErrorResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata, createNullLanguageModelUsage, createProviderDefinedToolFactory, createProviderDefinedToolFactoryWithOutputSchema, createProviderExecutedToolFactory, createStatusCodeErrorResponseHandler, createToolNameMapping, delay$1 as delay, detectMediaType, downloadBlob, dynamicTool, executeTool, getToolCaller as experimental_getToolCaller, parseTranscriptionStreamClientFrame as experimental_parseTranscriptionStreamClientFrame, parseTranscriptionStreamPart as experimental_parseTranscriptionStreamPart, serializeTranscriptionStreamPart as experimental_serializeTranscriptionStreamPart, toolCaller as experimental_toolCaller, extractLines, extractResponseHeaders, fetchWithValidatedRedirects, filterNullable, generateId$1 as generateId, getErrorMessage, getFromApi, getRuntimeEnvironmentUserAgent, getTopLevelMediaType, getWebSocketConstructor, injectJsonInstructionIntoMessages, isAbortError, isBrowserRuntime, isBuffer, isCustomReasoning, isExecutableTool, isFullMediaType, isNonNullable, isParsableJson, isProviderReference, isRecord, isSameOrigin, isUrlSupported, jsonSchema, lazySchema, loadApiKey, loadOptionalSetting, loadSetting, mapReasoningToProviderBudget, mapReasoningToProviderEffort, mediaTypeToExtension, normalizeHeaders, parseJSON, parseJsonEventStream, parseProviderOptions, postFormDataToApi, postJsonToApi, postToApi, readResponseWithSizeLimit, readWebSocketMessageText, removeUndefinedEntries, resolve, resolveFullMediaType, resolveProviderReference, retryWithExponentialBackoff, safeParseJSON, safeValidateTypes, secureJsonParse, serializeModelOptions, stripFileExtension, toWebSocketUrl, tool$1 as tool, validateBaseURL, validateDownloadUrl, validateTypes, waitForWebSocketBufferDrain, withUserAgentSuffix, withoutTrailingSlash, zodSchema };
+}
 /**
  * A value that can be provided either as a single item, an array of items,
  * or be left undefined.
@@ -10593,8 +10581,11 @@ type Arrayable<T> = T | T[] | undefined;
 /**
  * Normalizes a possibly undefined or non-array value into an array.
  */
+declare function asArray<T>(value: Arrayable<T>): T[];
+declare function combineHeaders(...headers: Array<Record<string, string | undefined> | undefined>): Record<string, string | undefined>;
 type WebSocketLike = {
-  readyState: number; /** Bytes queued by `send` but not yet transmitted (native + `ws`). */
+  readyState: number;
+  /** Bytes queued by `send` but not yet transmitted (native + `ws`). */
   readonly bufferedAmount?: number;
   send(data: string | Uint8Array | ArrayBuffer): void;
   close(code?: number, reason?: string): void;
@@ -10608,6 +10599,74 @@ type WebSocketLike = {
 type WebSocketConstructor = new (url: string | URL, protocols?: string | string[], options?: {
   headers?: Record<string, string | undefined>;
 }) => WebSocketLike;
+declare function getWebSocketConstructor(webSocket: WebSocketConstructor | undefined): WebSocketConstructor;
+/**
+ * Converts an http(s) URL to the corresponding ws(s) URL.
+ */
+declare function toWebSocketUrl(url: string | URL): URL;
+/**
+ * Reads WebSocket message data as text, handling string, binary,
+ * and Blob payloads.
+ */
+declare function readWebSocketMessageText(data: unknown): Promise<string>;
+/**
+ * Waits until the socket's send buffer drains below `highWaterMark` bytes.
+ * No-op for implementations that do not expose `bufferedAmount`. There is no
+ * portable drain event, so this polls. Returns as soon as the socket is no
+ * longer open or the signal aborts — `bufferedAmount` never drains on a
+ * closed socket, so waiting on would poll forever.
+ */
+declare function waitForWebSocketBufferDrain(socket: WebSocketLike, { highWaterMark, pollIntervalMs, abortSignal }?: {
+  highWaterMark?: number;
+  pollIntervalMs?: number;
+  abortSignal?: AbortSignal;
+}): Promise<void>;
+interface WebSocketConnection {
+  /** Undefined when the constructor threw or the signal was already aborted. */
+  socket: WebSocketLike | undefined;
+  /**
+   * Unregisters the abort listener and closes the socket. Never throws.
+   * Handlers stay attached; callers guard their own terminal state.
+   */
+  close: (code?: number) => void;
+}
+/**
+ * Opens a WebSocket for a provider model, owning the transport-generic layer
+ * (analogous to `postToApi` for HTTP): constructor resolution, header hygiene,
+ * abort wiring, and message decoding. Callers own the URL, the auth channel
+ * (subprotocols vs headers), and the wire protocol.
+ */
+declare function connectToWebSocket({ url, protocols, headers, webSocket, abortSignal, onOpen, onMessageText, onProcessingError, onSocketError, onClose, onAbort }: {
+  url: string | URL;
+  protocols?: string | string[];
+  headers?: Record<string, string | undefined>;
+  webSocket?: WebSocketConstructor;
+  abortSignal?: AbortSignal;
+  onOpen?: (socket: WebSocketLike) => void;
+  /** One decoded message. Throws and rejections go to `onProcessingError`. */
+  onMessageText: (text: string) => void | PromiseLike<void>;
+  /** Constructor throws and message decoding/processing failures. */
+  onProcessingError: (error: unknown) => void;
+  onSocketError?: () => void;
+  /**
+   * Receives the close code and reason when the transport provides them
+   * (native `CloseEvent` / `ws` close event).
+   */
+  onClose?: (info: {
+    code?: number;
+    reason?: string;
+  }) => void;
+  /** Also called (without opening a socket) when the signal is already aborted. */
+  onAbort?: (reason: unknown) => void;
+}): WebSocketConnection;
+/**
+ * Converts an AsyncIterator to a ReadableStream.
+ *
+ * @template T - The type of elements produced by the AsyncIterator.
+ * @param { <T>} iterator - The AsyncIterator to convert.
+ * @returns {ReadableStream<T>} - A ReadableStream that provides the same data as the AsyncIterator.
+ */
+declare function convertAsyncIteratorToReadableStream<T>(iterator: AsyncIterator<T>): ReadableStream<T>;
 /**
  * Data content. Can either be a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer.
  */
@@ -11117,58 +11176,237 @@ type ToolResultOutput = {
     providerOptions?: ProviderOptions;
   }>;
 };
-declare const symbol$1$1: unique symbol;
-declare class DownloadError extends AISDKError {
-  private readonly [symbol$1$1];
-  readonly url: string;
-  readonly statusCode?: number;
-  readonly statusText?: string;
-  constructor({
-    url,
-    statusCode,
-    statusText,
-    cause,
-    message
-  }: {
-    url: string;
-    statusCode?: number;
-    statusText?: string;
-    message?: string;
-    cause?: unknown;
-  });
-  static isInstance(error: unknown): error is DownloadError;
-}
+type InlineFileData = Extract<FilePart['data'], {
+  type: 'data';
+} | {
+  type: 'text';
+}>;
 /**
- * Fetch function type (standardizes the version of fetch used).
+ * Converts inline file data (a tagged `data` or `text` shape) into raw bytes.
+ *
+ * - `{ type: 'text', text }` → UTF-8 encoded bytes
+ * - `{ type: 'data', data: Uint8Array | Buffer }` → returned as-is
+ * - `{ type: 'data', data: ArrayBuffer }` → wrapped in a `Uint8Array`
+ * - `{ type: 'data', data: string }` → decoded as base64
  */
-type FetchFunction = typeof globalThis.fetch;
+declare function convertInlineFileDataToUint8Array(data: InlineFileData): Uint8Array;
 /**
- * Fetches a URL while enforcing the download guard on every hop.
+ * Convert an ImageModelV4File to a URL or data URI string.
  *
- * Redirects are followed manually (`redirect: 'manual'`) so each hop is
- * validated with {@link validateDownloadUrl} *before* it is requested. Relying
- * on the default `redirect: 'follow'` would issue the request to a redirect
- * target (e.g. an internal address) before we ever see its URL, defeating the
- * guard.
+ * If the file is a URL, it returns the URL as-is.
+ * If the file is base64 data, it returns a data URI with the base64 data.
+ * If the file is a Uint8Array, it converts it to base64 and returns a data URI.
+ */
+declare function convertImageModelFileToDataUri(file: ImageModelV4File): string;
+/**
+ * Converts an input object to FormData for multipart/form-data requests.
  *
- * Request headers are also protected: {@link sanitizeRequestHeaders} strips
- * proxy/metadata/cookie/hop-by-hop headers before the first request, and all
- * caller headers except `User-Agent` are dropped on a cross-origin redirect.
- * The fetch spec only strips `Authorization` on cross-origin redirects because
- * in a browser, CORS preflighting protects custom headers; there is no CORS on
- * the server, so provider API keys carried in custom headers (e.g. `x-key`)
- * must be dropped here as well.
+ * Handles the following cases:
+ * - `null` or `undefined` values are skipped
+ * - Arrays with a single element are appended as a single value
+ * - Arrays with multiple elements are appended with `[]` suffix (e.g., `image[]`)
+ *   unless `useArrayBrackets` is set to `false`
+ * - All other values are appended directly
  *
- * A `redirect: 'manual'` request yields an unreadable opaque response in the
- * browser (and in other spec-compliant fetch implementations), so the redirect
- * target cannot be validated here. In a real browser this is safe to follow
- * natively because reaching an internal network is not possible (fetch is
- * constrained by CORS and cannot reach a server's internal network or
- * cloud-metadata). On any other runtime we cannot validate the hop, so we fail
- * closed rather than follow it blindly and bypass the guard.
+ * @param input - The input object to convert. Use a generic type for type validation.
+ * @param options - Optional configuration object.
+ * @param options.useArrayBrackets - Whether to add `[]` suffix for multi-element arrays.
+ *   Defaults to `true`. Set to `false` for APIs that expect repeated keys without brackets.
+ * @returns A FormData object containing the input values.
  *
- * A hop that is same-origin with `trustedOrigin` (the developer-configured
- * provider endpoint) skips target validation: that origin is exactly what an
+ * @example
+ * ```ts
+ * type MyInput = {
+ *   model: string;
+ *   prompt: string;
+ *   images: Blob[];
+ * };
+ *
+ * const formData = convertToFormData<MyInput>({
+ *   model: 'gpt-image-1',
+ *   prompt: 'A cat',
+ *   images: [blob1, blob2],
+ * });
+ * ```
+ */
+declare function convertToFormData<T extends Record<string, unknown>>(input: T, options?: {
+  useArrayBrackets?: boolean;
+}): FormData;
+/**
+ * Converts common provider response fields into language model response
+ * metadata.
+ */
+declare function createLanguageModelResponseMetadata({ id, model, created }: {
+  id?: string | null;
+  model?: string | null;
+  created?: number | null;
+}): LanguageModelV4ResponseMetadata;
+/**
+ * Creates an empty language model usage result for unavailable usage data.
+ */
+declare function createNullLanguageModelUsage(): LanguageModelV4Usage;
+/**
+ * Interface for mapping between custom tool names and provider tool names.
+ */
+interface ToolNameMapping {
+  /**
+   * Maps a custom tool name (used by the client) to the provider's tool name.
+   * If the custom tool name does not have a mapping, returns the input name.
+   *
+   * @param customToolName - The custom name of the tool defined by the client.
+   * @returns The corresponding provider tool name, or the input name if not mapped.
+   */
+  toProviderToolName: (customToolName: string) => string;
+  /**
+   * Maps a provider tool name to the custom tool name used by the client.
+   * If the provider tool name does not have a mapping, returns the input name.
+   *
+   * @param providerToolName - The name of the tool as understood by the provider.
+   * @returns The corresponding custom tool name, or the input name if not mapped.
+   */
+  toCustomToolName: (providerToolName: string) => string;
+}
+/**
+ * @param tools - Tools that were passed to the language model.
+ * @param providerToolNames - Maps the provider tool ids to the provider tool names.
+ */
+declare function createToolNameMapping({ tools, providerToolNames }: {
+  /**
+   * Tools that were passed to the language model.
+   */
+  tools: Array<LanguageModelV4FunctionTool | LanguageModelV4ProviderTool> | undefined;
+  /**
+   * Maps the provider tool ids to the provider tool names.
+   */
+  providerToolNames: Record<`${string}.${string}`, string>;
+}): ToolNameMapping;
+/**
+ * Creates a Promise that resolves after a specified delay
+ * @param delayInMs - The delay duration in milliseconds. If null or undefined, resolves immediately.
+ * @param signal - Optional AbortSignal to cancel the delay
+ * @returns A Promise that resolves after the specified delay
+ * @throws {DOMException} When the signal is aborted
+ */
+declare function delay$1(delayInMs?: number | null, options?: {
+  abortSignal?: AbortSignal;
+}): Promise<void>;
+/**
+ * Delayed promise. It is only constructed once the value is accessed.
+ * This is useful to avoid unhandled promise rejections when the promise is created
+ * but not accessed.
+ */
+declare class DelayedPromise<T> {
+  private status;
+  private _promise;
+  private _resolve;
+  private _reject;
+  get promise(): Promise<T>;
+  resolve(value: T): void;
+  reject(error: unknown): void;
+  isResolved(): boolean;
+  isRejected(): boolean;
+  isPending(): boolean;
+}
+/**
+ * Detect the IANA media type of a file from its raw bytes or base64 string.
+ *
+ * - When `topLevelType` is omitted, every known signature is considered
+ *   (image, audio, video, and application). Returns `undefined` when the
+ *   bytes do not match any known signature.
+ * - When `topLevelType` is provided, only signatures for that top-level
+ *   segment are considered. Returns `undefined` for unsupported segments
+ *   (e.g. `"text"`) or when no signature matches.
+ */
+declare function detectMediaType({ data, topLevelType }: {
+  data: Uint8Array | string;
+  topLevelType?: string;
+}): string | undefined;
+/**
+ * Returns the top-level segment of a media type (the portion before `/`).
+ *
+ * Examples:
+ *   - `"image/png"` -> `"image"`
+ *   - `"image/*"` -> `"image"`
+ *   - `"image"` -> `"image"`
+ *   - `"image/"` -> `"image"`
+ *   - `""` -> `""`
+ *   - `"/"` -> `""`
+ */
+declare function getTopLevelMediaType(mediaType: string): string;
+/**
+ * Returns `true` only when the given media type has a non-empty, non-wildcard
+ * subtype (i.e. matches the form `type/subtype`, and `subtype` is not `*`).
+ *
+ * Examples:
+ *   - `"image/png"` -> `true`
+ *   - `"image/*"` -> `false`
+ *   - `"image"` -> `false`
+ *   - `"image/"` -> `false`
+ *   - `""` -> `false`
+ *   - `"/"` -> `false`
+ */
+declare function isFullMediaType(mediaType: string): boolean;
+/**
+ * Download a file from a URL and return it as a Blob.
+ *
+ * @param url - The URL to download from.
+ * @param options - Optional settings for the download.
+ * @param options.maxBytes - Maximum allowed download size in bytes. Defaults to 100 MiB.
+ * @param options.abortSignal - An optional abort signal to cancel the download.
+ * @returns A Promise that resolves to the downloaded Blob.
+ *
+ * @throws DownloadError if the download fails or exceeds maxBytes.
+ */
+declare function downloadBlob(url: string, options?: {
+  maxBytes?: number;
+  abortSignal?: AbortSignal;
+}): Promise<Blob>;
+declare const symbol$1$1: unique symbol;
+declare class DownloadError extends AISDKError {
+  private readonly [symbol$1$1];
+  readonly url: string;
+  readonly statusCode?: number;
+  readonly statusText?: string;
+  constructor({ url, statusCode, statusText, cause, message }: {
+    url: string;
+    statusCode?: number;
+    statusText?: string;
+    message?: string;
+    cause?: unknown;
+  });
+  static isInstance(error: unknown): error is DownloadError;
+}
+/**
+ * Fetch function type (standardizes the version of fetch used).
+ */
+type FetchFunction = typeof globalThis.fetch;
+/**
+ * Fetches a URL while enforcing the download guard on every hop.
+ *
+ * Redirects are followed manually (`redirect: 'manual'`) so each hop is
+ * validated with {@link validateDownloadUrl} *before* it is requested. Relying
+ * on the default `redirect: 'follow'` would issue the request to a redirect
+ * target (e.g. an internal address) before we ever see its URL, defeating the
+ * guard.
+ *
+ * Request headers are also protected: {@link sanitizeRequestHeaders} strips
+ * proxy/metadata/cookie/hop-by-hop headers before the first request, and all
+ * caller headers except `User-Agent` are dropped on a cross-origin redirect.
+ * The fetch spec only strips `Authorization` on cross-origin redirects because
+ * in a browser, CORS preflighting protects custom headers; there is no CORS on
+ * the server, so provider API keys carried in custom headers (e.g. `x-key`)
+ * must be dropped here as well.
+ *
+ * A `redirect: 'manual'` request yields an unreadable opaque response in the
+ * browser (and in other spec-compliant fetch implementations), so the redirect
+ * target cannot be validated here. In a real browser this is safe to follow
+ * natively because reaching an internal network is not possible (fetch is
+ * constrained by CORS and cannot reach a server's internal network or
+ * cloud-metadata). On any other runtime we cannot validate the hop, so we fail
+ * closed rather than follow it blindly and bypass the guard.
+ *
+ * A hop that is same-origin with `trustedOrigin` (the developer-configured
+ * provider endpoint) skips target validation: that origin is exactly what an
  * unvalidated, config-derived request would fetch anyway, and validating it
  * would break legitimate self-hosted / localhost deployments whose response
  * URLs point back at the configured host. Hops on any other origin are always
@@ -11186,6 +11424,48 @@ type FetchFunction = typeof globalThis.fetch;
  * @throws DownloadError if a hop is unsafe, the redirect limit is exceeded, or
  * a redirect cannot be validated on a non-browser runtime.
  */
+declare function fetchWithValidatedRedirects({ url, headers, abortSignal, maxRedirects, fetch: customFetch, trustedOrigin }: {
+  url: string;
+  headers?: HeadersInit;
+  abortSignal?: AbortSignal;
+  maxRedirects?: number;
+  fetch?: FetchFunction;
+  /**
+   * A developer-configured origin (e.g. the provider's `baseURL`) whose hops
+   * skip target validation. Must never be derived from response data.
+   */
+  trustedOrigin?: string;
+}): Promise<Response>;
+/**
+ * Extracts a 1-based inclusive line range from `text`, auto-detecting the
+ * file's line ending (`\r\n`, `\n`, or `\r`, in that priority).
+ *
+ * Mixed line endings are not supported: detection picks one and uses it for
+ * both the split and the rejoin, so files that mix conventions will not slice
+ * cleanly. When neither `startLine` nor `endLine` is provided, the input is
+ * returned unchanged. `endLine` past EOF clamps to the last line.
+ */
+declare function extractLines({ text, startLine, endLine }: {
+  text: string;
+  startLine?: number;
+  endLine?: number;
+}): string;
+/**
+ * Extracts the headers from a response object and returns them as a key-value object.
+ *
+ * @param response - The response object to extract headers from.
+ * @returns The headers as a key-value object.
+ */
+declare function extractResponseHeaders(response: Response): {
+  [k: string]: string;
+};
+/**
+ * Filters `null` and `undefined` values out of a list of values.
+ *
+ * @param values - The values to filter.
+ * @returns A new array containing only non-nullish values.
+ */
+declare function filterNullable<T>(...values: Array<T | undefined | null>): Array<T>;
 /**
  * Creates an ID generator.
  * The total length of the ID is the sum of the prefix, separator, and random part length.
@@ -11196,12 +11476,7 @@ type FetchFunction = typeof globalThis.fetch;
  * @param separator - The separator between the prefix and the random part of the ID. Default: '-'.
  * @param size - The size of the random part of the ID to generate. Default: 16.
  */
-declare const createIdGenerator: ({
-  prefix,
-  size,
-  alphabet,
-  separator
-}?: {
+declare const createIdGenerator: ({ prefix, size, alphabet, separator }?: {
   prefix?: string;
   separator?: string;
   size?: number;
@@ -11254,6 +11529,7 @@ type Schema<OBJECT = unknown> = {
  * @param createValidator A function that creates a schema.
  * @returns A function that returns a schema.
  */
+declare function lazySchema<SCHEMA>(createSchema: () => Schema<SCHEMA>): LazySchema<SCHEMA>;
 type LazySchema<SCHEMA> = () => Schema<SCHEMA>;
 type ZodSchema<SCHEMA = any> = z3.Schema<SCHEMA, z3.ZodTypeDef, any> | $ZodType<SCHEMA, any>;
 type StandardSchema<SCHEMA = any> = StandardSchemaV1<unknown, SCHEMA> & {
@@ -11269,9 +11545,7 @@ type InferSchema<SCHEMA> = SCHEMA extends ZodSchema<infer T> ? T : SCHEMA extend
  * @param jsonSchema The JSON Schema for the schema.
  * @param options.validate Optional. A validation function for the schema.
  */
-declare function jsonSchema<OBJECT = unknown>(jsonSchema: JSONSchema7$1 | PromiseLike<JSONSchema7$1> | (() => JSONSchema7$1 | PromiseLike<JSONSchema7$1>), {
-  validate
-}?: {
+declare function jsonSchema<OBJECT = unknown>(jsonSchema: JSONSchema7$1 | PromiseLike<JSONSchema7$1> | (() => JSONSchema7$1 | PromiseLike<JSONSchema7$1>), { validate }?: {
   validate?: (value: unknown) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>;
 }): Schema<OBJECT>;
 declare function asSchema<OBJECT>(schema: FlexibleSchema<OBJECT> | undefined): Schema<OBJECT>;
@@ -11290,6 +11564,22 @@ declare function zodSchema<OBJECT>(zodSchema: $ZodType<OBJECT, any> | z3.Schema<
  * @param text - The JSON string to parse.
  * @returns {JSONValue} - The parsed JSON object.
  */
+declare function parseJSON(options: {
+  text: string;
+  schema?: undefined;
+}): Promise<JSONValue$3>;
+/**
+ * Parses a JSON string into a strongly-typed object using the provided schema.
+ *
+ * @template T - The type of the object to parse the JSON into.
+ * @param {string} text - The JSON string to parse.
+ * @param {Validator<T>} schema - The schema to use for parsing the JSON.
+ * @returns {Promise<T>} - The parsed object.
+ */
+declare function parseJSON<T>(options: {
+  text: string;
+  schema: FlexibleSchema<T>;
+}): Promise<T>;
 type ParseResult<T> = {
   success: true;
   value: T;
@@ -11305,12 +11595,231 @@ type ParseResult<T> = {
  * @param text - The JSON string to parse.
  * @returns {Promise<object>} Either an object with `success: true` and the parsed data, or an object with `success: false` and the error that occurred.
  */
+declare function safeParseJSON(options: {
+  text: string;
+  schema?: undefined;
+}): Promise<ParseResult<JSONValue$3>>;
+/**
+ * Safely parses a JSON string into a strongly-typed object, using a provided schema to validate the object.
+ *
+ * @template T - The type of the object to parse the JSON into.
+ * @param {string} text - The JSON string to parse.
+ * @param {Validator<T>} schema - The schema to use for parsing the JSON.
+ * @returns An object with either a `success` flag and the parsed and typed data, or a `success` flag and an error object.
+ */
+declare function safeParseJSON<T>(options: {
+  text: string;
+  schema: FlexibleSchema<T>;
+}): Promise<ParseResult<T>>;
+declare function isParsableJson(input: string): boolean;
+type ResponseHandler<RETURN_TYPE> = (options: {
+  url: string;
+  requestBodyValues: unknown;
+  response: Response;
+}) => PromiseLike<{
+  value: RETURN_TYPE;
+  rawValue?: unknown;
+  responseHeaders?: Record<string, string>;
+}>;
+declare const createJsonErrorResponseHandler: <T>({ errorSchema, errorToMessage, isRetryable }: {
+  errorSchema: FlexibleSchema<T>;
+  errorToMessage: (error: T) => string;
+  isRetryable?: (response: Response, error?: T) => boolean;
+}) => ResponseHandler<APICallError>;
+declare const createEventSourceResponseHandler: <T>(chunkSchema: FlexibleSchema<T>) => ResponseHandler<ReadableStream<ParseResult<T>>>;
+declare const createJsonResponseHandler: <T>(responseSchema: FlexibleSchema<T>) => ResponseHandler<T>;
+declare const createBinaryResponseHandler: () => ResponseHandler<Uint8Array>;
+declare const createStatusCodeErrorResponseHandler: () => ResponseHandler<APICallError>;
+declare const getFromApi: <T>({ url, headers, successfulResponseHandler, failedResponseHandler, abortSignal, fetch, validateUrl, credentialedOrigin, trustedOrigin }: {
+  url: string;
+  headers?: Record<string, string | undefined>;
+  failedResponseHandler: ResponseHandler<Error>;
+  successfulResponseHandler: ResponseHandler<T>;
+  abortSignal?: AbortSignal;
+  fetch?: FetchFunction;
+  /**
+   * Set `true` when `url` is untrusted (e.g. taken from a provider response
+   * body): it is routed through {@link fetchWithValidatedRedirects}, which
+   * rejects private/loopback/link-local targets and re-validates redirect
+   * hops; blocked URLs throw `DownloadError`. Set `false` only for URLs built
+   * from a developer-configured endpoint.
+   *
+   * Optional for backwards compatibility with existing callers; omitting it
+   * behaves like `false` (no validation). Provider code in this repository
+   * must always pass it explicitly so every call site makes a visible trust
+   * decision — see `contributing/secure-url-handling.md`.
+   */
+  validateUrl?: boolean;
+  /**
+   * When set, `headers` are sent only if `url` is same-origin with this origin
+   * (the user-agent suffix is always kept). Pass the provider's configured
+   * base URL alongside `validateUrl: true` so credentials never ride a request
+   * to a response-supplied host on a different origin (e.g. a CDN). Redirects
+   * that later cross origin drop all caller headers regardless (see
+   * {@link fetchWithValidatedRedirects}).
+   */
+  credentialedOrigin?: string;
+  /**
+   * A developer-configured origin (e.g. the provider's `baseURL`) that is
+   * exempt from URL validation when `validateUrl` is `true`. A response URL
+   * (or redirect hop) that is same-origin with it is fetched without target
+   * validation — it points at exactly the host a config-derived
+   * `validateUrl: false` request would fetch anyway, so blocking it would
+   * only break legitimate self-hosted / localhost deployments whose response
+   * URLs point back at the configured host. Hops on any other origin are
+   * still validated. Must never be derived from response data.
+   */
+  trustedOrigin?: string;
+}) => Promise<{
+  value: T;
+  rawValue?: unknown;
+  responseHeaders?: Record<string, string>;
+}>;
+declare function getRuntimeEnvironmentUserAgent(globalThisAny?: any): string;
 /**
  * Checks if an object has required keys.
  * @param OBJECT - The object to check.
  * @returns True if the object has required keys, false otherwise.
  */
 type HasRequiredKey<OBJECT> = {} extends OBJECT ? false : true;
+declare function injectJsonInstructionIntoMessages({ messages, schema, schemaPrefix, schemaSuffix }: {
+  messages: LanguageModelV4Prompt;
+  schema?: JSONSchema7$1;
+  schemaPrefix?: string;
+  schemaSuffix?: string;
+}): LanguageModelV4Prompt;
+declare function isAbortError(error: unknown): error is Error;
+/**
+ * Returns `true` when running in a browser.
+ *
+ * Detection keys on the presence of a global `window`, matching the browser
+ * check used elsewhere in this package (see `getRuntimeEnvironmentUserAgent`)
+ * so the SDK has a single, consistent definition of "browser". Server runtimes
+ * (Node.js, Deno, Bun, edge/workers) do not define `window`.
+ */
+declare function isBrowserRuntime(globalThisAny?: any): boolean;
+/**
+ * Type-guard for Node.js `Buffer` instances.
+ *
+ * Uses optional chaining on `globalThis.Buffer` so it returns `false` in
+ * runtimes where `Buffer` is not available (e.g. CloudFlare Workers).
+ */
+declare function isBuffer(value: unknown): value is Buffer;
+/**
+ * Returns true when `url` has the same origin (scheme + host + port) as
+ * `baseUrl`.
+ *
+ * Used to decide whether provider credentials may be attached to a request to a
+ * URL taken from a provider response (e.g. a polling or media-download URL).
+ * Credentials must only be sent to the provider's own origin; a response that
+ * names a foreign host (a CDN, or an attacker-controlled host if the response
+ * is tampered with) must not receive the API key.
+ *
+ * Returns false if either value is not a valid absolute URL (fail-closed).
+ */
+declare function isSameOrigin(url: string, baseUrl: string): boolean;
+/**
+ * Type guard that checks whether a value is not `null` or `undefined`.
+ *
+ * @template T - The type of the value to check.
+ * @param value - The value to check.
+ * @returns `true` if the value is neither `null` nor `undefined`, otherwise `false`.
+ */
+declare function isNonNullable<T>(value: T | undefined | null): value is NonNullable<T>;
+/**
+ * Checks whether a value is a provider reference (a mapping of provider names
+ * to provider-specific identifiers) as opposed to raw bytes, a URL, or a
+ * tagged `{ type: ... }` object.
+ */
+declare function isProviderReference(data: unknown): data is SharedV4ProviderReference;
+/**
+ * Checks whether a value is a non-null, non-array object.
+ */
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * Checks if the given URL is supported natively by the model.
+ *
+ * @param mediaType - The media type of the URL. Case-sensitive. May be a full
+ *                    `type/subtype`, a wildcard `type/*`, or just the
+ *                    top-level segment (e.g. `image`).
+ * @param url - The URL to check.
+ * @param supportedUrls - A record where keys are case-sensitive media types (or '*')
+ *                        and values are arrays of RegExp patterns for URLs.
+ *
+ * @returns `true` if the URL matches a pattern under the specific media type
+ *          or the wildcard '*', `false` otherwise.
+ */
+declare function isUrlSupported({ mediaType, url, supportedUrls }: {
+  mediaType: string;
+  url: string;
+  supportedUrls: Record<string, RegExp[]>;
+}): boolean;
+declare function loadApiKey({ apiKey, environmentVariableName, apiKeyParameterName, description }: {
+  apiKey: string | undefined;
+  environmentVariableName: string;
+  apiKeyParameterName?: string;
+  description: string;
+}): string;
+/**
+ * Loads an optional `string` setting from the environment or a parameter.
+ *
+ * @param settingValue - The setting value.
+ * @param environmentVariableName - The environment variable name.
+ * @returns The setting value.
+ */
+declare function loadOptionalSetting({ settingValue, environmentVariableName }: {
+  settingValue: string | undefined;
+  environmentVariableName: string;
+}): string | undefined;
+/**
+ * Loads a `string` setting from the environment or a parameter.
+ *
+ * @param settingValue - The setting value.
+ * @param environmentVariableName - The environment variable name.
+ * @param settingName - The setting name.
+ * @param description - The description of the setting.
+ * @returns The setting value.
+ */
+declare function loadSetting({ settingValue, environmentVariableName, settingName, description }: {
+  settingValue: string | undefined;
+  environmentVariableName: string;
+  settingName: string;
+  description: string;
+}): string;
+type ReasoningLevel = Exclude<LanguageModelV4CallOptions['reasoning'], 'none' | 'provider-default' | undefined>;
+declare function isCustomReasoning(reasoning: LanguageModelV4CallOptions['reasoning']): reasoning is Exclude<LanguageModelV4CallOptions['reasoning'], 'provider-default' | undefined>;
+/**
+ * Maps a top-level reasoning level to a provider-specific effort string using
+ * the given effort map. Pushes a compatibility warning if the reasoning level
+ * maps to a different string, or an unsupported warning if the level is not
+ * present in the map.
+ *
+ * @returns The mapped effort string, or `undefined` if the level is not
+ *   supported.
+ */
+declare function mapReasoningToProviderEffort<T extends string>({ reasoning, effortMap, warnings }: {
+  reasoning: ReasoningLevel;
+  effortMap: Partial<Record<ReasoningLevel, T>>;
+  warnings: SharedV4Warning[];
+}): T | undefined;
+/**
+ * Maps a top-level reasoning level to an absolute token budget by multiplying
+ * the model's max output tokens by a percentage from the budget percentages
+ * map. The result is clamped between `minReasoningBudget` (default 1024) and
+ * `maxReasoningBudget`. Pushes an unsupported warning if the level is not
+ * present in the budget percentages map.
+ *
+ * @returns The computed token budget, or `undefined` if the level is not
+ *   supported.
+ */
+declare function mapReasoningToProviderBudget({ reasoning, maxOutputTokens, maxReasoningBudget, minReasoningBudget, budgetPercentages, warnings }: {
+  reasoning: ReasoningLevel;
+  maxOutputTokens: number;
+  maxReasoningBudget: number;
+  minReasoningBudget?: number;
+  budgetPercentages?: Partial<Record<ReasoningLevel, number>>;
+  warnings: SharedV4Warning[];
+}): number | undefined;
 /**
  * A value that can be provided either synchronously or as a promise-like.
  */
@@ -11324,16 +11833,69 @@ type MaybePromiseLike<T> = T | PromiseLike<T>;
  * @returns The corresponding file extension
  * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/MIME_types/Common_types
  */
+declare function mediaTypeToExtension(mediaType: string): string;
+/**
+ * Normalizes different header inputs into a plain record with lower-case keys.
+ * Entries with `undefined` or `null` values are removed.
+ *
+ * @param headers - Input headers (`Headers`, tuples array, plain record) to normalize.
+ * @returns A record containing the normalized header entries.
+ */
+declare function normalizeHeaders(headers: HeadersInit | Record<string, string | undefined> | Array<[string, string | undefined]> | undefined): Record<string, string>;
 /**
  * Parses a JSON event stream into a stream of parsed JSON objects.
  */
-declare function parseJsonEventStream<T>({
-  stream,
-  schema
-}: {
+declare function parseJsonEventStream<T>({ stream, schema }: {
   stream: ReadableStream<Uint8Array>;
   schema: FlexibleSchema<T>;
 }): ReadableStream<ParseResult<T>>;
+declare function parseProviderOptions<OPTIONS>({ provider, providerOptions, schema }: {
+  provider: string;
+  providerOptions: Record<string, unknown> | undefined;
+  schema: FlexibleSchema<OPTIONS>;
+}): Promise<OPTIONS | undefined>;
+declare const postJsonToApi: <T>({ url, headers, body, failedResponseHandler, successfulResponseHandler, abortSignal, fetch }: {
+  url: string;
+  headers?: Record<string, string | undefined>;
+  body: unknown;
+  failedResponseHandler: ResponseHandler<APICallError>;
+  successfulResponseHandler: ResponseHandler<T>;
+  abortSignal?: AbortSignal;
+  fetch?: FetchFunction;
+}) => Promise<{
+  value: T;
+  rawValue?: unknown;
+  responseHeaders?: Record<string, string>;
+}>;
+declare const postFormDataToApi: <T>({ url, headers, formData, failedResponseHandler, successfulResponseHandler, abortSignal, fetch }: {
+  url: string;
+  headers?: Record<string, string | undefined>;
+  formData: FormData;
+  failedResponseHandler: ResponseHandler<APICallError>;
+  successfulResponseHandler: ResponseHandler<T>;
+  abortSignal?: AbortSignal;
+  fetch?: FetchFunction;
+}) => Promise<{
+  value: T;
+  rawValue?: unknown;
+  responseHeaders?: Record<string, string>;
+}>;
+declare const postToApi: <T>({ url, headers, body, successfulResponseHandler, failedResponseHandler, abortSignal, fetch }: {
+  url: string;
+  headers?: Record<string, string | undefined>;
+  body: {
+    content: string | FormData | Uint8Array | Blob;
+    values: unknown;
+  };
+  failedResponseHandler: ResponseHandler<Error>;
+  successfulResponseHandler: ResponseHandler<T>;
+  abortSignal?: AbortSignal;
+  fetch?: FetchFunction;
+}) => Promise<{
+  value: T;
+  rawValue?: unknown;
+  responseHeaders?: Record<string, string>;
+}>;
 /**
  * A context object that is passed into tool execution.
  */
@@ -11347,6 +11909,7 @@ type ExecutableTool<TOOL extends Tool = Tool> = TOOL & {
 /**
  * Checks whether a tool exposes an execute function.
  */
+declare function isExecutableTool<TOOL extends Tool>(tool: TOOL | undefined): tool is ExecutableTool<TOOL>;
 type NeverOptional<N, T> = 0 extends 1 & N ? Partial<T> : [N] extends [never] ? Partial<Record<keyof T, undefined>> : T;
 /**
  * Tool approval request prompt part.
@@ -11970,6 +12533,31 @@ declare function dynamicTool(tool: Omit<DynamicTool<unknown, unknown, Context$1>
  * A provider-defined tool is a tool for which the provider defines the input
  * and output schemas, but does not execute the tool.
  */
+type ProviderDefinedToolFactory<INPUT, ARGS extends object, CONTEXT extends Context$1 = {}> = <OUTPUT>(options: ARGS & {
+  execute?: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
+  needsApproval?: Tool<INPUT, OUTPUT, CONTEXT>['needsApproval'];
+  toModelOutput?: Tool<INPUT, OUTPUT, CONTEXT>['toModelOutput'];
+  onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
+  onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
+  onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
+}) => ProviderDefinedTool<INPUT, OUTPUT, CONTEXT>;
+declare function createProviderDefinedToolFactory<INPUT, ARGS extends object, CONTEXT extends Context$1 = {}>({ id, inputSchema }: {
+  id: `${string}.${string}`;
+  inputSchema: FlexibleSchema<INPUT>;
+}): ProviderDefinedToolFactory<INPUT, ARGS, CONTEXT>;
+type ProviderDefinedToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS extends object, CONTEXT extends Context$1 = {}> = (options: ARGS & {
+  execute?: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
+  needsApproval?: Tool<INPUT, OUTPUT, CONTEXT>['needsApproval'];
+  toModelOutput?: Tool<INPUT, OUTPUT, CONTEXT>['toModelOutput'];
+  onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
+  onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
+  onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
+}) => ProviderDefinedTool<INPUT, OUTPUT, CONTEXT>;
+declare function createProviderDefinedToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS extends object, CONTEXT extends Context$1 = {}>({ id, inputSchema, outputSchema }: {
+  id: `${string}.${string}`;
+  inputSchema: FlexibleSchema<INPUT>;
+  outputSchema: FlexibleSchema<OUTPUT>;
+}): ProviderDefinedToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS, CONTEXT>;
 /**
  * A provider-executed tool is a tool for which the provider executes the tool.
  */
@@ -11978,6 +12566,71 @@ type ProviderExecutedToolFactory<INPUT, OUTPUT, ARGS extends object, CONTEXT ext
   onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
   onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
 }) => ProviderExecutedTool<INPUT, OUTPUT, CONTEXT>;
+declare function createProviderExecutedToolFactory<INPUT, OUTPUT, ARGS extends object, CONTEXT extends Context$1 = {}>({ id, inputSchema, outputSchema, supportsDeferredResults }: {
+  id: `${string}.${string}`;
+  inputSchema: FlexibleSchema<INPUT>;
+  outputSchema: FlexibleSchema<OUTPUT>;
+  /**
+   * Whether this provider-executed tool supports deferred results.
+   *
+   * When true, the tool result may not be returned in the same turn as the
+   * tool call (e.g., when using programmatic tool calling where a server tool
+   * triggers a client-executed tool, and the server tool's result is deferred
+   * until the client tool is resolved).
+   *
+   * @default false
+   */
+  supportsDeferredResults?: boolean;
+}): ProviderExecutedToolFactory<INPUT, OUTPUT, ARGS, CONTEXT>;
+/**
+ * Cancels a response body to release the underlying connection.
+ *
+ * When a fetch Response is rejected without consuming its body (e.g. a failed
+ * status code, an open-redirect rejection, or a Content-Length that exceeds the
+ * size limit), the underlying TCP socket is not returned to the connection pool
+ * and may stay open until the process runs out of file descriptors. Cancelling
+ * the body avoids this leak.
+ *
+ * Errors thrown while cancelling are ignored: the body may already be locked,
+ * disturbed, or absent, none of which should mask the original rejection.
+ */
+declare function cancelResponseBody(response: Response): Promise<void>;
+/**
+ * Default maximum download size: 2 GiB.
+ *
+ * `fetch().arrayBuffer()` has ~2x peak memory overhead (undici buffers the
+ * body internally, then creates the JS ArrayBuffer), so very large downloads
+ * risk exceeding the default V8 heap limit on 64-bit systems and terminating
+ * the process with an out-of-memory error.
+ *
+ * Setting this limit converts an unrecoverable OOM crash into a catchable
+ * `DownloadError`.
+ */
+declare const DEFAULT_MAX_DOWNLOAD_SIZE: number;
+/**
+ * Reads a fetch Response body with a size limit to prevent memory exhaustion.
+ *
+ * Checks the Content-Length header for early rejection, then reads the body
+ * incrementally via ReadableStream and aborts with a DownloadError when the
+ * limit is exceeded.
+ *
+ * @param response - The fetch Response to read.
+ * @param url - The URL being downloaded (used in error messages).
+ * @param maxBytes - Maximum allowed bytes. Defaults to DEFAULT_MAX_DOWNLOAD_SIZE.
+ * @returns A Uint8Array containing the response body.
+ * @throws DownloadError if the response exceeds maxBytes.
+ */
+declare function readResponseWithSizeLimit({ response, url, maxBytes }: {
+  response: Response;
+  url: string;
+  maxBytes?: number;
+}): Promise<Uint8Array>;
+/**
+ * Removes entries from a record where the value is null or undefined.
+ * @param record - The input object whose entries may be null or undefined.
+ * @returns A new object containing only entries with non-null and non-undefined values.
+ */
+declare function removeUndefinedEntries<T>(record: Record<string, T | undefined>): Record<string, T>;
 /**
  * A value or a lazy provider of a value, each of which may be synchronous or asynchronous.
  *
@@ -11998,6 +12651,338 @@ type Resolvable<T> = MaybePromiseLike<T> | (() => MaybePromiseLike<T>);
  * Resolves a value that could be a raw value, a Promise, a function returning a value,
  * or a function returning a Promise.
  */
+declare function resolve<T>(value: Resolvable<T>): Promise<T>;
+/**
+ * Resolves a file part's media type to a full `type/subtype` form required by
+ * providers whose API demands the full IANA media type.
+ *
+ * - If `part.mediaType` is already a full media type (e.g. `image/png`), it is
+ *   returned as-is.
+ * - Otherwise, when inline bytes are available (`part.data.type === 'data'`),
+ *   the subtype is sniffed from the bytes using the signature table that
+ *   corresponds to the top-level segment.
+ * - When neither applies (e.g. top-level-only with a URL source, or bytes that
+ *   cannot be detected), an `UnsupportedFunctionalityError` is thrown.
+ */
+declare function resolveFullMediaType({ part }: {
+  part: LanguageModelV4FilePart;
+}): string;
+/**
+ * Resolves a provider reference to the provider-specific identifier for the
+ * given provider. Throws `NoSuchProviderReferenceError` if the provider is not
+ * found in the reference mapping.
+ */
+declare function resolveProviderReference({ reference, provider }: {
+  reference: SharedV4ProviderReference;
+  provider: string;
+}): string;
+type RetryFunction = <OUTPUT>(fn: () => PromiseLike<OUTPUT>) => PromiseLike<OUTPUT>;
+type RetryErrorReason$1 = 'maxRetriesExceeded' | 'errorNotRetryable';
+type RetryErrorFactory = ({ message, reason, errors }: {
+  message: string;
+  reason: RetryErrorReason$1;
+  errors: Array<unknown>;
+}) => unknown;
+type RetryDelayProvider = ({ error, exponentialBackoffDelay }: {
+  error: unknown;
+  exponentialBackoffDelay: number;
+}) => number;
+type ShouldRetryFunction = (error: unknown) => boolean | Promise<boolean>;
+/**
+ * Retries a failed operation with exponential backoff.
+ */
+declare const retryWithExponentialBackoff: ({ maxRetries, initialDelayInMs, backoffFactor, abortSignal, shouldRetry, getDelayInMs, createRetryError }: {
+  maxRetries?: number;
+  initialDelayInMs?: number;
+  backoffFactor?: number;
+  abortSignal?: AbortSignal;
+  shouldRetry: ShouldRetryFunction;
+  getDelayInMs?: RetryDelayProvider;
+  createRetryError?: RetryErrorFactory;
+}) => RetryFunction;
+/**
+ * Serializes a model instance for workflow step boundaries.
+ * Returns the `modelId` plus the JSON-serializable config properties.
+ *
+ * Non-serializable values are omitted. As a special case, a
+ * function-valued `headers` property is resolved during serialization
+ * and included if the returned value is JSON-serializable.
+ *
+ * Used as the body of `static [WORKFLOW_SERIALIZE]` in provider models.
+ *
+ * @example
+ * ```ts
+ * static [WORKFLOW_SERIALIZE](model: MyLanguageModel) {
+ *   return serializeModelOptions({
+ *     modelId: model.modelId,
+ *     config: model.config,
+ *   });
+ * }
+ * ```
+ */
+declare function serializeModelOptions<CONFIG extends {
+  headers?: Resolvable<Record<string, string | undefined>>;
+}>(options: {
+  modelId: string;
+  config: CONFIG;
+}): {
+  modelId: string;
+  config: JSONObject$2;
+};
+declare const symbol$10: unique symbol;
+declare class SerializationError extends AISDKError {
+  private readonly [symbol$10];
+  constructor({ message, cause }?: {
+    message?: string;
+    cause?: unknown;
+  });
+  static isInstance(error: unknown): error is SerializationError;
+}
+declare function secureJsonParse(text: string): any;
+/**
+ * Minimal interface for a streaming tool call delta from an OpenAI-compatible API.
+ */
+interface StreamingToolCallDelta {
+  index?: number | null;
+  id?: string | null;
+  type?: string | null;
+  function?: {
+    name?: string | null;
+    arguments?: string | null;
+  } | null;
+}
+interface StreamingToolCallTrackerOptions<DELTA extends StreamingToolCallDelta = StreamingToolCallDelta> {
+  /**
+   * ID generator function for tool call IDs.
+   * Defaults to the standard generateId.
+   */
+  generateId?: () => string;
+  /**
+   * How to validate the `type` field on new tool call deltas.
+   * - `'none'`: no validation (default)
+   * - `'if-present'`: throw if type is present and not `'function'`
+   * - `'required'`: throw if type is not exactly `'function'`
+   */
+  typeValidation?: 'none' | 'if-present' | 'required';
+  /**
+   * Extract provider-specific metadata from a tool call delta.
+   * Called once when a new tool call is detected.
+   * The returned metadata is stored on the tool call and passed to
+   * `buildToolCallProviderMetadata` when the tool call is finalized.
+   */
+  extractMetadata?: (delta: DELTA) => SharedV4ProviderMetadata | undefined;
+  /**
+   * Build the `providerMetadata` object for a `tool-call` event.
+   * Receives the metadata previously extracted via `extractMetadata`.
+   * If `undefined` is returned, no `providerMetadata` is included in the event.
+   */
+  buildToolCallProviderMetadata?: (metadata: SharedV4ProviderMetadata | undefined) => SharedV4ProviderMetadata | undefined;
+}
+type StreamingToolCallTrackerController = Pick<TransformStreamDefaultController<LanguageModelV4StreamPart>, 'enqueue'>;
+/**
+ * Tracks streaming tool call state across multiple deltas from an
+ * OpenAI-compatible chat completion stream. Handles argument accumulation,
+ * emits tool-input-start/delta/end and tool-call events, and finalizes
+ * unfinished tool calls on flush.
+ *
+ * Used by openai, openai-compatible, groq, deepseek, and alibaba providers.
+ */
+declare class StreamingToolCallTracker<DELTA extends StreamingToolCallDelta = StreamingToolCallDelta> {
+  private toolCalls;
+  private toolCallsById;
+  private toolCallsByIndex;
+  private latestToolCall;
+  private readonly controller;
+  private readonly _generateId;
+  private readonly typeValidation;
+  private readonly extractMetadata?;
+  private readonly buildToolCallProviderMetadata?;
+  constructor(controller: StreamingToolCallTrackerController, options?: StreamingToolCallTrackerOptions<DELTA>);
+  /**
+   * Process a tool call delta from a streaming response chunk.
+   * Emits tool-input-start, tool-input-delta, tool-input-end, and tool-call
+   * events as appropriate.
+   */
+  processDelta(toolCallDelta: DELTA): void;
+  /**
+   * Finalize any unfinished tool calls. Should be called during the stream's
+   * flush handler to ensure all tool calls are properly completed.
+   */
+  flush(): void;
+  private processNewToolCall;
+  private processExistingToolCall;
+  private finishToolCall;
+}
+/**
+ * Strips file extension segments from a filename.
+ *
+ * Examples:
+ * - "report.pdf" -> "report"
+ * - "archive.tar.gz" -> "archive"
+ * - "filename" -> "filename"
+ */
+declare function stripFileExtension(filename: string): string;
+/**
+ * Experimental transcription-stream WebSocket envelope (v1): the standard
+ * serialization of `TranscriptionModelV4.doStream` over a WebSocket. Clients
+ * (e.g. the `@ai-sdk/gateway` provider) encode with this module and servers
+ * (e.g. AI Gateway) decode with it, so the two sides cannot drift.
+ *
+ * Envelope rules:
+ *
+ * 1. The client sends exactly one `transcription-stream.start` TEXT frame
+ *    first.
+ * 2. Audio rides BINARY frames containing raw bytes in the declared
+ *    `inputAudioFormat` (base64 string chunks are decoded before sending).
+ * 3. The client signals end of audio with the
+ *    `transcription-stream.audio-done` TEXT frame; a plain close without it
+ *    is an abort.
+ * 4. Every server→client TEXT frame is one JSON-serialized
+ *    `TranscriptionModelV4StreamPart` (flattened, no wrapper). Payloads must
+ *    be JSON-serializable. `Date` values (`response-metadata.timestamp`)
+ *    serialize to ISO 8601 strings and are revived by
+ *    `parseTranscriptionStreamPart`. `Error` payloads in `error` parts
+ *    serialize as `{ name, message }`.
+ * 5. The server closes with code 1000 after the `finish` part; on failure it
+ *    sends an `error` part and closes non-1000. A close without a prior
+ *    `finish` is an error.
+ * 6. Unknown frame/part types are ignored in both directions (forward
+ *    compatibility).
+ * 7. Servers may enforce a maximum frame size (the AI Gateway rejects frames
+ *    over 256 KiB); clients should split audio into frames of at most
+ *    64 KiB.
+ * 8. Connection establishment (URL, auth) is transport-specific and out of
+ *    scope.
+ *
+ * The envelope validates frame shape only; server policy (accepted audio
+ * formats, required `rate`, size limits) layers on top. Both parsers use
+ * `secureJsonParse`, so frames carrying `__proto__` / `constructor.prototype`
+ * keys are rejected (prototype-pollution protection) rather than parsed.
+ */
+/** Type of the first client TEXT frame. */
+declare const TRANSCRIPTION_STREAM_START_FRAME_TYPE = "transcription-stream.start";
+/** Type of the client TEXT frame that signals the end of the audio input. */
+declare const TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE = "transcription-stream.audio-done";
+/**
+ * The client's session start frame. Optional keys are omitted when undefined.
+ */
+type TranscriptionStreamStartFrame = {
+  type: typeof TRANSCRIPTION_STREAM_START_FRAME_TYPE;
+  /** Audio format of the binary audio frames, e.g. `{ type: 'audio/pcm', rate: 16000 }`. */
+  inputAudioFormat: {
+    type: string;
+    rate?: number;
+  };
+  /** Provider-specific options, passed through verbatim. */
+  providerOptions?: Record<string, JSONObject$2>;
+  /** When true, the server should include `raw` parts in the stream. */
+  includeRawChunks?: boolean;
+};
+/** Server-side classification of a client TEXT frame. */
+type TranscriptionStreamClientFrame = {
+  type: 'start';
+  frame: TranscriptionStreamStartFrame;
+} | {
+  type: 'audio-done';
+} | {
+  /** Malformed JSON or a recognized frame with an invalid shape. */
+  type: 'invalid';
+  message: string;
+} | {
+  /** Unrecognized frame type; ignore for forward compatibility. */
+  type: 'unknown';
+};
+/**
+ * Server-side: parse a client TEXT frame. Validates envelope shape only and
+ * rejects prototype-pollution payloads (parsed with `secureJsonParse`). Never
+ * throws.
+ */
+declare function parseTranscriptionStreamClientFrame(text: string): TranscriptionStreamClientFrame;
+/**
+ * Server-side: serialize a transcription stream part as one TEXT frame.
+ * `Error` payloads in `error` parts serialize as `{ name, message }` —
+ * `Error` properties are non-enumerable, so a plain `JSON.stringify` would
+ * serialize them to `{}` and lose the message end-to-end. Returns
+ * `undefined` for payloads that are not JSON-serializable (envelope rule 4,
+ * e.g. bigint or cyclic values); callers drop the frame.
+ */
+declare function serializeTranscriptionStreamPart(part: TranscriptionModelV4StreamPart): string | undefined;
+/**
+ * Client-side: parse a server TEXT frame into a transcription stream part.
+ * Returns `undefined` for malformed or unsafe (prototype-polluting) JSON
+ * (parsed with `secureJsonParse`), unknown part types, and known part types
+ * whose required or optional fields are missing or mistyped (including
+ * warning and segment elements) — downstream SDK code dereferences those
+ * fields, so a drifted server must not crash or pollute the stream.
+ * Revives `response-metadata.timestamp` to a `Date`.
+ */
+declare function parseTranscriptionStreamPart(text: string): TranscriptionModelV4StreamPart | undefined;
+declare function convertBase64ToUint8Array(base64String: string): Uint8Array<ArrayBuffer>;
+declare function convertUint8ArrayToBase64(array: Uint8Array): string;
+declare function convertToBase64(value: string | Uint8Array): string;
+declare function validateBaseURL(baseURL: string | undefined): string | undefined;
+/**
+ * Validates that a URL is safe to download from, blocking private/internal addresses
+ * to prevent SSRF attacks.
+ *
+ * Note: this function performs string/literal-IP checks only. The Node.js
+ * download fetch additionally validates and pins DNS results at connect time.
+ *
+ * @param url - The URL string to validate.
+ * @throws DownloadError if the URL is unsafe.
+ */
+declare function validateDownloadUrl(url: string): void;
+/**
+ * Validates the types of an unknown object using a schema and
+ * return a strongly-typed object.
+ *
+ * @template T - The type of the object to validate.
+ * @param {string} options.value - The object to validate.
+ * @param {Validator<T>} options.schema - The schema to use for validating the JSON.
+ * @param {TypeValidationContext} options.context - Optional context about what is being validated.
+ * @returns {Promise<T>} - The typed object.
+ */
+declare function validateTypes<OBJECT>({ value, schema, context }: {
+  value: unknown;
+  schema: FlexibleSchema<OBJECT>;
+  context?: TypeValidationContext;
+}): Promise<OBJECT>;
+/**
+ * Safely validates the types of an unknown object using a schema and
+ * return a strongly-typed object.
+ *
+ * @template T - The type of the object to validate.
+ * @param {string} options.value - The JSON object to validate.
+ * @param {Validator<T>} options.schema - The schema to use for validating the JSON.
+ * @param {TypeValidationContext} options.context - Optional context about what is being validated.
+ * @returns An object with either a `success` flag and the parsed and typed data, or a `success` flag and an error object.
+ */
+declare function safeValidateTypes<OBJECT>({ value, schema, context }: {
+  value: unknown;
+  schema: FlexibleSchema<OBJECT>;
+  context?: TypeValidationContext;
+}): Promise<{
+  success: true;
+  value: OBJECT;
+  rawValue: unknown;
+} | {
+  success: false;
+  error: TypeValidationError;
+  rawValue: unknown;
+}>;
+declare const VERSION: string;
+/**
+ * Appends suffix parts to the `user-agent` header.
+ * If a `user-agent` header already exists, the suffix parts are appended to it.
+ * If no `user-agent` header exists, a new one is created with the suffix parts.
+ * Automatically removes undefined entries from the headers.
+ *
+ * @param headers - The original headers.
+ * @param userAgentSuffixParts - The parts to append to the `user-agent` header.
+ * @returns The new headers with the `user-agent` header set or updated.
+ */
+declare function withUserAgentSuffix(headers: HeadersInit | Record<string, string | undefined> | undefined, ...userAgentSuffixParts: string[]): Record<string, string>;
+declare function withoutTrailingSlash(url: string | undefined): string | undefined;
 /**
  * Detects the `any` type so untyped tools can be treated as having no explicit
  * context type.
@@ -12039,6 +13024,17 @@ type InferToolOutput<TOOL extends Tool<any, any, any>> = TOOL extends Tool<any,
  * @yields A preliminary output for each streamed value, followed by a final output, or a single final
  * output for non-streaming tools.
  */
+declare function executeTool<TOOL extends Tool>({ tool: tool$1, input, options }: {
+  tool: ExecutableTool<TOOL>;
+  input: InferToolInput<TOOL>;
+  options: ToolExecutionOptions<InferToolContext<TOOL>>;
+}): AsyncGenerator<{
+  type: 'preliminary';
+  output: InferToolOutput<TOOL>;
+} | {
+  type: 'final';
+  output: InferToolOutput<TOOL>;
+}>;
 /**
  * A mapping of tool names to tool definitions.
  */
@@ -12047,17 +13043,17 @@ type ToolSet = Record<string, (Tool<never, never, any> | Tool<any, any, any> | T
  * Builds the required portion of the tool context map for tools whose context
  * type does not include `undefined`.
  */
-type RequiredToolSetContext<TOOLS extends ToolSet> = { [K in keyof TOOLS as InferToolContext<NoInfer<TOOLS[K]>> extends never ? never : undefined extends InferToolContext<NoInfer<TOOLS[K]>> ? never : K]: InferToolContext<NoInfer<TOOLS[K]>> };
+type RequiredToolSetContext<TOOLS extends ToolSet> = { [K in keyof TOOLS as InferToolContext<NoInfer<TOOLS[K]>> extends never ? never : undefined extends InferToolContext<NoInfer<TOOLS[K]>> ? never : K]: InferToolContext<NoInfer<TOOLS[K]>>; };
 /**
  * Builds the optional portion of the tool context map for tools whose context
  * object itself may be `undefined`.
  */
-type OptionalToolSetContext<TOOLS extends ToolSet> = { [K in keyof TOOLS as InferToolContext<NoInfer<TOOLS[K]>> extends never ? never : undefined extends InferToolContext<NoInfer<TOOLS[K]>> ? K : never]?: InferToolContext<NoInfer<TOOLS[K]>> };
+type OptionalToolSetContext<TOOLS extends ToolSet> = { [K in keyof TOOLS as InferToolContext<NoInfer<TOOLS[K]>> extends never ? never : undefined extends InferToolContext<NoInfer<TOOLS[K]>> ? K : never]?: InferToolContext<NoInfer<TOOLS[K]>>; };
 /**
  * Flattens intersected mapped types so type equality assertions and editor
  * hovers show the resulting object shape.
  */
-type Normalize<OBJECT> = { [KEY in keyof OBJECT]: OBJECT[KEY] };
+type Normalize<OBJECT> = { [KEY in keyof OBJECT]: OBJECT[KEY]; };
 /**
  * Infer the context type for a tool set.
  *
@@ -12105,37 +13101,42 @@ type ToolCallerTool<TOOL extends Tool = Tool> = TOOL & {
   readonly experimental_toolCaller: ToolCallerDefinition;
 };
 declare function toolCaller<TOOL extends Tool>(tool: TOOL, definition: ToolCallerDefinition): ToolCallerTool<TOOL>;
+declare function getToolCaller(tool: Tool | undefined): ToolCallerDefinition | undefined;
+/**
+ * Typed tool result that is returned by `generateText` and `streamText`.
+ * It contains the tool call ID, the tool name, the tool arguments, and the tool result.
+ */
+interface ToolResult<NAME extends string, INPUT, OUTPUT> {
+  /**
+   * 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 was called.
+   */
+  toolName: NAME;
+  /**
+   * Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
+   */
+  input: INPUT;
+  /**
+   * Result of the tool call. This is the result of the tool's execution.
+   */
+  output: OUTPUT;
+  /**
+   * Whether the tool result has been executed by the provider.
+   */
+  providerExecuted?: boolean;
+  /**
+   * Whether the tool is dynamic.
+   */
+  dynamic?: boolean;
+}
 //#endregion
 //#region ../../node_modules/.pnpm/@ai-sdk+gateway@4.0.52_zod@4.4.3/node_modules/@ai-sdk/gateway/dist/index.d.ts
 type GatewayEmbeddingModelId = 'alibaba/qwen3-embedding-0.6b' | 'alibaba/qwen3-embedding-4b' | 'alibaba/qwen3-embedding-8b' | 'amazon/titan-embed-text-v2' | 'cohere/embed-v4.0' | 'google/gemini-embedding-001' | 'google/gemini-embedding-2' | 'google/text-embedding-005' | 'google/text-multilingual-embedding-002' | 'mistral/codestral-embed' | 'mistral/mistral-embed' | 'openai/text-embedding-3-large' | 'openai/text-embedding-3-small' | 'openai/text-embedding-ada-002' | 'perplexity/pplx-embed-v1-0.6b' | 'perplexity/pplx-embed-v1-4b' | 'voyage/voyage-3-large' | 'voyage/voyage-3.5' | 'voyage/voyage-3.5-lite' | 'voyage/voyage-4' | 'voyage/voyage-4-large' | 'voyage/voyage-4-lite' | 'voyage/voyage-code-2' | 'voyage/voyage-code-3' | 'voyage/voyage-finance-2' | 'voyage/voyage-law-2' | (string & {});
 type GatewayImageModelId = 'bfl/flux-2-flex' | 'bfl/flux-2-klein-4b' | 'bfl/flux-2-klein-9b' | 'bfl/flux-2-max' | 'bfl/flux-2-pro' | 'bfl/flux-kontext-max' | 'bfl/flux-kontext-pro' | 'bfl/flux-pro-1.0-fill' | 'bfl/flux-pro-1.1' | 'bfl/flux-pro-1.1-ultra' | 'bytedance/seedream-4.0' | 'bytedance/seedream-4.5' | 'bytedance/seedream-5.0-lite' | 'bytedance/seedream-5.0-pro' | 'google/imagen-4.0-fast-generate-001' | 'google/imagen-4.0-generate-001' | 'google/imagen-4.0-ultra-generate-001' | 'openai/gpt-image-1' | 'openai/gpt-image-1-mini' | 'openai/gpt-image-1.5' | 'openai/gpt-image-2' | 'prodia/flux-fast-schnell' | 'quiverai/arrow-1.1' | 'recraft/recraft-v2' | 'recraft/recraft-v3' | 'recraft/recraft-v4' | 'recraft/recraft-v4-pro' | 'recraft/recraft-v4.1' | 'recraft/recraft-v4.1-pro' | 'recraft/recraft-v4.1-utility' | 'recraft/recraft-v4.1-utility-pro' | 'xai/grok-imagine-image' | 'xai/grok-imagine-image-2.0' | (string & {});
 type GatewayModelId = 'alibaba/qwen-3-14b' | 'alibaba/qwen-3-235b' | 'alibaba/qwen-3-30b' | 'alibaba/qwen-3-32b' | 'alibaba/qwen-3.6-max-preview' | 'alibaba/qwen3-235b-a22b-thinking' | 'alibaba/qwen3-coder' | 'alibaba/qwen3-coder-30b-a3b' | 'alibaba/qwen3-coder-next' | 'alibaba/qwen3-coder-plus' | 'alibaba/qwen3-max' | 'alibaba/qwen3-max-preview' | 'alibaba/qwen3-max-thinking' | 'alibaba/qwen3-next-80b-a3b-instruct' | 'alibaba/qwen3-next-80b-a3b-thinking' | 'alibaba/qwen3-vl-235b-a22b-instruct' | 'alibaba/qwen3-vl-instruct' | 'alibaba/qwen3-vl-thinking' | 'alibaba/qwen3.5-flash' | 'alibaba/qwen3.5-plus' | 'alibaba/qwen3.6-27b' | 'alibaba/qwen3.6-plus' | 'alibaba/qwen3.7-flash' | 'alibaba/qwen3.7-max' | 'alibaba/qwen3.7-plus' | 'alibaba/qwen3.8-max' | 'amazon/nova-2-lite' | 'amazon/nova-lite' | 'amazon/nova-micro' | 'amazon/nova-pro' | 'anthropic/claude-3-haiku' | 'anthropic/claude-fable-5' | 'anthropic/claude-haiku-4.5' | 'anthropic/claude-opus-4' | 'anthropic/claude-opus-4.5' | 'anthropic/claude-opus-4.6' | 'anthropic/claude-opus-4.7' | 'anthropic/claude-opus-4.8' | 'anthropic/claude-opus-4.8-fast' | 'anthropic/claude-opus-5' | 'anthropic/claude-opus-5-fast' | 'anthropic/claude-sonnet-4' | 'anthropic/claude-sonnet-4.5' | 'anthropic/claude-sonnet-4.6' | 'anthropic/claude-sonnet-5' | 'arcee-ai/trinity-large-thinking' | 'arcee-ai/trinity-mini' | 'bytedance/seed-1.6' | 'bytedance/seed-1.8' | 'cohere/command-a' | 'deepseek/deepseek-r1' | 'deepseek/deepseek-v3' | 'deepseek/deepseek-v3.1' | 'deepseek/deepseek-v3.1-terminus' | 'deepseek/deepseek-v3.2' | 'deepseek/deepseek-v3.2-thinking' | 'deepseek/deepseek-v4-flash' | 'deepseek/deepseek-v4-flash-0731' | 'deepseek/deepseek-v4-pro' | 'deepseek/deepseek-v4-pro-0813' | 'google/gemini-2.5-flash' | 'google/gemini-2.5-flash-image' | 'google/gemini-2.5-flash-lite' | 'google/gemini-2.5-pro' | 'google/gemini-3-flash' | 'google/gemini-3-pro-image' | 'google/gemini-3.1-flash-image' | 'google/gemini-3.1-flash-image-preview' | 'google/gemini-3.1-flash-lite' | 'google/gemini-3.1-flash-lite-image' | 'google/gemini-3.1-pro-preview' | 'google/gemini-3.5-flash' | 'google/gemini-3.5-flash-lite' | 'google/gemini-3.6-flash' | 'google/gemini-3.7-flash' | 'google/gemini-omni-flash-preview' | 'google/gemma-4-26b-a4b-it' | 'google/gemma-4-31b-it' | 'inception/mercury-2' | 'inception/mercury-coder-small' | 'inclusionai/ling-3.0-flash' | 'inclusionai/ling-3.0-tiny-free' | 'interfaze/interfaze-beta' | 'kwaipilot/kat-coder-air-v2.5' | 'kwaipilot/kat-coder-pro-v1' | 'kwaipilot/kat-coder-pro-v2' | 'kwaipilot/kat-coder-pro-v2.5' | 'meta/llama-3.1-70b' | 'meta/llama-3.1-8b' | 'meta/llama-3.3-70b' | 'meta/llama-4-maverick' | 'meta/llama-4-scout' | 'meta/muse-glimmer-30b' | 'meta/muse-spark-1.1' | 'meta/muse-spark-1.2' | 'meta/muse-spark-1.2-contributor' | 'minimax/minimax-m2' | 'minimax/minimax-m2.1' | 'minimax/minimax-m2.1-lightning' | 'minimax/minimax-m2.5' | 'minimax/minimax-m2.5-highspeed' | 'minimax/minimax-m2.7' | 'minimax/minimax-m2.7-highspeed' | 'minimax/minimax-m3' | 'mistral/codestral' | 'mistral/devstral-2' | 'mistral/devstral-small-2' | 'mistral/magistral-medium' | 'mistral/magistral-small' | 'mistral/ministral-14b' | 'mistral/ministral-3b' | 'mistral/ministral-8b' | 'mistral/mistral-large-3' | 'mistral/mistral-medium' | 'mistral/mistral-medium-3.5' | 'mistral/mistral-nemo' | 'mistral/mistral-small' | 'mistral/pixtral-12b' | 'moonshotai/kimi-k2' | 'moonshotai/kimi-k2-thinking' | 'moonshotai/kimi-k2.5' | 'moonshotai/kimi-k2.6' | 'moonshotai/kimi-k2.7-code' | 'moonshotai/kimi-k2.7-code-highspeed' | 'moonshotai/kimi-k3' | 'moonshotai/kimi-k3-fast' | 'morph/morph-v3-fast' | 'morph/morph-v3-large' | 'nvidia/nemotron-3-nano-30b-a3b' | 'nvidia/nemotron-3-super-120b-a12b' | 'nvidia/nemotron-3-ultra-550b-a55b' | 'nvidia/nemotron-nano-12b-v2-vl' | 'nvidia/nemotron-nano-9b-v2' | 'openai/gpt-3.5-turbo' | 'openai/gpt-4-turbo' | 'openai/gpt-4.1' | 'openai/gpt-4.1-mini' | 'openai/gpt-4.1-nano' | 'openai/gpt-4o' | 'openai/gpt-4o-mini' | 'openai/gpt-4o-mini-search-preview' | 'openai/gpt-5' | 'openai/gpt-5-codex' | 'openai/gpt-5-mini' | 'openai/gpt-5-nano' | 'openai/gpt-5-pro' | 'openai/gpt-5.1-codex' | 'openai/gpt-5.1-codex-max' | 'openai/gpt-5.1-codex-mini' | 'openai/gpt-5.1-thinking' | 'openai/gpt-5.2' | 'openai/gpt-5.2-codex' | 'openai/gpt-5.2-pro' | 'openai/gpt-5.3-codex' | 'openai/gpt-5.4' | 'openai/gpt-5.4-mini' | 'openai/gpt-5.4-nano' | 'openai/gpt-5.4-pro' | 'openai/gpt-5.5' | 'openai/gpt-5.5-pro' | 'openai/gpt-5.6-luna' | 'openai/gpt-5.6-sol' | 'openai/gpt-5.6-terra' | 'openai/gpt-oss-120b' | 'openai/gpt-oss-20b' | 'openai/gpt-oss-safeguard-20b' | 'openai/o1' | 'openai/o3' | 'openai/o3-deep-research' | 'openai/o3-mini' | 'openai/o3-pro' | 'openai/o4-mini' | 'perplexity/sonar' | 'perplexity/sonar-pro' | 'perplexity/sonar-reasoning-pro' | 'poolside/laguna-s-2.1' | 'poolside/laguna-s-2.1-free' | 'sakana/fugu-ultra' | 'sakana/namazu' | 'stepfun/step-3.5-flash' | 'stepfun/step-3.7-flash' | 'tencent/hy3' | 'thinkingmachines/inkling' | 'thinkingmachines/inkling-small' | 'xai/grok-4.1-fast-non-reasoning' | 'xai/grok-4.1-fast-reasoning' | 'xai/grok-4.20-multi-agent' | 'xai/grok-4.20-multi-agent-beta' | 'xai/grok-4.20-non-reasoning' | 'xai/grok-4.20-non-reasoning-beta' | 'xai/grok-4.20-reasoning' | 'xai/grok-4.20-reasoning-beta' | 'xai/grok-4.3' | 'xai/grok-4.5' | 'xai/grok-4.6' | 'xai/grok-build-0.1' | 'xiaomi/mimo-v2.5' | 'xiaomi/mimo-v2.5-pro' | 'zai/glm-4.5' | 'zai/glm-4.5-air' | 'zai/glm-4.5v' | 'zai/glm-4.6' | 'zai/glm-4.6v' | 'zai/glm-4.6v-flash' | 'zai/glm-4.7' | 'zai/glm-4.7-flash' | 'zai/glm-4.7-flashx' | 'zai/glm-5' | 'zai/glm-5-turbo' | 'zai/glm-5.1' | 'zai/glm-5.2' | 'zai/glm-5.2-fast' | 'zai/glm-5v-turbo' | (string & {});
-/**
- * Shared WebSocket subprotocol contract for AI Gateway realtime and streaming
- * transcription auth.
- *
- * The browser `WebSocket` API cannot set request headers, so the Gateway auth
- * (bearer) token is carried through the `Sec-WebSocket-Protocol` handshake
- * instead of an `Authorization` header — the same workaround OpenAI uses for
- * `openai-insecure-api-key.<token>`.
- *
- * This module is the single source of truth for that contract so the client and
- * the Gateway server can't drift: the client encodes values with
- * `getGatewayRealtimeProtocols` / `getGatewayTranscriptionProtocols`, and the
- * Gateway server decodes them with `getGatewayRealtimeAuthToken` /
- * `getGatewayRealtimeTeamIdOrSlug`.
- *
- * WebSocket subprotocol values must fit the RFC token grammar. The auth token is
- * sent as-is, so callers must use tokens that are valid subprotocol tokens; the
- * optional team scope is base64url-encoded by this module. Keep the complete
- * `Sec-WebSocket-Protocol` header compact (target under an 8 KiB safe header
- * budget) because intermediaries may reject large upgrade headers.
- */
-/**
- * Marker subprotocol offered on every realtime handshake so the Gateway can
- * echo a negotiated subprotocol on the 101 response (some clients require the
- * server to select one of the offered subprotocols).
- */
 type GatewayRerankingModelId = 'cohere/rerank-v3.5' | 'cohere/rerank-v4-fast' | 'cohere/rerank-v4-pro' | 'voyage/rerank-2.5' | 'voyage/rerank-2.5-lite' | (string & {});
 type GatewaySpeechModelId = 'fish-audio/s1' | 'fish-audio/s2-pro' | 'fish-audio/s2.1-pro' | 'openai/tts-1' | 'openai/tts-1-hd' | 'xai/grok-tts' | (string & {});
 type GatewayTranscriptionModelId = 'fish-audio/transcribe-1' | 'openai/gpt-4o-mini-transcribe' | 'openai/gpt-4o-transcribe' | 'openai/gpt-realtime-whisper' | 'openai/whisper-1' | 'xai/grok-stt' | (string & {});
@@ -12808,12 +13809,16 @@ interface GatewayProvider extends ProviderV4 {
   tools: typeof gatewayTools;
 }
 type GatewayTranscriptionFactoryGetTokenOptions = {
-  model: GatewayTranscriptionModelId; /** Token lifetime in seconds. Gateway default is 60s (max 300s). */
+  model: GatewayTranscriptionModelId;
+  /** Token lifetime in seconds. Gateway default is 60s (max 300s). */
   expiresAfterSeconds?: number;
 };
 type GatewayTranscriptionFactoryGetTokenResult = {
-  /** The minted `vcst_` client secret. */token: string; /** WebSocket URL of the streaming transcription surface for this model. */
-  url: string; /** Token expiry, epoch seconds. */
+  /** The minted `vcst_` client secret. */
+  token: string;
+  /** WebSocket URL of the streaming transcription surface for this model. */
+  url: string;
+  /** Token expiry, epoch seconds. */
   expiresAt?: number;
 };
 /**
@@ -13258,13 +14263,21 @@ type LogWarningsFunction = (options: {
  * Called when the operation begins, before the embedding model is called.
  */
 type EmbedStartEvent = {
-  /** Unique identifier for this embed call, used to correlate events. */readonly callId: string; /** Identifies the operation type (e.g. 'ai.embed' or 'ai.embedMany'). */
-  readonly operationId: string; /** The provider identifier (e.g., 'openai', 'anthropic'). */
-  readonly provider: string; /** The specific model identifier (e.g., 'text-embedding-3-small'). */
-  readonly modelId: string; /** The value(s) being embedded. A string for embed, an array for embedMany. */
-  readonly value: string | Array<string>; /** Maximum number of retries for failed requests. */
-  readonly maxRetries: number; /** Additional HTTP headers sent with the request. */
-  readonly headers: Record<string, string | undefined> | undefined; /** Additional provider-specific options. */
+  /** Unique identifier for this embed call, used to correlate events. */
+  readonly callId: string;
+  /** Identifies the operation type (e.g. 'ai.embed' or 'ai.embedMany'). */
+  readonly operationId: string;
+  /** The provider identifier (e.g., 'openai', 'anthropic'). */
+  readonly provider: string;
+  /** The specific model identifier (e.g., 'text-embedding-3-small'). */
+  readonly modelId: string;
+  /** The value(s) being embedded. A string for embed, an array for embedMany. */
+  readonly value: string | Array<string>;
+  /** Maximum number of retries for failed requests. */
+  readonly maxRetries: number;
+  /** Additional HTTP headers sent with the request. */
+  readonly headers: Record<string, string | undefined> | undefined;
+  /** Additional provider-specific options. */
   readonly providerOptions: ProviderOptions | undefined;
 };
 /**
@@ -13273,15 +14286,25 @@ type EmbedStartEvent = {
  * Called when the operation completes, after the embedding model returns.
  */
 type EmbedEndEvent = {
-  /** Unique identifier for this embed call, used to correlate events. */readonly callId: string; /** Identifies the operation type (e.g. 'ai.embed' or 'ai.embedMany'). */
-  readonly operationId: string; /** The provider identifier (e.g., 'openai', 'anthropic'). */
-  readonly provider: string; /** The specific model identifier (e.g., 'text-embedding-3-small'). */
-  readonly modelId: string; /** The value(s) that were embedded. A string for embed, an array for embedMany. */
-  readonly value: string | Array<string>; /** The resulting embedding(s). A single vector for embed, an array for embedMany. */
-  readonly embedding: Embedding | Array<Embedding>; /** Token usage for the embedding operation. */
-  readonly usage: EmbeddingModelUsage; /** Warnings from the embedding model, e.g. unsupported settings. */
-  readonly warnings: Array<Warning>; /** Optional provider-specific metadata. */
-  readonly providerMetadata: ProviderMetadata | undefined; /** Response data including headers and body. A single response for embed, an array for embedMany. */
+  /** Unique identifier for this embed call, used to correlate events. */
+  readonly callId: string;
+  /** Identifies the operation type (e.g. 'ai.embed' or 'ai.embedMany'). */
+  readonly operationId: string;
+  /** The provider identifier (e.g., 'openai', 'anthropic'). */
+  readonly provider: string;
+  /** The specific model identifier (e.g., 'text-embedding-3-small'). */
+  readonly modelId: string;
+  /** The value(s) that were embedded. A string for embed, an array for embedMany. */
+  readonly value: string | Array<string>;
+  /** The resulting embedding(s). A single vector for embed, an array for embedMany. */
+  readonly embedding: Embedding | Array<Embedding>;
+  /** Token usage for the embedding operation. */
+  readonly usage: EmbeddingModelUsage;
+  /** Warnings from the embedding model, e.g. unsupported settings. */
+  readonly warnings: Array<Warning>;
+  /** Optional provider-specific metadata. */
+  readonly providerMetadata: ProviderMetadata | undefined;
+  /** Response data including headers and body. A single response for embed, an array for embedMany. */
   readonly response: {
     headers?: Record<string, string>;
     body?: unknown;
@@ -13297,11 +14320,17 @@ type EmbedEndEvent = {
  * calls when values are chunked.
  */
 type EmbeddingModelCallStartEvent = {
-  /** Unique identifier for this embed call, used to correlate events. */readonly callId: string; /** Unique identifier for this individual doEmbed invocation, used to correlate start/finish within parallel chunks. */
-  readonly embedCallId: string; /** Identifies the inner operation (e.g. 'ai.embed.doEmbed' or 'ai.embedMany.doEmbed'). */
-  readonly operationId: string; /** The provider identifier. */
-  readonly provider: string; /** The specific model identifier. */
-  readonly modelId: string; /** The values being embedded in this particular model call. */
+  /** Unique identifier for this embed call, used to correlate events. */
+  readonly callId: string;
+  /** Unique identifier for this individual doEmbed invocation, used to correlate start/finish within parallel chunks. */
+  readonly embedCallId: string;
+  /** Identifies the inner operation (e.g. 'ai.embed.doEmbed' or 'ai.embedMany.doEmbed'). */
+  readonly operationId: string;
+  /** The provider identifier. */
+  readonly provider: string;
+  /** The specific model identifier. */
+  readonly modelId: string;
+  /** The values being embedded in this particular model call. */
   readonly values: Array<string>;
 };
 /**
@@ -13310,13 +14339,21 @@ type EmbeddingModelCallStartEvent = {
  * Contains the embeddings, usage, and any warnings from the model response.
  */
 type EmbeddingModelCallEndEvent = {
-  /** Unique identifier for this embed call, used to correlate events. */readonly callId: string; /** Unique identifier for this individual doEmbed invocation, used to correlate start/finish within parallel chunks. */
-  readonly embedCallId: string; /** Identifies the inner operation (e.g. 'ai.embed.doEmbed' or 'ai.embedMany.doEmbed'). */
-  readonly operationId: string; /** The provider identifier. */
-  readonly provider: string; /** The specific model identifier. */
-  readonly modelId: string; /** The values that were embedded in this particular model call. */
-  readonly values: Array<string>; /** The resulting embeddings from the model call. */
-  readonly embeddings: Array<Embedding>; /** Token usage for this model call. */
+  /** Unique identifier for this embed call, used to correlate events. */
+  readonly callId: string;
+  /** Unique identifier for this individual doEmbed invocation, used to correlate start/finish within parallel chunks. */
+  readonly embedCallId: string;
+  /** Identifies the inner operation (e.g. 'ai.embed.doEmbed' or 'ai.embedMany.doEmbed'). */
+  readonly operationId: string;
+  /** The provider identifier. */
+  readonly provider: string;
+  /** The specific model identifier. */
+  readonly modelId: string;
+  /** The values that were embedded in this particular model call. */
+  readonly values: Array<string>;
+  /** The resulting embeddings from the model call. */
+  readonly embeddings: Array<Embedding>;
+  /** Token usage for this model call. */
   readonly usage: EmbeddingModelUsage;
 };
 /**
@@ -13718,9 +14755,9 @@ type PartialMap<KeyType, ValueType> = {} & Map<DeepPartialInternal<KeyType>, Dee
 type PartialSet<T> = {} & Set<DeepPartialInternal<T>>;
 type PartialReadonlyMap<KeyType, ValueType> = {} & ReadonlyMap<DeepPartialInternal<KeyType>, DeepPartialInternal<ValueType>>;
 type PartialReadonlySet<T> = {} & ReadonlySet<DeepPartialInternal<T>>;
-type PartialObject<ObjectType extends object> = { [KeyType in keyof ObjectType]?: DeepPartialInternal<ObjectType[KeyType]> };
-type IncludedContext<CONTEXT extends Context$1 | unknown | never> = { [KEY in keyof NoInfer<CONTEXT>]?: boolean } | undefined;
-type IncludedToolsContext<TOOLS extends ToolSet> = { [TOOL_NAME in keyof NoInfer<InferToolSetContext<TOOLS>>]?: IncludedContext<NoInfer<InferToolSetContext<TOOLS>[TOOL_NAME]>> } | undefined;
+type PartialObject<ObjectType extends object> = { [KeyType in keyof ObjectType]?: DeepPartialInternal<ObjectType[KeyType]>; };
+type IncludedContext<CONTEXT extends Context$1 | unknown | never> = { [KEY in keyof NoInfer<CONTEXT>]?: boolean; } | undefined;
+type IncludedToolsContext<TOOLS extends ToolSet> = { [TOOL_NAME in keyof NoInfer<InferToolSetContext<TOOLS>>]?: IncludedContext<NoInfer<InferToolSetContext<TOOLS>[TOOL_NAME]>>; } | undefined;
 /**
  * Telemetry configuration.
  */
@@ -13819,10 +14856,7 @@ declare class DefaultGeneratedFile implements GeneratedFile {
   private base64Data;
   private uint8ArrayData;
   readonly mediaType: string;
-  constructor({
-    data,
-    mediaType
-  }: {
+  constructor({ data, mediaType }: {
     data: string | Uint8Array;
     mediaType: string;
   });
@@ -13921,7 +14955,7 @@ type StaticToolCall<TOOLS extends ToolSet> = ValueOf<{ [NAME in keyof TOOLS]: Ba
   invalid?: false | undefined;
   error?: never;
   title?: string;
-} }>;
+}; }>;
 /**
  * A tool call whose `toolName` is only known at runtime, such as an invalid
  * or otherwise untyped call that cannot be matched to the declared tool set.
@@ -14010,7 +15044,7 @@ type StaticToolError<TOOLS extends ToolSet> = ValueOf<{ [NAME in keyof TOOLS]: {
   toolMetadata?: JSONObject$2;
   dynamic?: false | undefined;
   title?: string;
-} }>;
+}; }>;
 type DynamicToolError = {
   type: 'tool-error';
   toolCallId: string;
@@ -14036,7 +15070,7 @@ type StaticToolResult<TOOLS extends ToolSet> = ValueOf<{ [NAME in keyof TOOLS]:
   dynamic?: false | undefined;
   preliminary?: boolean;
   title?: string;
-} }>;
+}; }>;
 type DynamicToolResult = {
   type: 'tool-result';
   toolCallId: string;
@@ -14082,11 +15116,17 @@ type ContentPart<TOOLS extends ToolSet> = {
  * Timing statistics for the gaps between generated output chunks.
  */
 type OutputChunkTimingStats = {
-  /** Shortest observed time between output chunks in milliseconds. */readonly min: number; /** 10th percentile time between output chunks in milliseconds. */
-  readonly p10: number; /** Median time between output chunks in milliseconds. */
-  readonly median: number; /** Average time between output chunks in milliseconds. */
-  readonly avg: number; /** 90th percentile time between output chunks in milliseconds. */
-  readonly p90: number; /** Longest observed time between output chunks in milliseconds. */
+  /** Shortest observed time between output chunks in milliseconds. */
+  readonly min: number;
+  /** 10th percentile time between output chunks in milliseconds. */
+  readonly p10: number;
+  /** Median time between output chunks in milliseconds. */
+  readonly median: number;
+  /** Average time between output chunks in milliseconds. */
+  readonly avg: number;
+  /** 90th percentile time between output chunks in milliseconds. */
+  readonly p90: number;
+  /** Longest observed time between output chunks in milliseconds. */
   readonly max: number;
 };
 /**
@@ -14172,7 +15212,9 @@ type StepResult<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context$1 = Conte
    * Information about the model that produced this step.
    */
   readonly model: {
-    /** The provider of the model. */readonly provider: string; /** The ID of the model. */
+    /** The provider of the model. */
+    readonly provider: string;
+    /** The ID of the model. */
     readonly modelId: string;
   };
   /**
@@ -14274,7 +15316,9 @@ type StepResult<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context$1 = Conte
  * Common model information used across callback events.
  */
 type ModelInfo = {
-  /** The provider identifier (e.g., 'openai', 'anthropic'). */readonly provider: string; /** The specific model identifier (e.g., 'gpt-4o'). */
+  /** The provider identifier (e.g., 'openai', 'anthropic'). */
+  readonly provider: string;
+  /** The specific model identifier (e.g., 'gpt-4o'). */
   readonly modelId: string;
 };
 /**
@@ -14284,7 +15328,9 @@ type ModelInfo = {
  * Unlike `onStepStart`, this only represents model invocation work.
  */
 type LanguageModelCallStartEvent = ModelInfo & {
-  /** Unique identifier for this generation call, used to correlate events. */readonly callId: string; /** Prepared tool definitions for the model call, if any. */
+  /** Unique identifier for this generation call, used to correlate events. */
+  readonly callId: string;
+  /** Prepared tool definitions for the model call, if any. */
   readonly tools: ReadonlyArray<Record<string, unknown>> | undefined;
 } & StandardizedPrompt & LanguageModelCallOptions;
 /**
@@ -14294,14 +15340,22 @@ type LanguageModelCallStartEvent = ModelInfo & {
  * any client-side tool execution begins.
  */
 type LanguageModelCallEndEvent<TOOLS extends ToolSet = ToolSet> = ModelInfo & {
-  /** Unique identifier for this generation call, used to correlate events. */readonly callId: string; /** The unified reason why the model call finished. */
-  readonly finishReason: FinishReason; /** The token usage reported by the model call. */
-  readonly usage: LanguageModelUsage; /** The content parts produced by the model call. */
-  readonly content: ReadonlyArray<ContentPart<TOOLS>>; /** The provider-returned response id for this model call. */
-  readonly responseId: string; /** Optional provider-specific metadata for this model call. */
-  readonly providerMetadata?: ProviderMetadata; /** Performance metrics for the model call. */
+  /** Unique identifier for this generation call, used to correlate events. */
+  readonly callId: string;
+  /** The unified reason why the model call finished. */
+  readonly finishReason: FinishReason;
+  /** The token usage reported by the model call. */
+  readonly usage: LanguageModelUsage;
+  /** The content parts produced by the model call. */
+  readonly content: ReadonlyArray<ContentPart<TOOLS>>;
+  /** The provider-returned response id for this model call. */
+  readonly responseId: string;
+  /** Optional provider-specific metadata for this model call. */
+  readonly providerMetadata?: ProviderMetadata;
+  /** Performance metrics for the model call. */
   readonly performance: {
-    /** Time spent waiting for the language model response in milliseconds. */readonly responseTimeMs: number;
+    /** Time spent waiting for the language model response in milliseconds. */
+    readonly responseTimeMs: number;
     /**
      * Effective number of output tokens per second over the full language
      * model response.
@@ -14556,7 +15610,7 @@ type InferUITool<TOOL extends Tool> = {
 /**
  * Infer the input and output types of a tool set so it can be used as a UI tool set.
  */
-type InferUITools<TOOLS extends ToolSet> = { [NAME in keyof TOOLS & string]: InferUITool<TOOLS[NAME]> };
+type InferUITools<TOOLS extends ToolSet> = { [NAME in keyof TOOLS & string]: InferUITool<TOOLS[NAME]>; };
 type UITools = Record<string, UITool>;
 /**
  * AI SDK UI Messages. They are used in the client and to communicate between the frontend and the API routes.
@@ -14731,7 +15785,7 @@ type DataUIPart<DATA_TYPES extends UIDataTypes> = ValueOf<{ [NAME in keyof DATA_
   type: `data-${NAME}`;
   id?: string;
   data: DATA_TYPES[NAME];
-} }>;
+}; }>;
 type asUITool<TOOL extends UITool | Tool> = TOOL extends Tool ? InferUITool<TOOL> : TOOL;
 /**
  * Check if a message part is a data part.
@@ -14839,7 +15893,7 @@ type UIToolInvocation<TOOL extends UITool | Tool> = {
 });
 type ToolUIPart<TOOLS extends UITools = UITools> = ValueOf<{ [NAME in keyof TOOLS & string]: {
   type: `tool-${NAME}`;
-} & UIToolInvocation<TOOLS[NAME]> }>;
+} & UIToolInvocation<TOOLS[NAME]>; }>;
 type DynamicToolUIPart = {
   type: 'dynamic-tool';
   /**
@@ -15003,7 +16057,7 @@ type InferUIMessageToolCall<UI_MESSAGE extends UIMessage> = ValueOf<{ [NAME in k
   input: infer INPUT;
 } ? INPUT : never> & {
   dynamic?: false;
-} }> | (ToolCall<string, unknown> & {
+}; }> | (ToolCall<string, unknown> & {
   dynamic: true;
 });
 declare const uiMessageChunkSchema: LazySchema<UIMessageChunk<unknown, UIDataTypes>>;
@@ -15012,7 +16066,7 @@ type DataUIMessageChunk<DATA_TYPES extends UIDataTypes> = ValueOf<{ [NAME in key
   id?: string;
   data: DATA_TYPES[NAME];
   transient?: boolean;
-} }>;
+}; }>;
 type UIMessageChunk<METADATA = unknown, DATA_TYPES extends UIDataTypes = UIDataTypes> = {
   type: 'text-start';
   id: string;
@@ -15221,7 +16275,7 @@ type StaticToolOutputDenied<TOOLS extends ToolSet> = ValueOf<{ [NAME in keyof TO
   toolName: NAME & string;
   providerExecuted?: boolean;
   dynamic?: false | undefined;
-} }>;
+}; }>;
 /**
  * Tool output when the tool execution has been denied.
  */
@@ -15748,20 +16802,15 @@ type GenericToolApprovalFunction<TOOLS extends ToolSet, TOOLS_CONTEXT extends In
  *
  * In addition to the string statuses, you can also use object statuses with a reason property.
  */
-type ToolApprovalConfiguration<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context$1 | unknown | never> = GenericToolApprovalFunction<TOOLS, InferToolSetContext<TOOLS>, RUNTIME_CONTEXT> | { [key in keyof TOOLS]?: ToolApprovalStatus | SingleToolApprovalFunction<InferToolInput<TOOLS[key]>, InferToolContext<TOOLS[key]>, RUNTIME_CONTEXT> };
-type ToolCallerName<TOOLS extends ToolSet> = { [NAME in keyof TOOLS]: TOOLS[NAME] extends ToolCallerTool ? NAME : never }[keyof TOOLS] & string;
-type Experimental_ToolCallers<TOOLS extends ToolSet> = { [NAME in keyof TOOLS]?: ReadonlyArray<'AI_SDK_DIRECT_TOOL_CALL' | ToolCallerName<TOOLS>> };
+type ToolApprovalConfiguration<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context$1 | unknown | never> = GenericToolApprovalFunction<TOOLS, InferToolSetContext<TOOLS>, RUNTIME_CONTEXT> | { [key in keyof TOOLS]?: ToolApprovalStatus | SingleToolApprovalFunction<InferToolInput<TOOLS[key]>, InferToolContext<TOOLS[key]>, RUNTIME_CONTEXT>; };
+type ToolCallerName<TOOLS extends ToolSet> = { [NAME in keyof TOOLS]: TOOLS[NAME] extends ToolCallerTool ? NAME : never; }[keyof TOOLS] & string;
+type Experimental_ToolCallers<TOOLS extends ToolSet> = { [NAME in keyof TOOLS]?: ReadonlyArray<'AI_SDK_DIRECT_TOOL_CALL' | ToolCallerName<TOOLS>>; };
 declare const symbol$l: unique symbol;
 declare class InvalidToolInputError extends AISDKError {
   private readonly [symbol$l];
   readonly toolName: string;
   readonly toolInput: string;
-  constructor({
-    toolInput,
-    toolName,
-    cause,
-    message
-  }: {
+  constructor({ toolInput, toolName, cause, message }: {
     message?: string;
     toolInput: string;
     toolName: string;
@@ -15774,11 +16823,7 @@ declare class NoSuchToolError extends AISDKError {
   private readonly [symbol$k];
   readonly toolName: string;
   readonly availableTools: string[] | undefined;
-  constructor({
-    toolName,
-    availableTools,
-    message
-  }: {
+  constructor({ toolName, availableTools, message }: {
     toolName: string;
     availableTools?: string[] | undefined;
     message?: string;
@@ -15820,7 +16865,8 @@ type ToolOutput<TOOLS extends ToolSet> = TypedToolResult<TOOLS> | TypedToolError
  */
 type ToolContextFor<TOOL extends ToolSet[keyof ToolSet]> = [InferToolContext<TOOL>] extends [never] ? undefined : InferToolContext<TOOL>;
 type BaseToolExecutionStartFields = {
-  /** Unique identifier for this generation call, used to correlate events. */readonly callId: string;
+  /** Unique identifier for this generation call, used to correlate events. */
+  readonly callId: string;
   /**
    * Messages that were sent to the language model to initiate the response that contained the tool call.
    * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
@@ -15838,7 +16884,7 @@ type StaticToolExecutionStartEvent<TOOLS extends ToolSet> = ValueOf<{ [NAME in k
     toolName: NAME;
   }>;
   readonly toolContext: ToolContextFor<TOOLS[NAME]>;
-} }>;
+}; }>;
 /**
  * Start event shape for dynamic or untyped tool calls.
  */
@@ -15863,7 +16909,9 @@ type WidenedToolExecutionStartEvent = BaseToolExecutionStartFields & {
  */
 type ToolExecutionStartEvent<TOOLS extends ToolSet = ToolSet> = [ToolSet] extends [TOOLS] ? WidenedToolExecutionStartEvent : StaticToolExecutionStartEvent<TOOLS> | DynamicToolExecutionStartEvent;
 type BaseToolExecutionEndFields = {
-  /** Unique identifier for this generation call, used to correlate events. */readonly callId: string; /** Execution time of the tool call in milliseconds. */
+  /** Unique identifier for this generation call, used to correlate events. */
+  readonly callId: string;
+  /** Execution time of the tool call in milliseconds. */
   readonly toolExecutionMs: number;
   /**
    * Messages that were sent to the language model to initiate the response that contained the tool call.
@@ -15883,7 +16931,7 @@ type StaticToolExecutionEndEvent<TOOLS extends ToolSet> = ValueOf<{ [NAME in key
   }>;
   readonly toolContext: ToolContextFor<TOOLS[NAME]>;
   readonly toolOutput: ToolOutput<TOOLS>;
-} }>;
+}; }>;
 /**
  * End event shape for dynamic or untyped tool calls.
  */
@@ -15943,7 +16991,7 @@ type OnToolCallFinishEvent<TOOLS extends ToolSet = ToolSet> = ToolExecutionEndEv
  * an input with the same type shape. Refined inputs are used for tool execution,
  * output parts, lifecycle callbacks, and telemetry.
  */
-type ToolInputRefinement<TOOLS extends ToolSet> = { [NAME in keyof TOOLS]?: (input: InferToolInput<TOOLS[NAME]>) => MaybePromiseLike<InferToolInput<TOOLS[NAME]>> };
+type ToolInputRefinement<TOOLS extends ToolSet> = { [NAME in keyof TOOLS]?: (input: InferToolInput<TOOLS[NAME]>) => MaybePromiseLike<InferToolInput<TOOLS[NAME]>>; };
 /**
  * Checks whether a tool context map contains any contextual tool entries.
  */
@@ -16092,67 +17140,7 @@ type StreamTextOnAbortCallback<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Co
  * @returns
  * A result object for accessing different stream types and additional information.
  */
-declare function streamText<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context$1 = Context$1, OUTPUT extends Output = Output<string, string, never>>({
-  model,
-  tools,
-  toolChoice,
-  instructions,
-  system,
-  prompt,
-  messages,
-  allowSystemInMessages,
-  maxRetries,
-  abortSignal,
-  timeout,
-  headers,
-  stopWhen,
-  experimental_sandbox: sandbox,
-  output,
-  toolApproval,
-  experimental_toolCallers,
-  experimental_toolApprovalSecret,
-  experimental_telemetry,
-  telemetry,
-  prepareStep,
-  providerOptions,
-  activeTools,
-  toolOrder,
-  experimental_repairToolCall,
-  repairToolCall,
-  experimental_refineToolInput: refineToolInput,
-  experimental_transform: transform,
-  experimental_download: download,
-  includeRawChunks,
-  onChunk,
-  onError,
-  onFinish,
-  onEnd,
-  onAbort,
-  onStepEnd,
-  onStepFinish,
-  onStart,
-  experimental_onStart,
-  onStepStart,
-  experimental_onStepStart,
-  onLanguageModelCallStart,
-  experimental_onLanguageModelCallStart,
-  onLanguageModelCallEnd,
-  experimental_onLanguageModelCallEnd,
-  onToolExecutionStart,
-  onToolExecutionEnd,
-  experimental_onToolCallStart,
-  experimental_onToolCallFinish,
-  runtimeContext,
-  toolsContext,
-  experimental_include,
-  include,
-  _internal: {
-    now,
-    generateId,
-    generateCallId
-  },
-  ...settings
-}: LanguageModelCallOptions & RequestOptions<TOOLS> & Prompt & ToolsContextParameter<TOOLS> & {
+declare function streamText<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context$1 = Context$1, OUTPUT extends Output = Output<string, string, never>>({ model, tools, toolChoice, instructions, system, prompt, messages, allowSystemInMessages, maxRetries, abortSignal, timeout, headers, stopWhen, experimental_sandbox: sandbox, output, toolApproval, experimental_toolCallers, experimental_toolApprovalSecret, experimental_telemetry, telemetry, prepareStep, providerOptions, activeTools, toolOrder, experimental_repairToolCall, repairToolCall, experimental_refineToolInput: refineToolInput, experimental_transform: transform, experimental_download: download, includeRawChunks, onChunk, onError, onFinish, onEnd, onAbort, onStepEnd, onStepFinish, onStart, experimental_onStart, onStepStart, experimental_onStepStart, onLanguageModelCallStart, experimental_onLanguageModelCallStart, onLanguageModelCallEnd, experimental_onLanguageModelCallEnd, onToolExecutionStart, onToolExecutionEnd, experimental_onToolCallStart, experimental_onToolCallFinish, runtimeContext, toolsContext, experimental_include, include, _internal: { now, generateId, generateCallId }, ...settings }: LanguageModelCallOptions & RequestOptions<TOOLS> & Prompt & ToolsContextParameter<TOOLS> & {
   /**
    * The language model to use.
    */
@@ -16456,11 +17444,7 @@ declare const text$1: () => Output<string, string, never>;
  *
  * @returns An output specification for generating objects with the specified schema.
  */
-declare const object: <OBJECT>({
-  schema: inputSchema,
-  name,
-  description
-}: {
+declare const object: <OBJECT>({ schema: inputSchema, name, description }: {
   schema: FlexibleSchema<OBJECT>;
   /**
    * Optional name of the output that should be generated.
@@ -16483,11 +17467,7 @@ declare const object: <OBJECT>({
  *
  * @returns An output specification for generating an array of elements.
  */
-declare const array: <ELEMENT>({
-  element: inputElementSchema,
-  name,
-  description
-}: {
+declare const array: <ELEMENT>({ element: inputElementSchema, name, description }: {
   element: FlexibleSchema<ELEMENT>;
   /**
    * Optional name of the output that should be generated.
@@ -16510,11 +17490,7 @@ declare const array: <ELEMENT>({
  *
  * @returns An output specification for generating a choice.
  */
-declare const choice: <CHOICE extends string>({
-  options: choiceOptions,
-  name,
-  description
-}: {
+declare const choice: <CHOICE extends string>({ options: choiceOptions, name, description }: {
   options: Array<CHOICE>;
   /**
    * Optional name of the output that should be generated.
@@ -16536,10 +17512,7 @@ declare const choice: <CHOICE extends string>({
  *
  * @returns An output specification for generating JSON.
  */
-declare const json: ({
-  name,
-  description
-}?: {
+declare const json: ({ name, description }?: {
   /**
    * Optional name of the output that should be generated.
    * Used by some providers for additional LLM guidance, e.g. via tool or schema name.
@@ -16566,23 +17539,35 @@ declare namespace output {
  * Called when the generation operation begins, before any LLM calls.
  */
 type GenerateTextStartEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context$1 = Context$1, OUTPUT extends Output = Output> = {
-  /** Unique identifier for this generation call, used to correlate events. */readonly callId: string; /** Identifies the operation type (e.g. 'ai.generateText' or 'ai.streamText'). */
-  readonly operationId: string; /** The provider identifier (e.g., 'openai', 'anthropic'). */
-  readonly provider: string; /** The specific model identifier (e.g., 'gpt-4o'). */
-  readonly modelId: string; /** The tools available for this generation. */
-  readonly tools: TOOLS | undefined; /** The tool choice strategy for this generation. */
-  readonly toolChoice: ToolChoice<NoInfer<TOOLS>> | undefined; /** Limits which tools are available for the model to call. */
-  readonly activeTools: ActiveTools<TOOLS>; /** Controls the order in which tools are sent to the provider. */
-  readonly toolOrder: ToolOrder<TOOLS>; /** Maximum number of retries for failed requests. */
+  /** Unique identifier for this generation call, used to correlate events. */
+  readonly callId: string;
+  /** Identifies the operation type (e.g. 'ai.generateText' or 'ai.streamText'). */
+  readonly operationId: string;
+  /** The provider identifier (e.g., 'openai', 'anthropic'). */
+  readonly provider: string;
+  /** The specific model identifier (e.g., 'gpt-4o'). */
+  readonly modelId: string;
+  /** The tools available for this generation. */
+  readonly tools: TOOLS | undefined;
+  /** The tool choice strategy for this generation. */
+  readonly toolChoice: ToolChoice<NoInfer<TOOLS>> | undefined;
+  /** Limits which tools are available for the model to call. */
+  readonly activeTools: ActiveTools<TOOLS>;
+  /** Controls the order in which tools are sent to the provider. */
+  readonly toolOrder: ToolOrder<TOOLS>;
+  /** Maximum number of retries for failed requests. */
   readonly maxRetries: number;
   /**
    * Timeout configuration for the generation.
    * Can be a number (milliseconds) or an object with totalMs, stepMs,
    * firstChunkMs (streaming only), chunkMs, toolMs, and per-tool overrides via tools.
    */
-  readonly timeout: TimeoutConfiguration<TOOLS> | undefined; /** Additional HTTP headers sent with the request. */
-  readonly headers: Record<string, string | undefined> | undefined; /** Additional provider-specific options. */
-  readonly providerOptions: ProviderOptions | undefined; /** The output specification for structured outputs, if configured. */
+  readonly timeout: TimeoutConfiguration<TOOLS> | undefined;
+  /** Additional HTTP headers sent with the request. */
+  readonly headers: Record<string, string | undefined> | undefined;
+  /** Additional provider-specific options. */
+  readonly providerOptions: ProviderOptions | undefined;
+  /** The output specification for structured outputs, if configured. */
   readonly output: OUTPUT | undefined;
   /**
    * Tool context.
@@ -16600,16 +17585,27 @@ type GenerateTextStartEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT ext
  * Each step represents a single LLM invocation.
  */
 type GenerateTextStepStartEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context$1 = Context$1, OUTPUT extends Output = Output> = {
-  /** Unique identifier for this generation call, used to correlate events. */readonly callId: string; /** The provider identifier (e.g., 'openai', 'anthropic'). */
-  readonly provider: string; /** The specific model identifier (e.g., 'gpt-4o'). */
-  readonly modelId: string; /** Zero-based index of the current step. */
-  readonly stepNumber: number; /** The tools available for this generation. */
-  readonly tools: TOOLS | undefined; /** The tool choice configuration for this step. */
-  readonly toolChoice: ToolChoice<NoInfer<TOOLS>> | undefined; /** Limits which tools are available for this step. */
-  readonly activeTools: ActiveTools<TOOLS>; /** Controls the order in which tools are sent to the provider for this step. */
-  readonly toolOrder: ToolOrder<TOOLS>; /** Array of results from previous steps (empty for first step). */
-  readonly steps: ReadonlyArray<StepResult<TOOLS, RUNTIME_CONTEXT>>; /** Additional provider-specific options for this step. */
-  readonly providerOptions: ProviderOptions | undefined; /** The output specification for structured outputs, if configured. */
+  /** Unique identifier for this generation call, used to correlate events. */
+  readonly callId: string;
+  /** The provider identifier (e.g., 'openai', 'anthropic'). */
+  readonly provider: string;
+  /** The specific model identifier (e.g., 'gpt-4o'). */
+  readonly modelId: string;
+  /** Zero-based index of the current step. */
+  readonly stepNumber: number;
+  /** The tools available for this generation. */
+  readonly tools: TOOLS | undefined;
+  /** The tool choice configuration for this step. */
+  readonly toolChoice: ToolChoice<NoInfer<TOOLS>> | undefined;
+  /** Limits which tools are available for this step. */
+  readonly activeTools: ActiveTools<TOOLS>;
+  /** Controls the order in which tools are sent to the provider for this step. */
+  readonly toolOrder: ToolOrder<TOOLS>;
+  /** Array of results from previous steps (empty for first step). */
+  readonly steps: ReadonlyArray<StepResult<TOOLS, RUNTIME_CONTEXT>>;
+  /** Additional provider-specific options for this step. */
+  readonly providerOptions: ProviderOptions | undefined;
+  /** The output specification for structured outputs, if configured. */
   readonly output: OUTPUT | undefined;
   /**
    * Runtime context. May be updated from `prepareStep` between steps.
@@ -16634,8 +17630,11 @@ type GenerateTextStepEndEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT e
  * Includes the final step's result along with aggregated data from all steps.
  */
 type GenerateTextEndEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context$1 = Context$1> = {
-  /** Unique identifier for this generation call, used to correlate events. */readonly callId: string; /** Zero-based index of the final step. */
-  readonly stepNumber: number; /** Information about the model that produced the final step. */
+  /** Unique identifier for this generation call, used to correlate events. */
+  readonly callId: string;
+  /** Zero-based index of the final step. */
+  readonly stepNumber: number;
+  /** Information about the model that produced the final step. */
   readonly model: StepResult<TOOLS, RUNTIME_CONTEXT>['model'];
   /**
    * Tool context from the final step.
@@ -16648,8 +17647,10 @@ type GenerateTextEndEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT exten
    *
    * @deprecated Use `finalStep.runtimeContext` instead.
    */
-  readonly runtimeContext: RUNTIME_CONTEXT; /** The content that was generated in all steps. */
-  readonly content: StepResult<TOOLS, RUNTIME_CONTEXT>['content']; /** The text that was generated in the final step. */
+  readonly runtimeContext: RUNTIME_CONTEXT;
+  /** The content that was generated in all steps. */
+  readonly content: StepResult<TOOLS, RUNTIME_CONTEXT>['content'];
+  /** The text that was generated in the final step. */
   readonly text: StepResult<TOOLS, RUNTIME_CONTEXT>['text'];
   /**
    * The reasoning that was generated in the final step.
@@ -16662,24 +17663,36 @@ type GenerateTextEndEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT exten
    *
    * @deprecated Use `finalStep.reasoningText` instead.
    */
-  readonly reasoningText: StepResult<TOOLS, RUNTIME_CONTEXT>['reasoningText']; /** Files that were generated in all steps. */
-  readonly files: StepResult<TOOLS, RUNTIME_CONTEXT>['files']; /** Sources that were used as references in all steps. */
-  readonly sources: StepResult<TOOLS, RUNTIME_CONTEXT>['sources']; /** Tool calls that were made in all steps. */
-  readonly toolCalls: StepResult<TOOLS, RUNTIME_CONTEXT>['toolCalls']; /** Static tool calls that were made in all steps. */
-  readonly staticToolCalls: StepResult<TOOLS, RUNTIME_CONTEXT>['staticToolCalls']; /** Dynamic tool calls that were made in all steps. */
-  readonly dynamicToolCalls: StepResult<TOOLS, RUNTIME_CONTEXT>['dynamicToolCalls']; /** Tool results that were generated in all steps. */
-  readonly toolResults: StepResult<TOOLS, RUNTIME_CONTEXT>['toolResults']; /** Static tool results that were generated in all steps. */
-  readonly staticToolResults: StepResult<TOOLS, RUNTIME_CONTEXT>['staticToolResults']; /** Dynamic tool results that were generated in all steps. */
-  readonly dynamicToolResults: StepResult<TOOLS, RUNTIME_CONTEXT>['dynamicToolResults']; /** The unified reason why the generation finished. Taken from the final step. */
-  readonly finishReason: StepResult<TOOLS, RUNTIME_CONTEXT>['finishReason']; /** The raw reason why the generation finished. Taken from the final step. */
-  readonly rawFinishReason: StepResult<TOOLS, RUNTIME_CONTEXT>['rawFinishReason']; /** Aggregated token usage across all steps. */
+  readonly reasoningText: StepResult<TOOLS, RUNTIME_CONTEXT>['reasoningText'];
+  /** Files that were generated in all steps. */
+  readonly files: StepResult<TOOLS, RUNTIME_CONTEXT>['files'];
+  /** Sources that were used as references in all steps. */
+  readonly sources: StepResult<TOOLS, RUNTIME_CONTEXT>['sources'];
+  /** Tool calls that were made in all steps. */
+  readonly toolCalls: StepResult<TOOLS, RUNTIME_CONTEXT>['toolCalls'];
+  /** Static tool calls that were made in all steps. */
+  readonly staticToolCalls: StepResult<TOOLS, RUNTIME_CONTEXT>['staticToolCalls'];
+  /** Dynamic tool calls that were made in all steps. */
+  readonly dynamicToolCalls: StepResult<TOOLS, RUNTIME_CONTEXT>['dynamicToolCalls'];
+  /** Tool results that were generated in all steps. */
+  readonly toolResults: StepResult<TOOLS, RUNTIME_CONTEXT>['toolResults'];
+  /** Static tool results that were generated in all steps. */
+  readonly staticToolResults: StepResult<TOOLS, RUNTIME_CONTEXT>['staticToolResults'];
+  /** Dynamic tool results that were generated in all steps. */
+  readonly dynamicToolResults: StepResult<TOOLS, RUNTIME_CONTEXT>['dynamicToolResults'];
+  /** The unified reason why the generation finished. Taken from the final step. */
+  readonly finishReason: StepResult<TOOLS, RUNTIME_CONTEXT>['finishReason'];
+  /** The raw reason why the generation finished. Taken from the final step. */
+  readonly rawFinishReason: StepResult<TOOLS, RUNTIME_CONTEXT>['rawFinishReason'];
+  /** Aggregated token usage across all steps. */
   readonly usage: LanguageModelUsage;
   /**
    * Aggregated token usage across all steps.
    *
    * @deprecated Use `usage` instead.
    */
-  readonly totalUsage: LanguageModelUsage; /** Warnings from the model provider in all steps. */
+  readonly totalUsage: LanguageModelUsage;
+  /** Warnings from the model provider in all steps. */
   readonly warnings: StepResult<TOOLS, RUNTIME_CONTEXT>['warnings'];
   /**
    * Additional request information from the final step.
@@ -16698,9 +17711,12 @@ type GenerateTextEndEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT exten
    *
    * @deprecated Use `finalStep.providerMetadata` instead.
    */
-  readonly providerMetadata: StepResult<TOOLS, RUNTIME_CONTEXT>['providerMetadata']; /** The response messages that were generated during the call. */
-  readonly responseMessages: ResponseMessage[]; /** Array containing results from all steps in the generation. */
-  readonly steps: StepResult<TOOLS, RUNTIME_CONTEXT>[]; /** The final step. This is a shortcut for `steps.at(-1)`. */
+  readonly providerMetadata: StepResult<TOOLS, RUNTIME_CONTEXT>['providerMetadata'];
+  /** The response messages that were generated during the call. */
+  readonly responseMessages: ResponseMessage[];
+  /** Array containing results from all steps in the generation. */
+  readonly steps: StepResult<TOOLS, RUNTIME_CONTEXT>[];
+  /** The final step. This is a shortcut for `steps.at(-1)`. */
   readonly finalStep: StepResult<TOOLS, RUNTIME_CONTEXT>;
 };
 /**
@@ -16710,8 +17726,11 @@ type GenerateTextEndEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT exten
  * completes.
  */
 type GenerateTextAbortEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context$1 = Context$1> = {
-  /** Unique identifier for this generation call, used to correlate events. */readonly callId: string; /** Details for all previously finished steps. */
-  readonly steps: StepResult<TOOLS, RUNTIME_CONTEXT>[]; /** The abort reason from the AbortSignal, when one is available. */
+  /** Unique identifier for this generation call, used to correlate events. */
+  readonly callId: string;
+  /** Details for all previously finished steps. */
+  readonly steps: StepResult<TOOLS, RUNTIME_CONTEXT>[];
+  /** The abort reason from the AbortSignal, when one is available. */
   readonly reason?: unknown;
 };
 /** @deprecated Use `GenerateTextStartEvent` instead. */
@@ -16788,15 +17807,24 @@ type GenerateTextOnFinishCallback<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTE
  * Called when the operation begins, before the reranking model is called.
  */
 type RerankStartEvent = {
-  /** Unique identifier for this rerank call, used to correlate events. */readonly callId: string; /** Identifies the operation type ('ai.rerank'). */
+  /** Unique identifier for this rerank call, used to correlate events. */
+  readonly callId: string;
+  /** Identifies the operation type ('ai.rerank'). */
   readonly operationId: string;
-  readonly provider: string; /** The specific model identifier (e.g., 'gpt-4o'). */
-  readonly modelId: string; /** The documents being reranked. */
-  readonly documents: Array<JSONObject$2 | string>; /** The query to rerank the documents against. */
-  readonly query: string; /** Number of top documents to return. */
-  readonly topN: number | undefined; /** Maximum number of retries for failed requests. */
-  readonly maxRetries: number; /** Additional HTTP headers sent with the request. */
-  readonly headers: Record<string, string | undefined> | undefined; /** Additional provider-specific options. */
+  readonly provider: string;
+  /** The specific model identifier (e.g., 'gpt-4o'). */
+  readonly modelId: string;
+  /** The documents being reranked. */
+  readonly documents: Array<JSONObject$2 | string>;
+  /** The query to rerank the documents against. */
+  readonly query: string;
+  /** Number of top documents to return. */
+  readonly topN: number | undefined;
+  /** Maximum number of retries for failed requests. */
+  readonly maxRetries: number;
+  /** Additional HTTP headers sent with the request. */
+  readonly headers: Record<string, string | undefined> | undefined;
+  /** Additional provider-specific options. */
   readonly providerOptions: ProviderOptions | undefined;
 };
 /**
@@ -16805,19 +17833,28 @@ type RerankStartEvent = {
  * Called when the operation completes, after the reranking model returns.
  */
 type RerankEndEvent = {
-  /** Unique identifier for this rerank call, used to correlate events. */readonly callId: string; /** Identifies the operation type ('ai.rerank'). */
+  /** Unique identifier for this rerank call, used to correlate events. */
+  readonly callId: string;
+  /** Identifies the operation type ('ai.rerank'). */
   readonly operationId: string;
-  readonly provider: string; /** The specific model identifier (e.g., 'gpt-4o'). */
-  readonly modelId: string; /** The documents that were reranked. */
-  readonly documents: Array<JSONObject$2 | string>; /** The query that documents were reranked against. */
-  readonly query: string; /** The reranked results sorted by relevance score in descending order. */
+  readonly provider: string;
+  /** The specific model identifier (e.g., 'gpt-4o'). */
+  readonly modelId: string;
+  /** The documents that were reranked. */
+  readonly documents: Array<JSONObject$2 | string>;
+  /** The query that documents were reranked against. */
+  readonly query: string;
+  /** The reranked results sorted by relevance score in descending order. */
   readonly ranking: Array<{
     originalIndex: number;
     score: number;
     document: JSONObject$2 | string;
-  }>; /** Warnings from the reranking model. */
-  readonly warnings: Array<Warning>; /** Optional provider-specific metadata. */
-  readonly providerMetadata: ProviderMetadata | undefined; /** Response data including headers and body. */
+  }>;
+  /** Warnings from the reranking model. */
+  readonly warnings: Array<Warning>;
+  /** Optional provider-specific metadata. */
+  readonly providerMetadata: ProviderMetadata | undefined;
+  /** Response data including headers and body. */
   readonly response: {
     id?: string;
     timestamp: Date;
@@ -16830,13 +17867,21 @@ type RerankEndEvent = {
  * Event fired when an individual reranking model call (inner doRerank) begins.
  */
 type RerankingModelCallStartEvent = {
-  /** Unique identifier for this rerank call, used to correlate events. */readonly callId: string; /** Identifies the inner operation ('ai.rerank.doRerank'). */
-  readonly operationId: string; /** The provider identifier. */
-  readonly provider: string; /** The specific model identifier. */
-  readonly modelId: string; /** The documents being reranked. */
-  readonly documents: Array<JSONObject$2 | string>; /** The type of documents ('text' or 'object'). */
-  readonly documentsType: string; /** The query to rerank against. */
-  readonly query: string; /** Number of top documents to return. */
+  /** Unique identifier for this rerank call, used to correlate events. */
+  readonly callId: string;
+  /** Identifies the inner operation ('ai.rerank.doRerank'). */
+  readonly operationId: string;
+  /** The provider identifier. */
+  readonly provider: string;
+  /** The specific model identifier. */
+  readonly modelId: string;
+  /** The documents being reranked. */
+  readonly documents: Array<JSONObject$2 | string>;
+  /** The type of documents ('text' or 'object'). */
+  readonly documentsType: string;
+  /** The query to rerank against. */
+  readonly query: string;
+  /** Number of top documents to return. */
   readonly topN: number | undefined;
 };
 /**
@@ -16845,11 +17890,17 @@ type RerankingModelCallStartEvent = {
  * Contains the ranking results from the model response.
  */
 type RerankingModelCallEndEvent = {
-  /** Unique identifier for this rerank call, used to correlate events. */readonly callId: string; /** Identifies the inner operation ('ai.rerank.doRerank'). */
-  readonly operationId: string; /** The provider identifier. */
-  readonly provider: string; /** The specific model identifier. */
-  readonly modelId: string; /** The type of documents ('text' or 'object'). */
-  readonly documentsType: string; /** The ranking results from the model. */
+  /** Unique identifier for this rerank call, used to correlate events. */
+  readonly callId: string;
+  /** Identifies the inner operation ('ai.rerank.doRerank'). */
+  readonly operationId: string;
+  /** The provider identifier. */
+  readonly provider: string;
+  /** The specific model identifier. */
+  readonly modelId: string;
+  /** The type of documents ('text' or 'object'). */
+  readonly documentsType: string;
+  /** The ranking results from the model. */
   readonly ranking: Array<{
     index: number;
     relevanceScore: number;
@@ -17404,62 +18455,7 @@ type GenerateTextInclude = {
  * @returns
  * A result object that contains the generated text, the results of the tool calls, and additional information.
  */
-declare function generateText<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context$1 = Context$1, OUTPUT extends Output = Output<string, string>>({
-  model: modelArg,
-  tools,
-  toolChoice,
-  instructions,
-  system,
-  prompt,
-  messages,
-  allowSystemInMessages,
-  maxRetries: maxRetriesArg,
-  abortSignal,
-  timeout,
-  headers,
-  stopWhen,
-  experimental_sandbox: sandbox,
-  output,
-  toolApproval,
-  experimental_toolCallers,
-  experimental_toolApprovalSecret,
-  experimental_telemetry,
-  telemetry,
-  providerOptions,
-  activeTools,
-  toolOrder,
-  prepareStep,
-  experimental_repairToolCall,
-  repairToolCall,
-  experimental_refineToolInput: refineToolInput,
-  experimental_download: download,
-  runtimeContext,
-  toolsContext,
-  experimental_include,
-  include,
-  _internal: {
-    generateId,
-    generateCallId,
-    now
-  },
-  onStart,
-  experimental_onStart,
-  onStepStart,
-  experimental_onStepStart,
-  onLanguageModelCallStart,
-  experimental_onLanguageModelCallStart,
-  onLanguageModelCallEnd,
-  experimental_onLanguageModelCallEnd,
-  onToolExecutionStart,
-  onToolExecutionEnd,
-  experimental_onToolCallStart,
-  experimental_onToolCallFinish,
-  onStepEnd,
-  onStepFinish,
-  onFinish,
-  onEnd,
-  ...settings
-}: LanguageModelCallOptions & RequestOptions<TOOLS> & Prompt & ToolsContextParameter<TOOLS> & {
+declare function generateText<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context$1 = Context$1, OUTPUT extends Output = Output<string, string>>({ model: modelArg, tools, toolChoice, instructions, system, prompt, messages, allowSystemInMessages, maxRetries: maxRetriesArg, abortSignal, timeout, headers, stopWhen, experimental_sandbox: sandbox, output, toolApproval, experimental_toolCallers, experimental_toolApprovalSecret, experimental_telemetry, telemetry, providerOptions, activeTools, toolOrder, prepareStep, experimental_repairToolCall, repairToolCall, experimental_refineToolInput: refineToolInput, experimental_download: download, runtimeContext, toolsContext, experimental_include, include, _internal: { generateId, generateCallId, now }, onStart, experimental_onStart, onStepStart, experimental_onStepStart, onLanguageModelCallStart, experimental_onLanguageModelCallStart, onLanguageModelCallEnd, experimental_onLanguageModelCallEnd, onToolExecutionStart, onToolExecutionEnd, experimental_onToolCallStart, experimental_onToolCallFinish, onStepEnd, onStepFinish, onFinish, onEnd, ...settings }: LanguageModelCallOptions & RequestOptions<TOOLS> & Prompt & ToolsContextParameter<TOOLS> & {
   /**
    * The language model to use.
    */
@@ -17905,42 +18901,11 @@ declare class ToolLoopAgent<CALL_OPTIONS = never, TOOLS extends ToolSet = {}, RU
   /**
    * Generates an output from the agent (non-streaming).
    */
-  generate({
-    abortSignal,
-    timeout,
-    experimental_sandbox: sandbox,
-    onStart,
-    experimental_onStart,
-    onStepStart,
-    experimental_onStepStart,
-    onToolExecutionStart,
-    onToolExecutionEnd,
-    onStepEnd,
-    onStepFinish,
-    onFinish,
-    onEnd,
-    ...options
-  }: AgentCallParameters<CALL_OPTIONS, TOOLS, RUNTIME_CONTEXT>): Promise<GenerateTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>>;
+  generate({ abortSignal, timeout, experimental_sandbox: sandbox, onStart, experimental_onStart, onStepStart, experimental_onStepStart, onToolExecutionStart, onToolExecutionEnd, onStepEnd, onStepFinish, onFinish, onEnd, ...options }: AgentCallParameters<CALL_OPTIONS, TOOLS, RUNTIME_CONTEXT>): Promise<GenerateTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>>;
   /**
    * Streams an output from the agent (streaming).
    */
-  stream({
-    abortSignal,
-    timeout,
-    experimental_sandbox: sandbox,
-    experimental_transform,
-    onStart,
-    experimental_onStart,
-    onStepStart,
-    experimental_onStepStart,
-    onToolExecutionStart,
-    onToolExecutionEnd,
-    onStepEnd,
-    onStepFinish,
-    onFinish,
-    onEnd,
-    ...options
-  }: AgentStreamParameters<CALL_OPTIONS, TOOLS, RUNTIME_CONTEXT>): Promise<StreamTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>>;
+  stream({ abortSignal, timeout, experimental_sandbox: sandbox, experimental_transform, onStart, experimental_onStart, onStepStart, experimental_onStepStart, onToolExecutionStart, onToolExecutionEnd, onStepEnd, onStepFinish, onFinish, onEnd, ...options }: AgentStreamParameters<CALL_OPTIONS, TOOLS, RUNTIME_CONTEXT>): Promise<StreamTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>>;
 }
 /**
  * Infer the type of the tools of an agent.
@@ -17969,13 +18934,7 @@ type InferAgentUIMessage<AGENT, MESSAGE_METADATA = unknown> = UIMessage<MESSAGE_
  *
  * @returns The response object.
  */
-declare function createAgentUIStreamResponse<CALL_OPTIONS = never, TOOLS extends ToolSet = {}, RUNTIME_CONTEXT extends Context$1 = Context$1, OUTPUT extends Output = never, MESSAGE_METADATA = unknown>({
-  headers,
-  status,
-  statusText,
-  consumeSseStream,
-  ...options
-}: {
+declare function createAgentUIStreamResponse<CALL_OPTIONS = never, TOOLS extends ToolSet = {}, RUNTIME_CONTEXT extends Context$1 = Context$1, OUTPUT extends Output = never, MESSAGE_METADATA = unknown>({ headers, status, statusText, consumeSseStream, ...options }: {
   agent: Agent$1<CALL_OPTIONS, TOOLS, RUNTIME_CONTEXT, OUTPUT>;
   uiMessages: unknown[];
   abortSignal?: AbortSignal;
@@ -17983,7 +18942,8 @@ declare function createAgentUIStreamResponse<CALL_OPTIONS = never, TOOLS extends
   experimental_sandbox?: SandboxSession;
   options?: CALL_OPTIONS;
   experimental_transform?: Arrayable<StreamTextTransform<TOOLS>>;
-  onStepEnd?: GenerateTextOnStepEndCallback<TOOLS>; /** @deprecated Use `onStepEnd` instead. */
+  onStepEnd?: GenerateTextOnStepEndCallback<TOOLS>;
+  /** @deprecated Use `onStepEnd` instead. */
   onStepFinish?: GenerateTextOnStepFinishCallback<TOOLS>;
 } & UIMessageStreamResponseInit & UIMessageStreamOptions<UIMessage<MESSAGE_METADATA, never, InferUITools<TOOLS>>>): Promise<Response>;
 /**
@@ -18014,21 +18974,7 @@ type UIMessageStreamOnStepEndCallback<UI_MESSAGE extends UIMessage> = (event: {
  */
 type UIMessageStreamOnStepFinishCallback<UI_MESSAGE extends UIMessage> = UIMessageStreamOnStepEndCallback<UI_MESSAGE>;
 declare const getOriginalFetch: () => typeof fetch;
-declare function callCompletionApi({
-  api,
-  prompt,
-  credentials,
-  headers,
-  body,
-  streamProtocol,
-  setCompletion,
-  setLoading,
-  setError,
-  setAbortController,
-  onFinish,
-  onError,
-  fetch
-}: {
+declare function callCompletionApi({ api, prompt, credentials, headers, body, streamProtocol, setCompletion, setLoading, setError, setAbortController, onFinish, onError, fetch }: {
   api: string;
   prompt: string;
   credentials: RequestCredentials | undefined;
@@ -18082,10 +19028,15 @@ interface ChatTransport<UI_MESSAGE extends UIMessage> {
    * @throws Error when the API request fails or response is invalid
    */
   sendMessages: (options: {
-    /** The type of message submission - either new message or regeneration */trigger: 'submit-message' | 'regenerate-message'; /** Unique identifier for the chat session */
-    chatId: string; /** ID of the message to regenerate, or undefined for new messages */
-    messageId: string | undefined; /** Array of UI messages representing the conversation history */
-    messages: UI_MESSAGE[]; /** Signal to abort the request if needed */
+    /** The type of message submission - either new message or regeneration */
+    trigger: 'submit-message' | 'regenerate-message';
+    /** Unique identifier for the chat session */
+    chatId: string;
+    /** ID of the message to regenerate, or undefined for new messages */
+    messageId: string | undefined;
+    /** Array of UI messages representing the conversation history */
+    messages: UI_MESSAGE[];
+    /** Signal to abort the request if needed */
     abortSignal: AbortSignal | undefined;
   } & ChatRequestOptions) => Promise<ReadableStream<UIMessageChunk>>;
   /**
@@ -18109,7 +19060,9 @@ interface ChatTransport<UI_MESSAGE extends UIMessage> {
    * @throws Error when the reconnection request fails or response is invalid
    */
   reconnectToStream: (options: {
-    /** Unique identifier for the chat session to reconnect to */chatId: string; /** Signal to abort the reconnection request if needed */
+    /** Unique identifier for the chat session to reconnect to */
+    chatId: string;
+    /** Signal to abort the reconnection request if needed */
     abortSignal?: AbortSignal;
   } & ChatRequestOptions) => Promise<ReadableStream<UIMessageChunk> | null>;
 }
@@ -18118,8 +19071,8 @@ type CreateUIMessage<UI_MESSAGE extends UIMessage> = Omit<UI_MESSAGE, 'id' | 'ro
   role?: UI_MESSAGE['role'];
 };
 type UIDataPartSchemas = Record<string, FlexibleSchema>;
-type UIDataTypesToSchemas<T extends UIDataTypes> = { [K in keyof T]: FlexibleSchema<T[K]> };
-type InferUIDataParts<T extends UIDataPartSchemas> = { [K in keyof T]: InferSchema<T[K]> };
+type UIDataTypesToSchemas<T extends UIDataTypes> = { [K in keyof T]: FlexibleSchema<T[K]>; };
+type InferUIDataParts<T extends UIDataPartSchemas> = { [K in keyof T]: InferSchema<T[K]>; };
 type ChatRequestOptions = {
   /**
    * Additional headers that should be to be passed to the API endpoint.
@@ -18134,12 +19087,7 @@ type ChatRequestOptions = {
 /**
  * Function that can be called to add a tool approval response to the chat.
  */
-type ChatAddToolApproveResponseFunction = ({
-  id,
-  approved,
-  reason,
-  options
-}: {
+type ChatAddToolApproveResponseFunction = ({ id, approved, reason, options }: {
   id: string;
   /**
    * Flag indicating whether the approval was granted or denied.
@@ -18157,14 +19105,7 @@ type ChatAddToolApproveResponseFunction = ({
 /**
  * Function that can be called to add a tool output to the chat.
  */
-type ChatAddToolOutputFunction<UI_MESSAGE extends UIMessage> = <TOOL extends keyof InferUIMessageTools<UI_MESSAGE>>({
-  state,
-  tool,
-  toolCallId,
-  output,
-  errorText,
-  options
-}: {
+type ChatAddToolOutputFunction<UI_MESSAGE extends UIMessage> = <TOOL extends keyof InferUIMessageTools<UI_MESSAGE>>({ state, tool, toolCallId, output, errorText, options }: {
   /**
    * Name of the tool that was called.
    */
@@ -18281,19 +19222,7 @@ declare abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
   private activeResponse;
   private activeResumeRequest;
   private jobExecutor;
-  constructor({
-    generateId,
-    id,
-    transport,
-    messageMetadataSchema,
-    dataPartSchemas,
-    state,
-    onError,
-    onToolCall,
-    onFinish,
-    onData,
-    sendAutomaticallyWhen
-  }: Omit<ChatInit<UI_MESSAGE>, 'messages'> & {
+  constructor({ generateId, id, transport, messageMetadataSchema, dataPartSchemas, state, onError, onToolCall, onFinish, onData, sendAutomaticallyWhen }: Omit<ChatInit<UI_MESSAGE>, 'messages'> & {
     state: ChatState<UI_MESSAGE>;
   });
   /**
@@ -18305,10 +19234,7 @@ declare abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
    * - `error`: An error occurred during the API request, preventing successful completion.
    */
   get status(): ChatStatus;
-  protected setStatus({
-    status,
-    error
-  }: {
+  protected setStatus({ status, error }: {
     status: ChatStatus;
     error?: Error;
   }): void;
@@ -18342,10 +19268,7 @@ declare abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
    * Regenerate the assistant message with the provided message id.
    * If no message id is provided, the last assistant message will be regenerated.
    */
-  regenerate: ({
-    messageId,
-    ...options
-  }?: {
+  regenerate: ({ messageId, ...options }?: {
     messageId?: string;
   } & ChatRequestOptions) => Promise<void>;
   /**
@@ -18482,19 +19405,8 @@ declare abstract class HttpChatTransport<UI_MESSAGE extends UIMessage> implement
   protected fetch?: FetchFunction;
   protected prepareSendMessagesRequest?: PrepareSendMessagesRequest<UI_MESSAGE>;
   protected prepareReconnectToStreamRequest?: PrepareReconnectToStreamRequest;
-  constructor({
-    api,
-    credentials,
-    headers,
-    body,
-    fetch,
-    prepareSendMessagesRequest,
-    prepareReconnectToStreamRequest
-  }: HttpChatTransportInitOptions<UI_MESSAGE>);
-  sendMessages({
-    abortSignal,
-    ...options
-  }: Parameters<ChatTransport<UI_MESSAGE>['sendMessages']>[0]): Promise<ReadableStream<UIMessageChunk>>;
+  constructor({ api, credentials, headers, body, fetch, prepareSendMessagesRequest, prepareReconnectToStreamRequest }: HttpChatTransportInitOptions<UI_MESSAGE>);
+  sendMessages({ abortSignal, ...options }: Parameters<ChatTransport<UI_MESSAGE>['sendMessages']>[0]): Promise<ReadableStream<UIMessageChunk>>;
   reconnectToStream(options: Parameters<ChatTransport<UI_MESSAGE>['reconnectToStream']>[0]): Promise<ReadableStream<UIMessageChunk> | null>;
   protected abstract processResponseStream(stream: ReadableStream<Uint8Array<ArrayBufferLike>>): ReadableStream<UIMessageChunk>;
 }
@@ -18537,15 +19449,8 @@ declare class DirectChatTransport<CALL_OPTIONS = never, TOOLS extends ToolSet =
   private readonly agent;
   private readonly agentOptions;
   private readonly uiMessageStreamOptions;
-  constructor({
-    agent,
-    options,
-    ...uiMessageStreamOptions
-  }: DirectChatTransportOptions<CALL_OPTIONS, TOOLS, RUNTIME_CONTEXT, OUTPUT, UI_MESSAGE>);
-  sendMessages({
-    messages,
-    abortSignal
-  }: Parameters<ChatTransport<UI_MESSAGE>['sendMessages']>[0]): Promise<ReadableStream<UIMessageChunk>>;
+  constructor({ agent, options, ...uiMessageStreamOptions }: DirectChatTransportOptions<CALL_OPTIONS, TOOLS, RUNTIME_CONTEXT, OUTPUT, UI_MESSAGE>);
+  sendMessages({ messages, abortSignal }: Parameters<ChatTransport<UI_MESSAGE>['sendMessages']>[0]): Promise<ReadableStream<UIMessageChunk>>;
   /**
    * Direct transport does not support reconnection since there is no
    * persistent server-side stream to reconnect to.
@@ -18559,9 +19464,7 @@ declare class DirectChatTransport<CALL_OPTIONS = never, TOOLS extends ToolSet =
  * The last step of the message must have at least one tool approval response and
  * all tool approvals must have a response.
  */
-declare function lastAssistantMessageIsCompleteWithApprovalResponses({
-  messages
-}: {
+declare function lastAssistantMessageIsCompleteWithApprovalResponses({ messages }: {
   messages: UIMessage[];
 }): boolean;
 /**
@@ -18569,9 +19472,7 @@ declare function lastAssistantMessageIsCompleteWithApprovalResponses({
  * The last step of the message must have at least one tool invocation and
  * all tool invocations must have a result.
  */
-declare function lastAssistantMessageIsCompleteWithToolCalls({
-  messages
-}: {
+declare function lastAssistantMessageIsCompleteWithToolCalls({ messages }: {
   messages: UIMessage[];
 }): boolean;
 declare class TextStreamChatTransport<UI_MESSAGE extends UIMessage> extends HttpChatTransport<UI_MESSAGE> {
@@ -18661,16 +19562,11 @@ type SafeValidateUIMessagesResult<UI_MESSAGE extends UIMessage> = {
  * but instead of throwing it returns `{ success: true, data }`
  * or `{ success: false, error }`.
  */
-declare function safeValidateUIMessages<UI_MESSAGE extends UIMessage>({
-  messages,
-  metadataSchema,
-  dataSchemas,
-  tools
-}: {
+declare function safeValidateUIMessages<UI_MESSAGE extends UIMessage>({ messages, metadataSchema, dataSchemas, tools }: {
   messages: unknown;
   metadataSchema?: FlexibleSchema<UIMessage['metadata']>;
-  dataSchemas?: { [NAME in keyof InferUIMessageData<UI_MESSAGE> & string]?: FlexibleSchema<InferUIMessageData<UI_MESSAGE>[NAME]> };
-  tools?: { [NAME in keyof InferUIMessageTools<UI_MESSAGE> & string]?: Tool<InferUIMessageTools<UI_MESSAGE>[NAME]['input'], InferUIMessageTools<UI_MESSAGE>[NAME]['output']> };
+  dataSchemas?: { [NAME in keyof InferUIMessageData<UI_MESSAGE> & string]?: FlexibleSchema<InferUIMessageData<UI_MESSAGE>[NAME]>; };
+  tools?: { [NAME in keyof InferUIMessageTools<UI_MESSAGE> & string]?: Tool<InferUIMessageTools<UI_MESSAGE>[NAME]['input'], InferUIMessageTools<UI_MESSAGE>[NAME]['output']>; };
 }): Promise<SafeValidateUIMessagesResult<UI_MESSAGE>>;
 /**
  * Validates a list of UI messages.
@@ -18679,16 +19575,11 @@ declare function safeValidateUIMessages<UI_MESSAGE extends UIMessage>({
  * the corresponding schemas are provided. Otherwise, they are assumed to be
  * valid.
  */
-declare function validateUIMessages<UI_MESSAGE extends UIMessage>({
-  messages,
-  metadataSchema,
-  dataSchemas,
-  tools
-}: {
+declare function validateUIMessages<UI_MESSAGE extends UIMessage>({ messages, metadataSchema, dataSchemas, tools }: {
   messages: unknown;
   metadataSchema?: FlexibleSchema<UIMessage['metadata']>;
-  dataSchemas?: { [NAME in keyof InferUIMessageData<UI_MESSAGE> & string]?: FlexibleSchema<InferUIMessageData<UI_MESSAGE>[NAME]> };
-  tools?: { [NAME in keyof InferUIMessageTools<UI_MESSAGE> & string]?: Tool<InferUIMessageTools<UI_MESSAGE>[NAME]['input'], InferUIMessageTools<UI_MESSAGE>[NAME]['output']> };
+  dataSchemas?: { [NAME in keyof InferUIMessageData<UI_MESSAGE> & string]?: FlexibleSchema<InferUIMessageData<UI_MESSAGE>[NAME]>; };
+  tools?: { [NAME in keyof InferUIMessageTools<UI_MESSAGE> & string]?: Tool<InferUIMessageTools<UI_MESSAGE>[NAME]['input'], InferUIMessageTools<UI_MESSAGE>[NAME]['output']>; };
 }): Promise<Array<UI_MESSAGE>>;
 interface UIMessageStreamWriter<UI_MESSAGE extends UIMessage = UIMessage> {
   /**
@@ -18721,17 +19612,7 @@ interface UIMessageStreamWriter<UI_MESSAGE extends UIMessage = UIMessage> {
  *
  * @returns A `ReadableStream` of UI message chunks.
  */
-declare function createUIMessageStream<UI_MESSAGE extends UIMessage>({
-  execute,
-  onError,
-  // prevent leaking server error details to the client by default
-  originalMessages,
-  onStepEnd,
-  onStepFinish,
-  onEnd,
-  onFinish,
-  generateId
-}: {
+declare function createUIMessageStream<UI_MESSAGE extends UIMessage>({ execute, onError, originalMessages, onStepEnd, onStepFinish, onEnd, onFinish, generateId }: {
   execute: (options: {
     writer: UIMessageStreamWriter<UI_MESSAGE>;
   }) => Promise<void> | void;
@@ -18770,13 +19651,7 @@ declare function createUIMessageStream<UI_MESSAGE extends UIMessage>({
  *
  * @returns A `Response` object with the UI message stream as the body.
  */
-declare function createUIMessageStreamResponse({
-  status,
-  statusText,
-  headers,
-  stream,
-  consumeSseStream
-}: UIMessageStreamResponseInit & {
+declare function createUIMessageStreamResponse({ status, statusText, headers, stream, consumeSseStream }: UIMessageStreamResponseInit & {
   stream: ReadableStream<UIMessageChunk>;
 }): Response;
 /**
@@ -18799,14 +19674,7 @@ declare class JsonToSseTransformStream extends TransformStream<unknown, string>
  * @param options.consumeSseStream - Optional callback to consume a copy of the SSE stream independently.
  * @returns A promise that resolves when the stream has been written.
  */
-declare function pipeUIMessageStreamToResponse({
-  response,
-  status,
-  statusText,
-  headers,
-  stream,
-  consumeSseStream
-}: {
+declare function pipeUIMessageStreamToResponse({ response, status, statusText, headers, stream, consumeSseStream }: {
   response: ServerResponse;
   stream: ReadableStream<UIMessageChunk>;
 } & UIMessageStreamResponseInit): Promise<void>;
@@ -18821,12 +19689,7 @@ declare function pipeUIMessageStreamToResponse({
  * @returns An `AsyncIterableStream` of `UIMessage`s. Each stream part is a different state of the same message
  * as it is being completed.
  */
-declare function readUIMessageStream<UI_MESSAGE extends UIMessage>({
-  message,
-  stream,
-  onError,
-  terminateOnError
-}: {
+declare function readUIMessageStream<UI_MESSAGE extends UIMessage>({ message, stream, onError, terminateOnError }: {
   message?: UI_MESSAGE;
   stream: ReadableStream<UIMessageChunk>;
   onError?: (error: unknown) => void;
@@ -18848,38 +19711,14 @@ type ToUIMessageChunkOptions<TOOLS extends ToolSet = ToolSet, UI_MESSAGE extends
  *
  * Returns `undefined` for stream parts that do not produce UI message chunks.
  */
-declare function toUIMessageChunk<TOOLS extends ToolSet = ToolSet, UI_MESSAGE extends UIMessage = UIMessage>(part: TextStreamPart<TOOLS>, {
-  tools,
-  sendReasoning,
-  sendSources,
-  sendStart,
-  sendFinish,
-  onError,
-  // prevent leaking server error details to the client by default
-  messageMetadata,
-  responseMessageId
-}?: ToUIMessageChunkOptions<TOOLS, UI_MESSAGE>): InferUIMessageChunk<UI_MESSAGE> | undefined;
+declare function toUIMessageChunk<TOOLS extends ToolSet = ToolSet, UI_MESSAGE extends UIMessage = UIMessage>(part: TextStreamPart<TOOLS>, { tools, sendReasoning, sendSources, sendStart, sendFinish, onError, messageMetadata, responseMessageId }?: ToUIMessageChunkOptions<TOOLS, UI_MESSAGE>): InferUIMessageChunk<UI_MESSAGE> | undefined;
 /**
  * Converts a stream of `TextStreamPart<TOOLS>` chunks (as emitted by
  * `streamText`'s `stream`) into a stream of `UIMessageChunk`s suitable for
  * UI message streaming, including response message ID injection and
  * `onEnd` handling.
  */
-declare function toUIMessageStream<TOOLS extends ToolSet = ToolSet, UI_MESSAGE extends UIMessage = UIMessage>({
-  stream,
-  tools,
-  sendReasoning,
-  sendSources,
-  sendStart,
-  sendFinish,
-  onError,
-  // prevent leaking server error details to the client by default
-  messageMetadata,
-  originalMessages,
-  generateMessageId,
-  onEnd,
-  onFinish
-}: {
+declare function toUIMessageStream<TOOLS extends ToolSet = ToolSet, UI_MESSAGE extends UIMessage = UIMessage>({ stream, tools, sendReasoning, sendSources, sendStart, sendFinish, onError, messageMetadata, originalMessages, generateMessageId, onEnd, onFinish }: {
   stream: ReadableStream<TextStreamPart<TOOLS>>;
   tools?: TOOLS;
 } & UIMessageStreamOptions<UI_MESSAGE>): ReadableStream<InferUIMessageChunk<UI_MESSAGE>>;
@@ -18909,18 +19748,7 @@ type UIMessageStreamOnFinishCallback<UI_MESSAGE extends UIMessage> = UIMessageSt
  *
  * @returns The UI message stream.
  */
-declare function createAgentUIStream<CALL_OPTIONS = never, TOOLS extends ToolSet = {}, RUNTIME_CONTEXT extends Context$1 = Context$1, OUTPUT extends Output = never, MESSAGE_METADATA = unknown, UI_MESSAGE extends UIMessage<MESSAGE_METADATA, never, InferUITools<TOOLS>> = UIMessage<MESSAGE_METADATA, never, InferUITools<TOOLS>>>({
-  agent,
-  uiMessages,
-  options,
-  abortSignal,
-  timeout,
-  experimental_sandbox: sandbox,
-  experimental_transform,
-  onStepEnd,
-  onStepFinish,
-  ...uiMessageStreamOptions
-}: {
+declare function createAgentUIStream<CALL_OPTIONS = never, TOOLS extends ToolSet = {}, RUNTIME_CONTEXT extends Context$1 = Context$1, OUTPUT extends Output = never, MESSAGE_METADATA = unknown, UI_MESSAGE extends UIMessage<MESSAGE_METADATA, never, InferUITools<TOOLS>> = UIMessage<MESSAGE_METADATA, never, InferUITools<TOOLS>>>({ agent, uiMessages, options, abortSignal, timeout, experimental_sandbox: sandbox, experimental_transform, onStepEnd, onStepFinish, ...uiMessageStreamOptions }: {
   agent: Agent$1<CALL_OPTIONS, TOOLS, RUNTIME_CONTEXT, OUTPUT>;
   uiMessages: unknown[];
   abortSignal?: AbortSignal;
@@ -18928,7 +19756,8 @@ declare function createAgentUIStream<CALL_OPTIONS = never, TOOLS extends ToolSet
   experimental_sandbox?: SandboxSession;
   options?: CALL_OPTIONS;
   experimental_transform?: Arrayable<StreamTextTransform<TOOLS>>;
-  onStepEnd?: GenerateTextOnStepEndCallback<TOOLS>; /** @deprecated Use `onStepEnd` instead. */
+  onStepEnd?: GenerateTextOnStepEndCallback<TOOLS>;
+  /** @deprecated Use `onStepEnd` instead. */
   onStepFinish?: GenerateTextOnStepFinishCallback<TOOLS>;
 } & UIMessageStreamOptions<UI_MESSAGE>): Promise<AsyncIterableStream<InferUIMessageChunk<UI_MESSAGE>>>;
 /**
@@ -18949,14 +19778,7 @@ declare function createAgentUIStream<CALL_OPTIONS = never, TOOLS extends ToolSet
  * @param statusText - The status text for the response. Optional.
  * @param consumeSseStream - Whether to consume the SSE stream. Optional.
  */
-declare function pipeAgentUIStreamToResponse<CALL_OPTIONS = never, TOOLS extends ToolSet = {}, RUNTIME_CONTEXT extends Context$1 = Context$1, OUTPUT extends Output = never, MESSAGE_METADATA = unknown>({
-  response,
-  headers,
-  status,
-  statusText,
-  consumeSseStream,
-  ...options
-}: {
+declare function pipeAgentUIStreamToResponse<CALL_OPTIONS = never, TOOLS extends ToolSet = {}, RUNTIME_CONTEXT extends Context$1 = Context$1, OUTPUT extends Output = never, MESSAGE_METADATA = unknown>({ response, headers, status, statusText, consumeSseStream, ...options }: {
   response: ServerResponse;
   agent: Agent$1<CALL_OPTIONS, TOOLS, RUNTIME_CONTEXT, OUTPUT>;
   uiMessages: unknown[];
@@ -18965,7 +19787,8 @@ declare function pipeAgentUIStreamToResponse<CALL_OPTIONS = never, TOOLS extends
   experimental_sandbox?: SandboxSession;
   options?: CALL_OPTIONS;
   experimental_transform?: Arrayable<StreamTextTransform<TOOLS>>;
-  onStepEnd?: GenerateTextOnStepEndCallback<TOOLS>; /** @deprecated Use `onStepEnd` instead. */
+  onStepEnd?: GenerateTextOnStepEndCallback<TOOLS>;
+  /** @deprecated Use `onStepEnd` instead. */
   onStepFinish?: GenerateTextOnStepFinishCallback<TOOLS>;
 } & UIMessageStreamResponseInit & UIMessageStreamOptions<UIMessage<MESSAGE_METADATA, never, InferUITools<TOOLS>>>): Promise<void>;
 /**
@@ -19075,38 +19898,15 @@ type TextBatchItemResult = (TextBatchGenerationResult & {
 /**
  * Starts a durable text-generation batch.
  */
-declare function startTextBatch({
-  model: modelArg,
-  requests,
-  providerOptions,
-  abortSignal,
-  headers,
-  timeout
-}: StartTextBatchOptions): Promise<StartTextBatchResult>;
+declare function startTextBatch({ model: modelArg, requests, providerOptions, abortSignal, headers, timeout }: StartTextBatchOptions): Promise<StartTextBatchResult>;
 /**
  * Retrieves the latest normalized status for a durable batch.
  */
-declare function getBatchStatus({
-  model: modelArg,
-  batch,
-  providerOptions,
-  maxRetries,
-  abortSignal,
-  headers,
-  timeout
-}: BatchOperationOptions): Promise<BatchStatus>;
+declare function getBatchStatus({ model: modelArg, batch, providerOptions, maxRetries, abortSignal, headers, timeout }: BatchOperationOptions): Promise<BatchStatus>;
 /**
  * Streams complete terminal results for the requests in a durable batch.
  */
-declare function getBatchResults({
-  model: modelArg,
-  batch,
-  providerOptions,
-  maxRetries,
-  abortSignal,
-  headers,
-  timeout
-}: BatchOperationOptions): AsyncIterableStream<TextBatchItemResult>;
+declare function getBatchResults({ model: modelArg, batch, providerOptions, maxRetries, abortSignal, headers, timeout }: BatchOperationOptions): AsyncIterableStream<TextBatchItemResult>;
 /**
  * The result of an `embed` call.
  * It contains the embedding, the value, and additional information.
@@ -19164,23 +19964,7 @@ interface EmbedResult {
  *
  * @returns A result object that contains the embedding, the value, and additional information.
  */
-declare function embed({
-  model: modelArg,
-  value,
-  providerOptions,
-  maxRetries: maxRetriesArg,
-  abortSignal,
-  headers,
-  experimental_telemetry,
-  telemetry,
-  onStart,
-  experimental_onStart,
-  onEnd,
-  experimental_onEnd,
-  _internal: {
-    generateCallId
-  }
-}: {
+declare function embed({ model: modelArg, value, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry, telemetry, onStart, experimental_onStart, onEnd, experimental_onEnd, _internal: { generateCallId } }: {
   /**
    * The embedding model to use.
    */
@@ -19314,24 +20098,7 @@ interface EmbedManyResult {
  *
  * @returns A result object that contains the embeddings, the value, and additional information.
  */
-declare function embedMany({
-  model: modelArg,
-  values,
-  maxParallelCalls,
-  maxRetries: maxRetriesArg,
-  abortSignal,
-  headers,
-  providerOptions,
-  experimental_telemetry,
-  telemetry,
-  onStart,
-  experimental_onStart,
-  onEnd,
-  experimental_onEnd,
-  _internal: {
-    generateCallId
-  }
-}: {
+declare function embedMany({ model: modelArg, values, maxParallelCalls, maxRetries: maxRetriesArg, abortSignal, headers, providerOptions, experimental_telemetry, telemetry, onStart, experimental_onStart, onEnd, experimental_onEnd, _internal: { generateCallId } }: {
   /**
    * The embedding model to use.
    */
@@ -19413,11 +20180,7 @@ declare class InvalidArgumentError extends AISDKError {
   private readonly [symbol$j];
   readonly parameter: string;
   readonly value: unknown;
-  constructor({
-    parameter,
-    value,
-    message
-  }: {
+  constructor({ parameter, value, message }: {
     parameter: string;
     value: unknown;
     message: string;
@@ -19508,38 +20271,7 @@ type LanguageModelStreamPart<TOOLS extends ToolSet = ToolSet> = Exclude<TextStre
  *
  * @returns A stream of model call parts together with request and response metadata when available.
  */
-declare function streamLanguageModelCall<TOOLS extends ToolSet, OUTPUT extends Output = Output>({
-  model,
-  tools,
-  toolOrder,
-  output,
-  toolChoice,
-  prompt,
-  system,
-  instructions,
-  messages,
-  allowSystemInMessages,
-  download,
-  abortSignal,
-  headers,
-  includeRawChunks,
-  providerOptions,
-  repairToolCall,
-  refineToolInput,
-  executeLanguageModelCallInTelemetryContext,
-  callId,
-  toolsContext,
-  experimental_sandbox: sandbox,
-  _internal: {
-    generateId,
-    generateCallId,
-    now
-  },
-  onStart,
-  onLanguageModelCallStart,
-  onLanguageModelCallEnd,
-  ...callSettings
-}: {
+declare function streamLanguageModelCall<TOOLS extends ToolSet, OUTPUT extends Output = Output>({ model, tools, toolOrder, output, toolChoice, prompt, system, instructions, messages, allowSystemInMessages, download, abortSignal, headers, includeRawChunks, providerOptions, repairToolCall, refineToolInput, executeLanguageModelCallInTelemetryContext, callId, toolsContext, experimental_sandbox: sandbox, _internal: { generateId, generateCallId, now }, onStart, onLanguageModelCallStart, onLanguageModelCallEnd, ...callSettings }: {
   model: LanguageModel;
   tools?: TOOLS;
   toolOrder?: ToolOrder<TOOLS>;
@@ -19592,10 +20324,7 @@ declare const symbol$i: unique symbol;
 declare class InvalidStreamPartError extends AISDKError {
   private readonly [symbol$i];
   readonly chunk: LanguageModelStreamPart<any>;
-  constructor({
-    chunk,
-    message
-  }: {
+  constructor({ chunk, message }: {
     chunk: LanguageModelStreamPart<any>;
     message: string;
   });
@@ -19605,9 +20334,7 @@ declare const symbol$h: unique symbol;
 declare class InvalidToolApprovalError extends AISDKError {
   private readonly [symbol$h];
   readonly approvalId: string;
-  constructor({
-    approvalId
-  }: {
+  constructor({ approvalId }: {
     approvalId: string;
   });
   static isInstance(error: unknown): error is InvalidToolApprovalError;
@@ -19617,11 +20344,7 @@ declare class InvalidToolApprovalSignatureError extends AISDKError {
   private readonly [symbol$g];
   readonly approvalId: string;
   readonly toolCallId: string;
-  constructor({
-    approvalId,
-    toolCallId,
-    reason
-  }: {
+  constructor({ approvalId, toolCallId, reason }: {
     approvalId: string;
     toolCallId: string;
     reason: string;
@@ -19633,10 +20356,7 @@ declare class ToolCallNotFoundForApprovalError extends AISDKError {
   private readonly [symbol$f];
   readonly toolCallId: string;
   readonly approvalId: string;
-  constructor({
-    toolCallId,
-    approvalId
-  }: {
+  constructor({ toolCallId, approvalId }: {
     toolCallId: string;
     approvalId: string;
   });
@@ -19646,9 +20366,7 @@ declare const symbol$e: unique symbol;
 declare class MissingToolResultsError extends AISDKError {
   private readonly [symbol$e];
   readonly toolCallIds: string[];
-  constructor({
-    toolCallIds
-  }: {
+  constructor({ toolCallIds }: {
     toolCallIds: string[];
   });
   static isInstance(error: unknown): error is MissingToolResultsError;
@@ -19666,11 +20384,7 @@ declare class NoImageGeneratedError extends AISDKError {
    * The response metadata for each call.
    */
   readonly responses: Array<ImageModelResponseMetadata> | undefined;
-  constructor({
-    message,
-    cause,
-    responses
-  }: {
+  constructor({ message, cause, responses }: {
     message?: string;
     cause?: Error;
     responses?: Array<ImageModelResponseMetadata>;
@@ -19707,14 +20421,7 @@ declare class NoObjectGeneratedError extends AISDKError {
    * Reason why the model finished generating a response.
    */
   readonly finishReason: FinishReason | undefined;
-  constructor({
-    message,
-    cause,
-    text: text$1,
-    response,
-    usage,
-    finishReason
-  }: {
+  constructor({ message, cause, text: text$1, response, usage, finishReason }: {
     message?: string;
     cause?: Error;
     text?: string;
@@ -19730,10 +20437,7 @@ declare const symbol$b: unique symbol;
  */
 declare class NoOutputGeneratedError extends AISDKError {
   private readonly [symbol$b];
-  constructor({
-    message,
-    cause
-  }?: {
+  constructor({ message, cause }?: {
     message?: string;
     cause?: Error;
   });
@@ -19822,11 +20526,7 @@ declare const symbol$7: unique symbol;
 declare class NoVideoGeneratedError extends AISDKError {
   private readonly [symbol$7];
   readonly responses: Array<VideoModelResponseMetadata>;
-  constructor({
-    message,
-    cause,
-    responses
-  }: {
+  constructor({ message, cause, responses }: {
     message?: string;
     cause?: unknown;
     responses: Array<VideoModelResponseMetadata>;
@@ -19851,11 +20551,7 @@ declare const symbol$6: unique symbol;
 declare class ToolCallRepairError extends AISDKError {
   private readonly [symbol$6];
   readonly originalError: NoSuchToolError | InvalidToolInputError;
-  constructor({
-    cause,
-    originalError,
-    message
-  }: {
+  constructor({ cause, originalError, message }: {
     message?: string;
     cause: unknown;
     originalError: NoSuchToolError | InvalidToolInputError;
@@ -19896,11 +20592,7 @@ declare class UIMessageStreamError extends AISDKError {
    * The ID associated with the failing chunk (part ID or toolCallId).
    */
   readonly chunkId: string;
-  constructor({
-    chunkType,
-    chunkId,
-    message
-  }: {
+  constructor({ chunkType, chunkId, message }: {
     chunkType: string;
     chunkId: string;
     message: string;
@@ -19911,11 +20603,7 @@ declare const symbol$4: unique symbol;
 declare class InvalidDataContentError extends AISDKError {
   private readonly [symbol$4];
   readonly content: unknown;
-  constructor({
-    content,
-    cause,
-    message
-  }: {
+  constructor({ content, cause, message }: {
     content: unknown;
     cause?: unknown;
     message?: string;
@@ -19926,10 +20614,7 @@ declare const symbol$3: unique symbol;
 declare class InvalidMessageRoleError extends AISDKError {
   private readonly [symbol$3];
   readonly role: string;
-  constructor({
-    role,
-    message
-  }: {
+  constructor({ role, message }: {
     role: string;
     message?: string;
   });
@@ -19939,10 +20624,7 @@ declare const symbol$2: unique symbol;
 declare class MessageConversionError extends AISDKError {
   private readonly [symbol$2];
   readonly originalMessage: Omit<UIMessage, 'id'>;
-  constructor({
-    originalMessage,
-    message
-  }: {
+  constructor({ originalMessage, message }: {
     originalMessage: Omit<UIMessage, 'id'>;
     message: string;
   });
@@ -19955,11 +20637,7 @@ declare class RetryError extends AISDKError {
   readonly reason: RetryErrorReason;
   readonly lastError: unknown;
   readonly errors: Array<unknown>;
-  constructor({
-    message,
-    reason,
-    errors
-  }: {
+  constructor({ message, reason, errors }: {
     message: string;
     reason: RetryErrorReason;
     errors: Array<unknown>;
@@ -19975,10 +20653,7 @@ type ActiveToolSubset<TOOLS extends ToolSet | undefined, ACTIVE_TOOL_NAMES exten
  * @param activeTools - The active tools to include.
  * @returns The filtered tools.
  */
-declare function filterActiveTools<TOOLS extends ToolSet | undefined, ACTIVE_TOOL_NAMES extends ActiveTools<NonNullable<TOOLS>>>({
-  tools,
-  activeTools
-}: {
+declare function filterActiveTools<TOOLS extends ToolSet | undefined, ACTIVE_TOOL_NAMES extends ActiveTools<NonNullable<TOOLS>>>({ tools, activeTools }: {
   tools: TOOLS;
   activeTools: ACTIVE_TOOL_NAMES;
 }): ActiveToolSubset<TOOLS, ACTIVE_TOOL_NAMES>;
@@ -19992,12 +20667,7 @@ declare function filterActiveTools<TOOLS extends ToolSet | undefined, ACTIVE_TOO
  *
  * @returns The pruned list of model messages.
  */
-declare function pruneMessages({
-  messages,
-  reasoning,
-  toolCalls,
-  emptyMessages
-}: {
+declare function pruneMessages({ messages, reasoning, toolCalls, emptyMessages }: {
   messages: ModelMessage[];
   reasoning?: 'all' | 'before-last-message' | 'none';
   toolCalls?: 'all' | 'before-last-message' | `before-last-${number}-messages` | 'none' | Array<{
@@ -20022,13 +20692,7 @@ type ChunkDetector = (buffer: string) => string | undefined | null;
  *
  * @returns A transform stream that smooths text streaming output.
  */
-declare function smoothStream<TOOLS extends ToolSet>({
-  delayInMs,
-  chunking,
-  _internal: {
-    delay
-  }
-}?: {
+declare function smoothStream<TOOLS extends ToolSet>({ delayInMs, chunking, _internal: { delay } }?: {
   delayInMs?: number | null;
   chunking?: 'word' | 'line' | RegExp | ChunkDetector | Intl.Segmenter;
   /**
@@ -20115,19 +20779,7 @@ type GenerateImagePrompt = string | {
  *
  * @returns A result object that contains the generated images.
  */
-declare function generateImage({
-  model: modelArg,
-  prompt: promptArg,
-  n,
-  maxImagesPerCall,
-  size,
-  aspectRatio,
-  seed,
-  providerOptions,
-  maxRetries: maxRetriesArg,
-  abortSignal,
-  headers
-}: {
+declare function generateImage({ model: modelArg, prompt: promptArg, n, maxImagesPerCall, size, aspectRatio, seed, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers }: {
   /**
    * The image model to use.
    */
@@ -20317,7 +20969,7 @@ type RepairTextFunction = (options: {
  *
  * @deprecated Use `generateText` with an `output` setting instead.
  */
-declare function generateObject<SCHEMA extends FlexibleSchema<unknown> = FlexibleSchema<JSONValue$3>, OUTPUT extends 'object' | 'array' | 'enum' | 'no-schema' = (InferSchema<SCHEMA> extends string ? 'enum' : 'object'), RESULT = (OUTPUT extends 'array' ? Array<InferSchema<SCHEMA>> : InferSchema<SCHEMA>)>(options: Omit<LanguageModelCallOptions, 'stopSequences'> & Omit<RequestOptions, 'timeout'> & Prompt & (OUTPUT extends 'enum' ? {
+declare function generateObject<SCHEMA extends FlexibleSchema<unknown> = FlexibleSchema<JSONValue$3>, OUTPUT extends 'object' | 'array' | 'enum' | 'no-schema' = InferSchema<SCHEMA> extends string ? 'enum' : 'object', RESULT = OUTPUT extends 'array' ? Array<InferSchema<SCHEMA>> : InferSchema<SCHEMA>>(options: Omit<LanguageModelCallOptions, 'stopSequences'> & Omit<RequestOptions, 'timeout'> & Prompt & (OUTPUT extends 'enum' ? {
   /**
    * The enum values that the model should use.
    */
@@ -20441,11 +21093,7 @@ declare function generateObject<SCHEMA extends FlexibleSchema<unknown> = Flexibl
  * @param options.onError - Optional callback to handle errors that occur during consumption.
  * @returns A promise that resolves when the stream is fully consumed.
  */
-declare function consumeStream({
-  stream,
-  onError,
-  abortSignal
-}: {
+declare function consumeStream({ stream, onError, abortSignal }: {
   stream: ReadableStream;
   onError?: (error: unknown) => void;
   abortSignal?: AbortSignal;
@@ -20471,10 +21119,7 @@ declare function cosineSimilarity(vector1: number[], vector2: number[]): number;
  */
 declare function createDownload(options?: {
   maxBytes?: number;
-}): ({
-  url,
-  abortSignal
-}: {
+}): ({ url, abortSignal }: {
   url: URL;
   abortSignal?: AbortSignal;
 }) => Promise<{
@@ -20513,12 +21158,7 @@ declare class SerialJobExecutor {
  * @param options.chunkDelayInMs - Optional delay in milliseconds between emitting each value (default: 0). Can be set to `null` to skip the delay. The difference between `chunkDelayInMs: null` and `chunkDelayInMs: 0` is that `chunkDelayInMs: null` will emit the values without any delay, while `chunkDelayInMs: 0` will emit the values with a delay of 0 milliseconds.
  * @returns A ReadableStream that emits the provided values
  */
-declare function simulateReadableStream<T>({
-  chunks,
-  initialDelayInMs,
-  chunkDelayInMs,
-  _internal
-}: {
+declare function simulateReadableStream<T>({ chunks, initialDelayInMs, chunkDelayInMs, _internal }: {
   chunks: T[];
   initialDelayInMs?: number | null;
   chunkDelayInMs?: number | null;
@@ -20726,7 +21366,7 @@ type StreamObjectOnFinishCallback<RESULT> = (event: {
  *
  * @deprecated Use `streamText` with an `output` setting instead.
  */
-declare function streamObject<SCHEMA extends FlexibleSchema<unknown> = FlexibleSchema<JSONValue$3>, OUTPUT extends 'object' | 'array' | 'enum' | 'no-schema' = (InferSchema<SCHEMA> extends string ? 'enum' : 'object'), RESULT = (OUTPUT extends 'array' ? Array<InferSchema<SCHEMA>> : InferSchema<SCHEMA>)>(options: Omit<LanguageModelCallOptions, 'stopSequences'> & Omit<RequestOptions, 'timeout'> & Prompt & (OUTPUT extends 'enum' ? {
+declare function streamObject<SCHEMA extends FlexibleSchema<unknown> = FlexibleSchema<JSONValue$3>, OUTPUT extends 'object' | 'array' | 'enum' | 'no-schema' = InferSchema<SCHEMA> extends string ? 'enum' : 'object', RESULT = OUTPUT extends 'array' ? Array<InferSchema<SCHEMA>> : InferSchema<SCHEMA>>(options: Omit<LanguageModelCallOptions, 'stopSequences'> & Omit<RequestOptions, 'timeout'> & Prompt & (OUTPUT extends 'enum' ? {
   /**
    * The enum values that the model should use.
    */
@@ -20893,19 +21533,7 @@ interface SpeechResult {
  *
  * @returns A result object that contains the generated audio data.
  */
-declare function generateSpeech({
-  model,
-  text: text$1,
-  voice,
-  outputFormat,
-  instructions,
-  speed,
-  language,
-  providerOptions,
-  maxRetries: maxRetriesArg,
-  abortSignal,
-  headers
-}: {
+declare function generateSpeech({ model, text: text$1, voice, outputFormat, instructions, speed, language, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers }: {
   /**
    * The speech model to use.
    */
@@ -21049,27 +21677,7 @@ type GenerateVideoWebhookFactory = () => PromiseLike<{
   url: string;
   received: PromiseLike<VideoModelV4OperationWebhook>;
 }>;
-declare function experimental_generateVideo({
-  model: modelArg,
-  prompt: promptArg,
-  n,
-  maxVideosPerCall,
-  aspectRatio,
-  resolution,
-  duration,
-  fps,
-  seed,
-  frameImages,
-  inputReferences,
-  generateAudio,
-  providerOptions,
-  maxRetries: maxRetriesArg,
-  abortSignal,
-  headers,
-  download: downloadFn,
-  poll,
-  webhook
-}: {
+declare function experimental_generateVideo({ model: modelArg, prompt: promptArg, n, maxVideosPerCall, aspectRatio, resolution, duration, fps, seed, frameImages, inputReferences, generateAudio, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, download: downloadFn, poll, webhook }: {
   /**
    * The video model to use.
    */
@@ -21199,9 +21807,7 @@ declare function experimental_generateVideo({
 /**
  * Applies default settings for an embedding model.
  */
-declare function defaultEmbeddingSettingsMiddleware({
-  settings
-}: {
+declare function defaultEmbeddingSettingsMiddleware({ settings }: {
   settings: Partial<{
     headers?: EmbeddingModelV4CallOptions['headers'];
     providerOptions?: EmbeddingModelV4CallOptions['providerOptions'];
@@ -21211,9 +21817,7 @@ declare function defaultEmbeddingSettingsMiddleware({
  * Applies default instructions to a language model when a call does not
  * already contain a system message.
  */
-declare function defaultInstructionsMiddleware({
-  instructions
-}: {
+declare function defaultInstructionsMiddleware({ instructions }: {
   /**
    * Default instructions to prepend to calls that do not contain a system
    * message.
@@ -21223,9 +21827,7 @@ declare function defaultInstructionsMiddleware({
 /**
  * Applies default settings for a language model.
  */
-declare function defaultSettingsMiddleware({
-  settings
-}: {
+declare function defaultSettingsMiddleware({ settings }: {
   settings: Partial<{
     maxOutputTokens?: LanguageModelV4CallOptions['maxOutputTokens'];
     temperature?: LanguageModelV4CallOptions['temperature'];
@@ -21269,11 +21871,7 @@ declare function extractJsonMiddleware(options?: {
  * @param separator - The separator to use between reasoning and text sections.
  * @param startWithReasoning - Whether to start with reasoning tokens.
  */
-declare function extractReasoningMiddleware({
-  tagName,
-  separator,
-  startWithReasoning
-}: {
+declare function extractReasoningMiddleware({ tagName, separator, startWithReasoning }: {
   tagName: string;
   separator?: string;
   startWithReasoning?: boolean;
@@ -21305,11 +21903,7 @@ declare function simulateStreamingMiddleware(): LanguageModelMiddleware;
  * });
  * ```
  */
-declare function addToolInputExamplesMiddleware({
-  prefix,
-  format,
-  remove
-}?: {
+declare function addToolInputExamplesMiddleware({ prefix, format, remove }?: {
   /**
    * A prefix to prepend before the examples.
    */
@@ -21340,12 +21934,7 @@ declare function addToolInputExamplesMiddleware({
  * @param options.providerId - Optional custom provider ID to override the original model's provider ID.
  * @returns A new LanguageModelV4 instance with middleware applied.
  */
-declare const wrapLanguageModel$1: ({
-  model: inputModel,
-  middleware: middlewareArg,
-  modelId,
-  providerId
-}: {
+declare const wrapLanguageModel$1: ({ model: inputModel, middleware: middlewareArg, modelId, providerId }: {
   model: LanguageModelV2$1 | LanguageModelV3$1 | LanguageModelV4;
   middleware: LanguageModelMiddleware | LanguageModelMiddleware[];
   modelId?: string;
@@ -21363,12 +21952,7 @@ declare const wrapLanguageModel$1: ({
  * @param options.providerId - Optional custom provider ID to override the original model's provider ID.
  * @returns A new EmbeddingModelV4 instance with middleware applied.
  */
-declare const wrapEmbeddingModel: ({
-  model: inputModel,
-  middleware: middlewareArg,
-  modelId,
-  providerId
-}: {
+declare const wrapEmbeddingModel: ({ model: inputModel, middleware: middlewareArg, modelId, providerId }: {
   model: EmbeddingModelV3 | EmbeddingModelV4;
   middleware: EmbeddingModelMiddleware | EmbeddingModelMiddleware[];
   modelId?: string;
@@ -21386,12 +21970,7 @@ declare const wrapEmbeddingModel: ({
  * @param options.providerId - Optional custom provider ID to override the original model's provider ID.
  * @returns A new ImageModelV4 instance with middleware applied.
  */
-declare const wrapImageModel: ({
-  model: inputModel,
-  middleware: middlewareArg,
-  modelId,
-  providerId
-}: {
+declare const wrapImageModel: ({ model: inputModel, middleware: middlewareArg, modelId, providerId }: {
   model: ImageModelV2 | ImageModelV3 | ImageModelV4;
   middleware: ImageModelMiddleware | ImageModelMiddleware[];
   modelId?: string;
@@ -21409,11 +21988,7 @@ declare const wrapImageModel: ({
  * @param options.imageModelMiddleware - Optional middleware to be applied to all image models from the provider. When multiple middlewares are provided, the first middleware will transform the input first, and the last middleware will be wrapped directly around the model.
  * @returns A new ProviderV4 instance with middleware applied to all language models.
  */
-declare function wrapProvider({
-  provider,
-  languageModelMiddleware,
-  imageModelMiddleware
-}: {
+declare function wrapProvider({ provider, languageModelMiddleware, imageModelMiddleware }: {
   provider: ProviderV4 | ProviderV3 | ProviderV2;
   languageModelMiddleware: LanguageModelMiddleware | LanguageModelMiddleware[];
   imageModelMiddleware?: ImageModelMiddleware | ImageModelMiddleware[];
@@ -21452,10 +22027,7 @@ type RealtimeClientEvent = RealtimeModelV4ClientEvent;
 type RealtimeServerEvent = RealtimeModelV4ServerEvent;
 type RealtimeSessionConfig = RealtimeModelV4SessionConfig;
 type RealtimeToolDefinition = RealtimeModelV4ToolDefinition;
-declare function getRealtimeToolDefinitions<TOOLS extends ToolSet>({
-  tools,
-  toolsContext
-}: {
+declare function getRealtimeToolDefinitions<TOOLS extends ToolSet>({ tools, toolsContext }: {
   tools: TOOLS;
   toolsContext?: InferToolSetContext<TOOLS>;
 }): Promise<RealtimeToolDefinition[]>;
@@ -21560,18 +22132,7 @@ type RealtimeSetupResponse = {
  *
  * @throws {NoSuchModelError} Throws when a requested model is not found and no fallback provider is available.
  */
-declare function customProvider<LANGUAGE_MODELS extends Record<string, LanguageModel>, EMBEDDING_MODELS extends Record<string, EmbeddingModel>, IMAGE_MODELS extends Record<string, ImageModel>, TRANSCRIPTION_MODELS extends Record<string, TranscriptionModel>, SPEECH_MODELS extends Record<string, SpeechModel>, RERANKING_MODELS extends Record<string, RerankingModel>, VIDEO_MODELS extends Record<string, VideoModel>, FILES extends FilesV4 | undefined = undefined, SKILLS extends SkillsV4 | undefined = undefined, FALLBACK extends ProviderV2 | ProviderV3 | ProviderV4 | undefined = undefined>({
-  languageModels,
-  embeddingModels,
-  imageModels,
-  transcriptionModels,
-  speechModels,
-  rerankingModels,
-  videoModels,
-  files,
-  skills,
-  fallbackProvider: fallbackProviderArg
-}: {
+declare function customProvider<LANGUAGE_MODELS extends Record<string, LanguageModel>, EMBEDDING_MODELS extends Record<string, EmbeddingModel>, IMAGE_MODELS extends Record<string, ImageModel>, TRANSCRIPTION_MODELS extends Record<string, TranscriptionModel>, SPEECH_MODELS extends Record<string, SpeechModel>, RERANKING_MODELS extends Record<string, RerankingModel>, VIDEO_MODELS extends Record<string, VideoModel>, FILES extends FilesV4 | undefined = undefined, SKILLS extends SkillsV4 | undefined = undefined, FALLBACK extends ProviderV2 | ProviderV3 | ProviderV4 | undefined = undefined>({ languageModels, embeddingModels, imageModels, transcriptionModels, speechModels, rerankingModels, videoModels, files, skills, fallbackProvider: fallbackProviderArg }: {
   languageModels?: LANGUAGE_MODELS;
   embeddingModels?: EMBEDDING_MODELS;
   imageModels?: IMAGE_MODELS;
@@ -21613,13 +22174,7 @@ declare class NoSuchProviderError extends NoSuchModelError {
   private readonly [symbol];
   readonly providerId: string;
   readonly availableProviders: string[];
-  constructor({
-    modelId,
-    modelType,
-    providerId,
-    availableProviders,
-    message
-  }: {
+  constructor({ modelId, modelType, providerId, availableProviders, message }: {
     modelId: string;
     modelType: 'languageModel' | 'embeddingModel' | 'imageModel' | 'transcriptionModel' | 'speechModel' | 'rerankingModel' | 'videoModel';
     providerId: string;
@@ -21676,11 +22231,7 @@ interface ProviderRegistryProvider<PROVIDERS extends Record<string, ProviderV4 |
  * @param options.imageModelMiddleware - Optional middleware to be applied to all image models from the registry. When multiple middlewares are provided, the first middleware will transform the input first, and the last middleware will be wrapped directly around the model.
  * @returns A new ProviderRegistryProvider instance that provides access to all registered providers with optional middleware applied to language and image models.
  */
-declare function createProviderRegistry<PROVIDERS extends Record<string, ProviderV4 | ProviderV3>, SEPARATOR extends string = ':'>(providers: PROVIDERS, {
-  separator,
-  languageModelMiddleware,
-  imageModelMiddleware
-}?: {
+declare function createProviderRegistry<PROVIDERS extends Record<string, ProviderV4 | ProviderV3>, SEPARATOR extends string = ':'>(providers: PROVIDERS, { separator, languageModelMiddleware, imageModelMiddleware }?: {
   separator?: SEPARATOR;
   languageModelMiddleware?: LanguageModelMiddleware | LanguageModelMiddleware[];
   imageModelMiddleware?: ImageModelMiddleware | ImageModelMiddleware[];
@@ -21765,25 +22316,7 @@ interface RerankResult<VALUE> {
  *
  * @returns A result object that contains the reranked documents, the reranked indices, and additional information.
  */
-declare function rerank<VALUE extends JSONObject$2 | string>({
-  model: modelArg,
-  documents,
-  query,
-  topN,
-  maxRetries: maxRetriesArg,
-  abortSignal,
-  headers,
-  providerOptions,
-  experimental_telemetry,
-  telemetry,
-  onStart,
-  experimental_onStart,
-  onEnd,
-  experimental_onEnd,
-  _internal: {
-    generateCallId
-  }
-}: {
+declare function rerank<VALUE extends JSONObject$2 | string>({ model: modelArg, documents, query, topN, maxRetries: maxRetriesArg, abortSignal, headers, providerOptions, experimental_telemetry, telemetry, onStart, experimental_onStart, onEnd, experimental_onEnd, _internal: { generateCallId } }: {
   /**
    * The reranking model to use.
    */
@@ -21878,12 +22411,7 @@ declare function registerTelemetry(...integrations: Telemetry[]): void;
  * @param options.stream - The text stream to send.
  * @returns A Response object with the text stream body.
  */
-declare function createTextStreamResponse({
-  status,
-  statusText,
-  headers,
-  stream
-}: ResponseInit & {
+declare function createTextStreamResponse({ status, statusText, headers, stream }: ResponseInit & {
   stream: ReadableStream<string>;
 }): Response;
 /**
@@ -21899,22 +22427,14 @@ declare function createTextStreamResponse({
  * @param options.stream - The text stream to pipe.
  * @returns A promise that resolves when the stream has been written.
  */
-declare function pipeTextStreamToResponse({
-  response,
-  status,
-  statusText,
-  headers,
-  stream
-}: {
+declare function pipeTextStreamToResponse({ response, status, statusText, headers, stream }: {
   response: ServerResponse;
   stream: ReadableStream<string>;
 } & ResponseInit): Promise<void>;
 /**
  * Converts a stream of `TextStreamPart` chunks into a stream of text deltas.
  */
-declare function toTextStream<TOOLS extends ToolSet = ToolSet>({
-  stream
-}: {
+declare function toTextStream<TOOLS extends ToolSet = ToolSet>({ stream }: {
   stream: ReadableStream<TextStreamPart<TOOLS>>;
 }): ReadableStream<string>;
 /**
@@ -21967,15 +22487,7 @@ interface TranscriptionResult {
    */
   readonly providerMetadata: Record<string, JSONObject$2>;
 }
-declare function transcribe({
-  model,
-  audio,
-  providerOptions,
-  maxRetries: maxRetriesArg,
-  abortSignal,
-  headers,
-  download: downloadFn
-}: {
+declare function transcribe({ model, audio, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, download: downloadFn }: {
   /**
    * The transcription model to use.
    */
@@ -22111,18 +22623,7 @@ interface StreamTranscriptionResult {
  *
  * @returns A result object that contains the streaming transcript and final transcript metadata.
  */
-declare function streamTranscribe({
-  model,
-  audio,
-  inputAudioFormat,
-  providerOptions,
-  abortSignal,
-  headers,
-  includeRawChunks,
-  _internal: {
-    currentDate
-  }
-}: {
+declare function streamTranscribe({ model, audio, inputAudioFormat, providerOptions, abortSignal, headers, includeRawChunks, _internal: { currentDate } }: {
   /**
    * The transcription model to use.
    */
@@ -22308,21 +22809,7 @@ interface StreamTranslationResult {
  *
  * @returns A result object that contains the streaming translation and final translation metadata.
  */
-declare function streamTranslate({
-  model,
-  audio,
-  inputAudioFormat,
-  targetLanguage,
-  sourceLanguage,
-  outputAudioFormat,
-  providerOptions,
-  abortSignal,
-  headers,
-  includeRawChunks,
-  _internal: {
-    currentDate
-  }
-}: {
+declare function streamTranslate({ model, audio, inputAudioFormat, targetLanguage, sourceLanguage, outputAudioFormat, providerOptions, abortSignal, headers, includeRawChunks, _internal: { currentDate } }: {
   /**
    * The speech translation model to use.
    */
@@ -22393,13 +22880,7 @@ interface UploadFileResult {
  *
  * @returns A result object containing the provider reference and optional metadata.
  */
-declare function uploadFile({
-  api,
-  data: dataArg,
-  mediaType: mediaTypeArg,
-  filename,
-  providerOptions
-}: {
+declare function uploadFile({ api, data: dataArg, mediaType: mediaTypeArg, filename, providerOptions }: {
   /**
    * The files API interface to use for uploading.
    * Can be a `FilesV4` instance or a `ProviderV4` instance with a `files()` method.
@@ -22428,29 +22909,24 @@ type UploadSkillFile = Omit<SkillsV4File, 'data'> & {
    */
   data: SkillsV4File['data'] | Uint8Array | string;
 };
-declare function uploadSkill({
-  api,
-  files,
-  displayTitle,
-  providerOptions
-}: {
+declare function uploadSkill({ api, files, displayTitle, providerOptions }: {
   api: SkillsV4 | ProviderV4;
 } & Omit<SkillsV4UploadSkillCallOptions, 'files'> & {
   files: UploadSkillFile[];
 }): Promise<UploadSkillResult>;
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/aisdk/index.d.ts
-declare const wrapAISDK: (ai: typeof index_d_exports) => typeof index_d_exports;
-declare function wrapLanguageModel(languageModel: LanguageModelV4): LanguageModelV4;
-declare function wrapLanguageModel(languageModel: LanguageModelV3): LanguageModelV3;
-declare function wrapLanguageModel(languageModel: LanguageModelV2): LanguageModelV2;
+export declare const wrapAISDK: (ai: typeof index_d_exports) => typeof index_d_exports;
+export declare function wrapLanguageModel(languageModel: LanguageModelV4): LanguageModelV4;
+export declare function wrapLanguageModel(languageModel: LanguageModelV3): LanguageModelV3;
+export declare function wrapLanguageModel(languageModel: LanguageModelV2): LanguageModelV2;
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/aisdk/v7-integration/index.d.ts
 /**
  * The AI SDK v7 diagnostics channel name. Every lifecycle event fires
  * `{ type, event }` through this channel.
  */
-declare const AI_SDK_TELEMETRY_DIAGNOSTIC_CHANNEL = "aisdk:telemetry";
+export declare const AI_SDK_TELEMETRY_DIAGNOSTIC_CHANNEL = "aisdk:telemetry";
 interface LaminarAiSdkTelemetryOptions {
   /**
    * When true, record prompt messages and response content on spans.
@@ -22478,7 +22954,7 @@ interface LaminarAiSdkTelemetryOptions {
  * `Telemetry` interface from `ai` so users can pick up the integration even
  * when they are on a narrower `ai` version that doesn't export it yet.
  */
-declare class LaminarAiSdkTelemetry {
+export declare class LaminarAiSdkTelemetry {
   private readonly recordInputs;
   private readonly recordOutputs;
   private readonly createStepSpan;
@@ -22516,6 +22992,8 @@ declare class LaminarAiSdkTelemetry {
   onEmbedEnd: (event: any) => void;
   onRerankStart: () => void;
   onRerankEnd: () => void;
+  experimental_onDecideStart: (event: any) => void;
+  experimental_onDecideEnd: (event: any) => void;
   onEnd: (event: any) => void;
   onError: (event: any) => void;
   onAbort: (event: any) => void;
@@ -22564,7 +23042,7 @@ declare class LaminarAiSdkTelemetry {
  * });
  * ```
  */
-declare const aiSdkTelemetry: (options?: LaminarAiSdkTelemetryOptions) => LaminarAiSdkTelemetry;
+export declare const aiSdkTelemetry: (options?: LaminarAiSdkTelemetryOptions) => LaminarAiSdkTelemetry;
 /**
  * Registers a Laminar `Telemetry` integration as a global receiver for every
  * AI SDK v7 call that has telemetry enabled.
@@ -22574,7 +23052,7 @@ declare const aiSdkTelemetry: (options?: LaminarAiSdkTelemetryOptions) => Lamina
  * of `ai` — callers often want to register telemetry before the first
  * provider call and must not pay the cost of eagerly loading the AI SDK.
  */
-declare const registerAiSdkTelemetry: (options?: LaminarAiSdkTelemetryOptions) => LaminarAiSdkTelemetry;
+export declare const registerAiSdkTelemetry: (options?: LaminarAiSdkTelemetryOptions) => LaminarAiSdkTelemetry;
 /**
  * Subscribes a pino-style logger to AI SDK v7's `diagnostics_channel`, which
  * fires every lifecycle event as `{ type, event }`. Use this for debugging
@@ -22582,7 +23060,7 @@ declare const registerAiSdkTelemetry: (options?: LaminarAiSdkTelemetryOptions) =
  *
  * Returns an unsubscribe function.
  */
-declare const enableAiSdkTelemetryDebug: (log?: (entry: {
+export declare const enableAiSdkTelemetryDebug: (log?: (entry: {
   type: string;
   event: unknown;
 }) => void) => (() => void);
@@ -22595,7 +23073,7 @@ declare const enableAiSdkTelemetryDebug: (log?: (entry: {
  * @param originalQuery - The original query function from claude-agent-sdk
  * @returns The instrumented query function
  */
-declare function instrumentClaudeAgentQuery(originalQuery: any): any;
+export declare function instrumentClaudeAgentQuery(originalQuery: any): any;
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/mastra/types.d.ts
 interface MastraSpanErrorInfo {
@@ -22668,7 +23146,7 @@ interface MastraExporterOptions {
  * `ai.response.toolCalls` so Laminar's backend parser threads them into
  * the LLM message history view.
  */
-declare class MastraExporter {
+export declare class MastraExporter {
   readonly name = "laminar";
   private readonly config;
   private readonly traceMap;
@@ -22841,7 +23319,7 @@ declare const ActivityInterceptorFactory: (options?: LaminarTemporalInterceptorO
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/temporal/index.d.ts
 /** Namespace export: `LaminarTemporalInterceptors.WorkflowClientInterceptor`. */
-declare const LaminarTemporalInterceptors: {
+export declare const LaminarTemporalInterceptors: {
   WorkflowClientInterceptor: typeof WorkflowClientInterceptor;
   ScheduleClientInterceptor: typeof ScheduleClientInterceptor;
   ActivityClientInterceptor: typeof ActivityClientInterceptor;
@@ -22875,7 +23353,7 @@ declare const TRACEPARENT_HEADER = "traceparent";
  * otherwise returns the global tracer provider.
  * @returns The tracer provider.
  */
-declare const getTracerProvider: () => TracerProvider;
+export declare const getTracerProvider: () => TracerProvider;
 /**
  * Get the tracer.
  * @returns Laminar's tracer if Laminar is initialized,
@@ -22900,7 +23378,7 @@ declare const getTracerProvider: () => TracerProvider;
  *   }
  * })
  */
-declare const getTracer: () => Tracer;
+export declare const getTracer: () => Tracer;
 //#endregion
 //#region src/opentelemetry-lib/tracing/instrumentations.d.ts
 /**
@@ -22927,7 +23405,7 @@ declare const getTracer: () => Tracer;
  * to enable them and register them with the OpenTelemetry SDK. For example, you could use
  * registerInstrumentations from the opentelemetry-api to register them.
  */
-declare const initializeLaminarInstrumentations: (options?: {
+export declare const initializeLaminarInstrumentations: (options?: {
   baseUrl?: string;
   apiKey?: string;
   httpPort?: number;
@@ -22936,5 +23414,5 @@ declare const initializeLaminarInstrumentations: (options?: {
   sessionRecordingOptions?: SessionRecordingOptions;
 }) => Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>[];
 //#endregion
-export { AI_SDK_TELEMETRY_DIAGNOSTIC_CHANNEL, type Datapoint, EvaluationDataset as Dataset, type Dataset as DatasetType, type EvalReporter, type EvaluationDatapoint, type EvaluationDatapointDatasetLink, type EvaluatorFunction, type EvaluatorFunctionReturn, type EveAssertionResult, type EveAssertionSeverity, type EveEval, type EveEvalDerivedFacts, type EveEvalResult, type EveEvalRunSummary, type EveEvalTarget, type EveEvalTaskResult, type EveEvalToolCall, type EveEvalVerdict, type EveRuntimeIdentity, type Event, HumanEvaluator, LAMINAR_SPAN_CONTEXT_HEADER as LAMINAR_TEMPORAL_SPAN_CONTEXT_HEADER, TRACEPARENT_HEADER as LAMINAR_TEMPORAL_TRACEPARENT_HEADER, Laminar, LaminarAiSdkTelemetry, type LaminarAiSdkTelemetryOptions, LaminarAttributes, LaminarClient, LaminarDataset, type LaminarInitializeProps, LaminarReporter, type LaminarReporterOptions, type LaminarSpanContext, LaminarSpanProcessor, ActivityClientInterceptor as LaminarTemporalActivityClientInterceptor, ActivityInterceptorFactory as LaminarTemporalActivityInterceptorFactory, LaminarTemporalInterceptors, ScheduleClientInterceptor as LaminarTemporalScheduleClientInterceptor, WorkflowClientInterceptor as LaminarTemporalWorkflowClientInterceptor, type MaskInputOptions, MastraExporter, type MastraExporterOptions, type PushDatapointsResponse, type SessionRecordingOptions, type Span, TracingLevel, aiSdkTelemetry, enableAiSdkTelemetryDebug, evaluate, getTracer, getTracerProvider, initializeLaminarInstrumentations, instrumentClaudeAgentQuery, observe, observeDecorator, observeExperimentalDecorator, registerAiSdkTelemetry, withTracingLevel, wrapAISDK, wrapLanguageModel };
+export { type Datapoint, EvaluationDataset as Dataset, type Dataset as DatasetType, type EvalReporter, type EvaluationDatapoint, type EvaluationDatapointDatasetLink, type EvaluatorFunction, type EvaluatorFunctionReturn, type EveAssertionResult, type EveAssertionSeverity, type EveEval, type EveEvalDerivedFacts, type EveEvalResult, type EveEvalRunSummary, type EveEvalTarget, type EveEvalTaskResult, type EveEvalToolCall, type EveEvalVerdict, type EveRuntimeIdentity, type Event, HumanEvaluator, LAMINAR_SPAN_CONTEXT_HEADER as LAMINAR_TEMPORAL_SPAN_CONTEXT_HEADER, TRACEPARENT_HEADER as LAMINAR_TEMPORAL_TRACEPARENT_HEADER, type LaminarAiSdkTelemetryOptions, LaminarClient, LaminarDataset, type LaminarInitializeProps, type LaminarReporterOptions, type LaminarSpanContext, ActivityClientInterceptor as LaminarTemporalActivityClientInterceptor, ActivityInterceptorFactory as LaminarTemporalActivityInterceptorFactory, ScheduleClientInterceptor as LaminarTemporalScheduleClientInterceptor, WorkflowClientInterceptor as LaminarTemporalWorkflowClientInterceptor, type MaskInputOptions, type MastraExporterOptions, type PushDatapointsResponse, type SessionRecordingOptions, type Span, TracingLevel, evaluate };
 //# sourceMappingURL=index.d.cts.map