ai 6.0.24 → 6.0.25

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import { GatewayModelId } from '@ai-sdk/gateway';
 export { GatewayModelId, createGateway, gateway } from '@ai-sdk/gateway';
 import * as _ai_sdk_provider_utils from '@ai-sdk/provider-utils';
-import { Tool, InferToolInput, InferToolOutput, FlexibleSchema, InferSchema, AssistantModelMessage, ToolModelMessage, ReasoningPart, SystemModelMessage, ModelMessage, ProviderOptions, UserModelMessage, IdGenerator, ToolCall, MaybePromiseLike, TextPart, FilePart, Resolvable, FetchFunction, DataContent } from '@ai-sdk/provider-utils';
+import { Tool, InferToolInput, InferToolOutput, FlexibleSchema, InferSchema, SystemModelMessage, ModelMessage, AssistantModelMessage, ToolModelMessage, ReasoningPart, ProviderOptions, UserModelMessage, IdGenerator, ToolCall, MaybePromiseLike, TextPart, FilePart, Resolvable, FetchFunction, DataContent } from '@ai-sdk/provider-utils';
 export { AssistantContent, AssistantModelMessage, DataContent, DownloadError, FilePart, FlexibleSchema, IdGenerator, ImagePart, InferSchema, InferToolInput, InferToolOutput, ModelMessage, Schema, SystemModelMessage, TextPart, Tool, ToolApprovalRequest, ToolApprovalResponse, ToolCallOptions, ToolCallPart, ToolContent, ToolExecuteFunction, ToolExecutionOptions, ToolModelMessage, ToolResultPart, UserContent, UserModelMessage, asSchema, createIdGenerator, dynamicTool, generateId, jsonSchema, parseJsonEventStream, tool, zodSchema } from '@ai-sdk/provider-utils';
 import * as _ai_sdk_provider from '@ai-sdk/provider';
-import { EmbeddingModelV3, EmbeddingModelV2, EmbeddingModelV3Embedding, EmbeddingModelV3Middleware, ImageModelV3, ImageModelV2, ImageModelV3ProviderMetadata, ImageModelV2ProviderMetadata, ImageModelV3Middleware, JSONValue as JSONValue$1, LanguageModelV3, LanguageModelV2, SharedV3Warning, LanguageModelV3Source, LanguageModelV3Middleware, RerankingModelV3, SharedV3ProviderMetadata, SpeechModelV3, SpeechModelV2, TranscriptionModelV3, TranscriptionModelV2, JSONObject, ImageModelV3Usage, LanguageModelV3CallOptions, AISDKError, LanguageModelV3ToolCall, JSONSchema7, JSONParseError, TypeValidationError, EmbeddingModelV3CallOptions, ProviderV3, ProviderV2, NoSuchModelError } from '@ai-sdk/provider';
+import { EmbeddingModelV3, EmbeddingModelV2, EmbeddingModelV3Embedding, EmbeddingModelV3Middleware, ImageModelV3, ImageModelV2, ImageModelV3ProviderMetadata, ImageModelV2ProviderMetadata, ImageModelV3Middleware, JSONValue as JSONValue$1, LanguageModelV3, LanguageModelV2, SharedV3Warning, LanguageModelV3Source, LanguageModelV3Middleware, RerankingModelV3, SharedV3ProviderMetadata, SpeechModelV3, SpeechModelV2, TranscriptionModelV3, TranscriptionModelV2, JSONObject, ImageModelV3Usage, AISDKError, LanguageModelV3ToolCall, JSONSchema7, LanguageModelV3CallOptions, JSONParseError, TypeValidationError, EmbeddingModelV3CallOptions, ProviderV3, ProviderV2, NoSuchModelError } from '@ai-sdk/provider';
 export { AISDKError, APICallError, EmptyResponseBodyError, InvalidPromptError, InvalidResponseDataError, JSONParseError, JSONSchema7, LoadAPIKeyError, LoadSettingError, NoContentGeneratedError, NoSuchModelError, TooManyEmbeddingValuesForCallError, TypeValidationError, UnsupportedFunctionalityError } from '@ai-sdk/provider';
 import { AttributeValue, Tracer } from '@opentelemetry/api';
 import { ServerResponse } from 'node:http';
@@ -569,188 +569,228 @@ type PartialObject<ObjectType extends object> = {
     [KeyType in keyof ObjectType]?: DeepPartialInternal<ObjectType[KeyType]>;
 };
 
-interface Output<OUTPUT = any, PARTIAL = any> {
+/**
+Timeout configuration for API calls. Can be specified as:
+- A number representing milliseconds
+- An object with `totalMs` property for the total timeout in milliseconds
+- An object with `stepMs` property for the timeout of each step in milliseconds
+- An object with `chunkMs` property for the timeout between stream chunks (streaming only)
+ */
+type TimeoutConfiguration = number | {
+    totalMs?: number;
+    stepMs?: number;
+    chunkMs?: number;
+};
+type CallSettings = {
     /**
-     * The response format to use for the model.
+  Maximum number of tokens to generate.
      */
-    responseFormat: PromiseLike<LanguageModelV3CallOptions['responseFormat']>;
+    maxOutputTokens?: number;
     /**
-     * Parses the complete output of the model.
+  Temperature setting. The range depends on the provider and model.
+  
+  It is recommended to set either `temperature` or `topP`, but not both.
      */
-    parseCompleteOutput(options: {
-        text: string;
-    }, context: {
-        response: LanguageModelResponseMetadata;
-        usage: LanguageModelUsage;
-        finishReason: FinishReason;
-    }): Promise<OUTPUT>;
+    temperature?: number;
     /**
-     * Parses the partial output of the model.
+  Nucleus sampling. This is a number between 0 and 1.
+  
+  E.g. 0.1 would mean that only tokens with the top 10% probability mass
+  are considered.
+  
+  It is recommended to set either `temperature` or `topP`, but not both.
      */
-    parsePartialOutput(options: {
-        text: string;
-    }): Promise<{
-        partial: PARTIAL;
-    } | undefined>;
-}
-/**
- * Output specification for text generation.
- * This is the default output mode that generates plain text.
- *
- * @returns An output specification for generating text.
- */
-declare const text: () => Output<string, string>;
-/**
- * Output specification for typed object generation using schemas.
- * When the model generates a text response, it will return an object that matches the schema.
- *
- * @param schema - The schema of the object to generate.
- * @param name - Optional name of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema name.
- * @param description - Optional description of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema description.
- *
- * @returns An output specification for generating objects with the specified schema.
- */
-declare const object: <OBJECT>({ schema: inputSchema, name, description, }: {
-    schema: FlexibleSchema<OBJECT>;
+    topP?: number;
     /**
-     * Optional name of the output that should be generated.
-     * Used by some providers for additional LLM guidance, e.g. via tool or schema name.
+  Only sample from the top K options for each subsequent token.
+  
+  Used to remove "long tail" low probability responses.
+  Recommended for advanced use cases only. You usually only need to use temperature.
      */
-    name?: string;
+    topK?: number;
     /**
-     * Optional description of the output that should be generated.
-     * Used by some providers for additional LLM guidance, e.g. via tool or schema description.
+  Presence penalty setting. It affects the likelihood of the model to
+  repeat information that is already in the prompt.
+  
+  The presence penalty is a number between -1 (increase repetition)
+  and 1 (maximum penalty, decrease repetition). 0 means no penalty.
      */
-    description?: string;
-}) => Output<OBJECT, DeepPartial<OBJECT>>;
-/**
- * Output specification for array generation.
- * When the model generates a text response, it will return an array of elements.
- *
- * @param element - The schema of the array elements to generate.
- * @param name - Optional name of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema name.
- * @param description - Optional description of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema description.
- *
- * @returns An output specification for generating an array of elements.
- */
-declare const array: <ELEMENT>({ element: inputElementSchema, name, description, }: {
-    element: FlexibleSchema<ELEMENT>;
+    presencePenalty?: number;
     /**
-     * Optional name of the output that should be generated.
-     * Used by some providers for additional LLM guidance, e.g. via tool or schema name.
+  Frequency penalty setting. It affects the likelihood of the model
+  to repeatedly use the same words or phrases.
+  
+  The frequency penalty is a number between -1 (increase repetition)
+  and 1 (maximum penalty, decrease repetition). 0 means no penalty.
      */
-    name?: string;
+    frequencyPenalty?: number;
     /**
-     * Optional description of the output that should be generated.
-     * Used by some providers for additional LLM guidance, e.g. via tool or schema description.
+  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.
      */
-    description?: string;
-}) => Output<Array<ELEMENT>, Array<ELEMENT>>;
-/**
- * Output specification for choice generation.
- * When the model generates a text response, it will return a one of the choice options.
- *
- * @param options - The available choices.
- * @param name - Optional name of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema name.
- * @param description - Optional description of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema description.
- *
- * @returns An output specification for generating a choice.
- */
-declare const choice: <CHOICE extends string>({ options: choiceOptions, name, description, }: {
-    options: Array<CHOICE>;
+    stopSequences?: string[];
     /**
-     * Optional name of the output that should be generated.
-     * Used by some providers for additional LLM guidance, e.g. via tool or schema name.
+  The seed (integer) to use for random sampling. If set and supported
+  by the model, calls will generate deterministic results.
      */
-    name?: string;
+    seed?: number;
     /**
-     * Optional description of the output that should be generated.
-     * Used by some providers for additional LLM guidance, e.g. via tool or schema description.
+  Maximum number of retries. Set to 0 to disable retries.
+  
+  @default 2
      */
-    description?: string;
-}) => Output<CHOICE, CHOICE>;
-/**
- * Output specification for unstructured JSON generation.
- * When the model generates a text response, it will return a JSON object.
- *
- * @param name - Optional name of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema name.
- * @param description - Optional description of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema description.
- *
- * @returns An output specification for generating JSON.
- */
-declare const json: ({ name, description, }?: {
+    maxRetries?: number;
     /**
-     * Optional name of the output that should be generated.
-     * Used by some providers for additional LLM guidance, e.g. via tool or schema name.
+  Abort signal.
      */
-    name?: string;
+    abortSignal?: AbortSignal;
     /**
-     * Optional description of the output that should be generated.
-     * Used by some providers for additional LLM guidance, e.g. via tool or schema description.
+  Timeout in milliseconds. The call will be aborted if it takes longer
+  than the specified timeout. Can be used alongside abortSignal.
+  
+  Can be specified as a number (milliseconds) or as an object with `totalMs`.
      */
-    description?: string;
-}) => Output<JSONValue$1, JSONValue$1>;
-
-type output_Output<OUTPUT = any, PARTIAL = any> = Output<OUTPUT, PARTIAL>;
-declare const output_array: typeof array;
-declare const output_choice: typeof choice;
-declare const output_json: typeof json;
-declare const output_object: typeof object;
-declare const output_text: typeof text;
-declare namespace output {
-  export {
-    output_Output as Output,
-    output_array as array,
-    output_choice as choice,
-    output_json as json,
-    output_object as object,
-    output_text as text,
-  };
-}
+    timeout?: TimeoutConfiguration;
+    /**
+  Additional HTTP headers to be sent with the request.
+  Only applicable for HTTP-based providers.
+     */
+    headers?: Record<string, string | undefined>;
+};
 
 /**
- * Infers the complete output type from the output specification.
+Prompt part of the AI function options.
+It contains a system message, a simple text prompt, or a list of messages.
  */
-type InferCompleteOutput<OUTPUT extends Output> = OUTPUT extends Output<infer COMPLETE_OUTPUT, any> ? COMPLETE_OUTPUT : never;
-/**
- * Infers the partial output type from the output specification.
+type Prompt = {
+    /**
+  System message to include in the prompt. Can be used with `prompt` or `messages`.
+     */
+    system?: string | SystemModelMessage | Array<SystemModelMessage>;
+} & ({
+    /**
+A prompt. It can be either a text prompt or a list of messages.
+
+You can either use `prompt` or `messages` but not both.
+*/
+    prompt: string | Array<ModelMessage>;
+    /**
+A list of messages.
+
+You can either use `prompt` or `messages` but not both.
  */
-type InferPartialOutput<OUTPUT extends Output> = OUTPUT extends Output<any, infer PARTIAL_OUTPUT> ? PARTIAL_OUTPUT : never;
+    messages?: never;
+} | {
+    /**
+A list of messages.
 
-/**
-A message that was generated during the generation process.
-It can be either an assistant message or a tool message.
+You can either use `prompt` or `messages` but not both.
  */
-type ResponseMessage = AssistantModelMessage | ToolModelMessage;
+    messages: Array<ModelMessage>;
+    /**
+A prompt. It can be either a text prompt or a list of messages.
+
+You can either use `prompt` or `messages` but not both.
+*/
+    prompt?: never;
+});
 
 /**
- * The result of a single step in the generation process.
+ * Telemetry configuration.
  */
-type StepResult<TOOLS extends ToolSet> = {
+type TelemetrySettings = {
     /**
-  The content that was generated in the last step.
+     * Enable or disable telemetry. Disabled by default while experimental.
      */
-    readonly content: Array<ContentPart<TOOLS>>;
-    /**
-  The generated text.
-  */
-    readonly text: string;
+    isEnabled?: boolean;
     /**
-  The reasoning that was generated during the generation.
-  */
-    readonly reasoning: Array<ReasoningPart>;
+     * Enable or disable input recording. Enabled by default.
+     *
+     * You might want to disable input recording to avoid recording sensitive
+     * information, to reduce data transfers, or to increase performance.
+     */
+    recordInputs?: boolean;
     /**
-  The reasoning text that was generated during the generation.
-  */
-    readonly reasoningText: string | undefined;
+     * Enable or disable output recording. Enabled by default.
+     *
+     * You might want to disable output recording to avoid recording sensitive
+     * information, to reduce data transfers, or to increase performance.
+     */
+    recordOutputs?: boolean;
     /**
-  The files that were generated during the generation.
-  */
-    readonly files: Array<GeneratedFile>;
+     * Identifier for this function. Used to group telemetry data by function.
+     */
+    functionId?: string;
     /**
-  The sources that were used to generate the text.
-  */
-    readonly sources: Array<Source>;
+     * Additional information to include in the telemetry data.
+     */
+    metadata?: Record<string, AttributeValue>;
+    /**
+     * A custom tracer to use for the telemetry data.
+     */
+    tracer?: Tracer;
+};
+
+/**
+ * Experimental. Can change in patch versions without warning.
+ *
+ * Download function. Called with the array of URLs and a boolean indicating
+ * whether the URL is supported by the model.
+ *
+ * The download function can decide for each URL:
+ * - to return null (which means that the URL should be passed to the model)
+ * - to download the asset and return the data (incl. retries, authentication, etc.)
+ *
+ * Should throw DownloadError if the download fails.
+ *
+ * Should return an array of objects sorted by the order of the requested downloads.
+ * For each object, the data should be a Uint8Array if the URL was downloaded.
+ * For each object, the mediaType should be the media type of the downloaded asset.
+ * For each object, the data should be null if the URL should be passed through as is.
+ */
+type DownloadFunction = (options: Array<{
+    url: URL;
+    isUrlSupportedByModel: boolean;
+}>) => PromiseLike<Array<{
+    data: Uint8Array;
+    mediaType: string | undefined;
+} | null>>;
+
+/**
+A message that was generated during the generation process.
+It can be either an assistant message or a tool message.
+ */
+type ResponseMessage = AssistantModelMessage | ToolModelMessage;
+
+/**
+ * The result of a single step in the generation process.
+ */
+type StepResult<TOOLS extends ToolSet> = {
+    /**
+  The content that was generated in the last step.
+     */
+    readonly content: Array<ContentPart<TOOLS>>;
+    /**
+  The generated text.
+  */
+    readonly text: string;
+    /**
+  The reasoning that was generated during the generation.
+  */
+    readonly reasoning: Array<ReasoningPart>;
+    /**
+  The reasoning text that was generated during the generation.
+  */
+    readonly reasoningText: string | undefined;
+    /**
+  The files that were generated during the generation.
+  */
+    readonly files: Array<GeneratedFile>;
+    /**
+  The sources that were used to generate the text.
+  */
+    readonly sources: Array<Source>;
     /**
   The tool calls that were made during the generation.
   */
@@ -819,1954 +859,1935 @@ type StepResult<TOOLS extends ToolSet> = {
 };
 
 /**
-The result of a `generateText` call.
-It contains the generated text, the tool calls that were made during the generation, and the results of the tool calls.
+ * Function that you can use to provide different settings for a step.
+ *
+ * @param options - The options for the step.
+ * @param options.steps - The steps that have been executed so far.
+ * @param options.stepNumber - The number of the step that is being executed.
+ * @param options.model - The model that is being used.
+ * @param options.messages - The messages that will be sent to the model for the current step.
+ * @param options.experimental_context - The context passed via the experimental_context setting (experimental).
+ *
+ * @returns An object that contains the settings for the step.
+ * If you return undefined (or for undefined settings), the settings from the outer level will be used.
  */
-interface GenerateTextResult<TOOLS extends ToolSet, OUTPUT extends Output> {
+type PrepareStepFunction<TOOLS extends Record<string, Tool> = Record<string, Tool>> = (options: {
     /**
-  The content that was generated in the last step.
+     * The steps that have been executed so far.
      */
-    readonly content: Array<ContentPart<TOOLS>>;
-    /**
-  The text that was generated in the last step.
-       */
-    readonly text: string;
+    steps: Array<StepResult<NoInfer<TOOLS>>>;
     /**
-  The full reasoning that the model has generated in the last step.
+     * The number of the step that is being executed.
      */
-    readonly reasoning: Array<ReasoningOutput>;
+    stepNumber: number;
     /**
-  The reasoning text that the model has generated in the last step. Can be undefined if the model
-  has only generated text.
+     * The model instance that is being used for this step.
      */
-    readonly reasoningText: string | undefined;
-    /**
-  The files that were generated in the last step.
-  Empty array if no files were generated.
-       */
-    readonly files: Array<GeneratedFile>;
+    model: LanguageModel;
     /**
-  Sources that have been used as references in the last step.
+     * The messages that will be sent to the model for the current step.
      */
-    readonly sources: Array<Source>;
+    messages: Array<ModelMessage>;
     /**
-  The tool calls that were made in the last step.
+     * The context passed via the experimental_context setting (experimental).
      */
-    readonly toolCalls: Array<TypedToolCall<TOOLS>>;
+    experimental_context: unknown;
+}) => PromiseLike<PrepareStepResult<TOOLS>> | PrepareStepResult<TOOLS>;
+/**
+ * The result type returned by a {@link PrepareStepFunction},
+ * allowing per-step overrides of model, tools, or messages.
+ */
+type PrepareStepResult<TOOLS extends Record<string, Tool> = Record<string, Tool>> = {
     /**
-  The static tool calls that were made in the last step.
+     * Optionally override which LanguageModel instance is used for this step.
      */
-    readonly staticToolCalls: Array<StaticToolCall<TOOLS>>;
+    model?: LanguageModel;
     /**
-  The dynamic tool calls that were made in the last step.
+     * Optionally set which tool the model must call, or provide tool call configuration
+     * for this step.
      */
-    readonly dynamicToolCalls: Array<DynamicToolCall>;
+    toolChoice?: ToolChoice<NoInfer<TOOLS>>;
     /**
-  The results of the tool calls from the last step.
+     * If provided, only these tools are enabled/available for this step.
      */
-    readonly toolResults: Array<TypedToolResult<TOOLS>>;
+    activeTools?: Array<keyof NoInfer<TOOLS>>;
     /**
-  The static tool results that were made in the last step.
+     * Optionally override the system message(s) sent to the model for this step.
      */
-    readonly staticToolResults: Array<StaticToolResult<TOOLS>>;
+    system?: string | SystemModelMessage | Array<SystemModelMessage>;
     /**
-  The dynamic tool results that were made in the last step.
+     * Optionally override the full set of messages sent to the model
+     * for this step.
      */
-    readonly dynamicToolResults: Array<DynamicToolResult>;
+    messages?: Array<ModelMessage>;
     /**
-     * The unified reason why the generation finished.
+     * Context that is passed into tool execution. Experimental.
+     *
+     * Changing the context will affect the context in this step
+     * and all subsequent steps.
      */
-    readonly finishReason: FinishReason;
+    experimental_context?: unknown;
     /**
-     * The raw reason why the generation finished (from the provider).
+     * Additional provider-specific options for this step.
+     *
+     * Can be used to pass provider-specific configuration such as
+     * container IDs for Anthropic's code execution.
      */
-    readonly rawFinishReason: string | undefined;
+    providerOptions?: ProviderOptions;
+} | undefined;
+
+type StopCondition<TOOLS extends ToolSet> = (options: {
+    steps: Array<StepResult<TOOLS>>;
+}) => PromiseLike<boolean> | boolean;
+declare function stepCountIs(stepCount: number): StopCondition<any>;
+declare function hasToolCall(toolName: string): StopCondition<any>;
+
+declare const symbol$e: unique symbol;
+declare class InvalidToolInputError extends AISDKError {
+    private readonly [symbol$e];
+    readonly toolName: string;
+    readonly toolInput: string;
+    constructor({ toolInput, toolName, cause, message, }: {
+        message?: string;
+        toolInput: string;
+        toolName: string;
+        cause: unknown;
+    });
+    static isInstance(error: unknown): error is InvalidToolInputError;
+}
+
+declare const symbol$d: unique symbol;
+declare class NoSuchToolError extends AISDKError {
+    private readonly [symbol$d];
+    readonly toolName: string;
+    readonly availableTools: string[] | undefined;
+    constructor({ toolName, availableTools, message, }: {
+        toolName: string;
+        availableTools?: string[] | undefined;
+        message?: string;
+    });
+    static isInstance(error: unknown): error is NoSuchToolError;
+}
+
+declare const systemModelMessageSchema: z.ZodType<SystemModelMessage>;
+declare const userModelMessageSchema: z.ZodType<UserModelMessage>;
+declare const assistantModelMessageSchema: z.ZodType<AssistantModelMessage>;
+declare const toolModelMessageSchema: z.ZodType<ToolModelMessage>;
+declare const modelMessageSchema: z.ZodType<ModelMessage>;
+
+/**
+ * A function that attempts to repair a tool call that failed to parse.
+ *
+ * It receives the error and the context as arguments and returns the repair
+ * tool call JSON as text.
+ *
+ * @param options.system - The system prompt.
+ * @param options.messages - The messages in the current generation step.
+ * @param options.toolCall - The tool call that failed to parse.
+ * @param options.tools - The tools that are available.
+ * @param options.inputSchema - A function that returns the JSON Schema for a tool.
+ * @param options.error - The error that occurred while parsing the tool call.
+ */
+type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
+    system: string | SystemModelMessage | Array<SystemModelMessage> | undefined;
+    messages: ModelMessage[];
+    toolCall: LanguageModelV3ToolCall;
+    tools: TOOLS;
+    inputSchema: (options: {
+        toolName: string;
+    }) => PromiseLike<JSONSchema7>;
+    error: NoSuchToolError | InvalidToolInputError;
+}) => Promise<LanguageModelV3ToolCall | null>;
+
+/**
+Callback that is set using the `onStepFinish` option.
+
+@param stepResult - The result of the step.
+ */
+type GenerateTextOnStepFinishCallback<TOOLS extends ToolSet> = (stepResult: StepResult<TOOLS>) => Promise<void> | void;
+/**
+Callback that is set using the `onFinish` option.
+
+@param event - The event that is passed to the callback.
+ */
+type GenerateTextOnFinishCallback<TOOLS extends ToolSet> = (event: StepResult<TOOLS> & {
     /**
-  The token usage of the last step.
+     * Details for all steps.
      */
-    readonly usage: LanguageModelUsage;
+    readonly steps: StepResult<TOOLS>[];
     /**
-  The total token usage of all steps.
-  When there are multiple steps, the usage is the sum of all step usages.
+     * Total usage for all steps. This is the sum of the usage of all steps.
      */
     readonly totalUsage: LanguageModelUsage;
     /**
-  Warnings from the model provider (e.g. unsupported settings)
-     */
-    readonly warnings: CallWarning[] | undefined;
-    /**
-  Additional request information.
-     */
-    readonly request: LanguageModelRequestMetadata;
-    /**
-  Additional response information.
+     * Context that is passed into tool execution.
+     *
+     * Experimental (can break in patch releases).
+     *
+     * @default undefined
      */
-    readonly response: LanguageModelResponseMetadata & {
-        /**
-    The response messages that were generated during the call. It consists of an assistant message,
-    potentially containing tool calls.
-    
-    When there are tool results, there is an additional tool message with the tool results that are available.
-    If there are tools that do not have execute functions, they are not included in the tool results and
-    need to be added separately.
-           */
-        messages: Array<ResponseMessage>;
-        /**
-    Response body (available only for providers that use HTTP requests).
-         */
-        body?: unknown;
-    };
+    experimental_context: unknown;
+}) => PromiseLike<void> | void;
+/**
+Generate a text and call tools for a given prompt using a language model.
+
+This function does not stream the output. If you want to stream the output, use `streamText` instead.
+
+@param model - The language model to use.
+
+@param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
+@param toolChoice - The tool choice strategy. Default: 'auto'.
+
+@param system - A system message that will be part of the prompt.
+@param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
+@param messages - A list of messages. You can either use `prompt` or `messages` but not both.
+
+@param maxOutputTokens - Maximum number of tokens to generate.
+@param temperature - Temperature setting.
+The value is passed through to the provider. The range depends on the provider and model.
+It is recommended to set either `temperature` or `topP`, but not both.
+@param topP - Nucleus sampling.
+The value is passed through to the provider. The range depends on the provider and model.
+It is recommended to set either `temperature` or `topP`, but not both.
+@param topK - Only sample from the top K options for each subsequent token.
+Used to remove "long tail" low probability responses.
+Recommended for advanced use cases only. You usually only need to use temperature.
+@param presencePenalty - Presence penalty setting.
+It affects the likelihood of the model to repeat information that is already in the prompt.
+The value is passed through to the provider. The range depends on the provider and model.
+@param frequencyPenalty - Frequency penalty setting.
+It affects the likelihood of the model to repeatedly use the same words or phrases.
+The value is passed through to the provider. The range depends on the provider and model.
+@param stopSequences - Stop sequences.
+If set, the model will stop generating text when one of the stop sequences is generated.
+@param seed - The seed (integer) to use for random sampling.
+If set and supported by the model, calls will generate deterministic results.
+
+@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+@param abortSignal - An optional abort signal that can be used to cancel the call.
+@param timeout - An optional timeout in milliseconds. The call will be aborted if it takes longer than the specified timeout.
+@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+
+@param experimental_generateMessageId - Generate a unique ID for each message.
+
+@param onStepFinish - Callback that is called when each step (LLM call) is finished, including intermediate steps.
+@param onFinish - Callback that is called when all steps are finished and the response is complete.
+
+@returns
+A result object that contains the generated text, the results of the tool calls, and additional information.
+ */
+declare function generateText<TOOLS extends ToolSet, OUTPUT extends Output = Output<string, string>>({ model: modelArg, tools, toolChoice, system, prompt, messages, maxRetries: maxRetriesArg, abortSignal, timeout, headers, stopWhen, experimental_output, output, experimental_telemetry: telemetry, providerOptions, experimental_activeTools, activeTools, experimental_prepareStep, prepareStep, experimental_repairToolCall: repairToolCall, experimental_download: download, experimental_context, _internal: { generateId }, onStepFinish, onFinish, ...settings }: CallSettings & Prompt & {
     /**
-  Additional provider-specific metadata. They are passed through
-  from the provider to the AI SDK and enable provider-specific
-  results that can be fully encapsulated in the provider.
+The language model to use.
      */
-    readonly providerMetadata: ProviderMetadata | undefined;
+    model: LanguageModel;
     /**
-  Details for all steps.
-  You can use this to get information about intermediate steps,
-  such as the tool calls or the response headers.
+The tools that the model can call. The model needs to support calling tools.
+*/
+    tools?: TOOLS;
+    /**
+The tool choice strategy. Default: 'auto'.
      */
-    readonly steps: Array<StepResult<TOOLS>>;
+    toolChoice?: ToolChoice<NoInfer<TOOLS>>;
     /**
-  The generated structured output. It uses the `output` specification.
-  
-  @deprecated Use `output` instead.
+Condition for stopping the generation when there are tool results in the last step.
+When the condition is an array, any of the conditions can be met to stop the generation.
+
+@default stepCountIs(1)
      */
-    readonly experimental_output: InferCompleteOutput<OUTPUT>;
+    stopWhen?: StopCondition<NoInfer<TOOLS>> | Array<StopCondition<NoInfer<TOOLS>>>;
     /**
-  The generated structured output. It uses the `output` specification.
-  
+Optional telemetry configuration (experimental).
      */
-    readonly output: InferCompleteOutput<OUTPUT>;
-}
-
-/**
-Timeout configuration for API calls. Can be specified as:
-- A number representing milliseconds
-- An object with `totalMs` property for the total timeout in milliseconds
-- An object with `stepMs` property for the timeout of each step in milliseconds
-- An object with `chunkMs` property for the timeout between stream chunks (streaming only)
+    experimental_telemetry?: TelemetrySettings;
+    /**
+Additional provider-specific options. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
  */
-type TimeoutConfiguration = number | {
-    totalMs?: number;
-    stepMs?: number;
-    chunkMs?: number;
-};
-type CallSettings = {
+    providerOptions?: ProviderOptions;
     /**
-  Maximum number of tokens to generate.
+     * @deprecated Use `activeTools` instead.
      */
-    maxOutputTokens?: number;
+    experimental_activeTools?: Array<keyof NoInfer<TOOLS>>;
     /**
-  Temperature setting. The range depends on the provider and model.
-  
-  It is recommended to set either `temperature` or `topP`, but not both.
+Limits the tools that are available for the model to call without
+changing the tool call and result types in the result.
      */
-    temperature?: number;
+    activeTools?: Array<keyof NoInfer<TOOLS>>;
     /**
-  Nucleus sampling. This is a number between 0 and 1.
-  
-  E.g. 0.1 would mean that only tokens with the top 10% probability mass
-  are considered.
-  
-  It is recommended to set either `temperature` or `topP`, but not both.
+Optional specification for parsing structured outputs from the LLM response.
      */
-    topP?: number;
+    output?: OUTPUT;
     /**
-  Only sample from the top K options for each subsequent token.
-  
-  Used to remove "long tail" low probability responses.
-  Recommended for advanced use cases only. You usually only need to use temperature.
+Optional specification for parsing structured outputs from the LLM response.
+
+@deprecated Use `output` instead.
      */
-    topK?: number;
+    experimental_output?: OUTPUT;
     /**
-  Presence penalty setting. It affects the likelihood of the model to
-  repeat information that is already in the prompt.
-  
-  The presence penalty is a number between -1 (increase repetition)
-  and 1 (maximum penalty, decrease repetition). 0 means no penalty.
+Custom download function to use for URLs.
+
+By default, files are downloaded if the model does not support the URL for the given media type.
      */
-    presencePenalty?: number;
+    experimental_download?: DownloadFunction | undefined;
     /**
-  Frequency penalty setting. It affects the likelihood of the model
-  to repeatedly use the same words or phrases.
-  
-  The frequency penalty is a number between -1 (increase repetition)
-  and 1 (maximum penalty, decrease repetition). 0 means no penalty.
+     * @deprecated Use `prepareStep` instead.
      */
-    frequencyPenalty?: number;
+    experimental_prepareStep?: PrepareStepFunction<NoInfer<TOOLS>>;
     /**
-  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[];
+Optional function that you can use to provide different settings for a step.
+    */
+    prepareStep?: PrepareStepFunction<NoInfer<TOOLS>>;
     /**
-  The seed (integer) to use for random sampling. If set and supported
-  by the model, calls will generate deterministic results.
+A function that attempts to repair a tool call that failed to parse.
      */
-    seed?: number;
+    experimental_repairToolCall?: ToolCallRepairFunction<NoInfer<TOOLS>>;
     /**
-  Maximum number of retries. Set to 0 to disable retries.
-  
-  @default 2
+     * Callback that is called when each step (LLM call) is finished, including intermediate steps.
      */
-    maxRetries?: number;
+    onStepFinish?: GenerateTextOnStepFinishCallback<NoInfer<TOOLS>>;
     /**
-  Abort signal.
+     * Callback that is called when all steps are finished and the response is complete.
      */
-    abortSignal?: AbortSignal;
+    onFinish?: GenerateTextOnFinishCallback<NoInfer<TOOLS>>;
     /**
-  Timeout in milliseconds. The call will be aborted if it takes longer
-  than the specified timeout. Can be used alongside abortSignal.
-  
-  Can be specified as a number (milliseconds) or as an object with `totalMs`.
+     * Context that is passed into tool execution.
+     *
+     * Experimental (can break in patch releases).
+     *
+     * @default undefined
      */
-    timeout?: TimeoutConfiguration;
+    experimental_context?: unknown;
     /**
-  Additional HTTP headers to be sent with the request.
-  Only applicable for HTTP-based providers.
+     * Internal. For test use only. May change without notice.
      */
-    headers?: Record<string, string | undefined>;
-};
+    _internal?: {
+        generateId?: IdGenerator;
+    };
+}): Promise<GenerateTextResult<TOOLS, OUTPUT>>;
 
 /**
-Prompt part of the AI function options.
-It contains a system message, a simple text prompt, or a list of messages.
+ * Infers the complete output type from the output specification.
  */
-type Prompt = {
-    /**
-  System message to include in the prompt. Can be used with `prompt` or `messages`.
-     */
-    system?: string | SystemModelMessage | Array<SystemModelMessage>;
-} & ({
-    /**
-A prompt. It can be either a text prompt or a list of messages.
-
-You can either use `prompt` or `messages` but not both.
-*/
-    prompt: string | Array<ModelMessage>;
-    /**
-A list of messages.
-
-You can either use `prompt` or `messages` but not both.
+type InferCompleteOutput<OUTPUT extends Output> = OUTPUT extends Output<infer COMPLETE_OUTPUT, any, any> ? COMPLETE_OUTPUT : never;
+/**
+ * Infers the partial output type from the output specification.
  */
-    messages?: never;
-} | {
-    /**
-A list of messages.
-
-You can either use `prompt` or `messages` but not both.
+type InferPartialOutput<OUTPUT extends Output> = OUTPUT extends Output<any, infer PARTIAL_OUTPUT, any> ? PARTIAL_OUTPUT : never;
+/**
+ * Infers the element type from an array output specification.
  */
-    messages: Array<ModelMessage>;
-    /**
-A prompt. It can be either a text prompt or a list of messages.
-
-You can either use `prompt` or `messages` but not both.
-*/
-    prompt?: never;
-});
+type InferElementOutput<OUTPUT extends Output> = OUTPUT extends Output<any, any, infer ELEMENT> ? ELEMENT : never;
 
 /**
- * Telemetry configuration.
+ * Prunes model messages from a list of model messages.
+ *
+ * @param messages - The list of model messages to prune.
+ * @param reasoning - How to remove reasoning content from assistant messages. Default is `'none'`.
+ * @param toolCalls - How to prune tool call/results/approval content. Default is `[]`.
+ * @param emptyMessages - Whether to keep or remove messages whose content is empty after pruning. Default is `'remove'`.
+ *
+ * @returns The pruned list of model messages.
  */
-type TelemetrySettings = {
-    /**
-     * Enable or disable telemetry. Disabled by default while experimental.
-     */
-    isEnabled?: boolean;
-    /**
-     * Enable or disable input recording. Enabled by default.
-     *
-     * You might want to disable input recording to avoid recording sensitive
-     * information, to reduce data transfers, or to increase performance.
-     */
-    recordInputs?: boolean;
-    /**
-     * Enable or disable output recording. Enabled by default.
-     *
-     * You might want to disable output recording to avoid recording sensitive
-     * information, to reduce data transfers, or to increase performance.
-     */
-    recordOutputs?: boolean;
-    /**
-     * Identifier for this function. Used to group telemetry data by function.
-     */
-    functionId?: string;
-    /**
-     * Additional information to include in the telemetry data.
-     */
-    metadata?: Record<string, AttributeValue>;
-    /**
-     * A custom tracer to use for the telemetry data.
-     */
-    tracer?: Tracer;
-};
+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<{
+        type: 'all' | 'before-last-message' | `before-last-${number}-messages`;
+        tools?: string[];
+    }>;
+    emptyMessages?: 'keep' | 'remove';
+}): ModelMessage[];
 
 /**
- * Experimental. Can change in patch versions without warning.
- *
- * Download function. Called with the array of URLs and a boolean indicating
- * whether the URL is supported by the model.
- *
- * The download function can decide for each URL:
- * - to return null (which means that the URL should be passed to the model)
- * - to download the asset and return the data (incl. retries, authentication, etc.)
+ * Detects the first chunk in a buffer.
  *
- * Should throw DownloadError if the download fails.
+ * @param buffer - The buffer to detect the first chunk in.
  *
- * Should return an array of objects sorted by the order of the requested downloads.
- * For each object, the data should be a Uint8Array if the URL was downloaded.
- * For each object, the mediaType should be the media type of the downloaded asset.
- * For each object, the data should be null if the URL should be passed through as is.
+ * @returns The first detected chunk, or `undefined` if no chunk was detected.
  */
-type DownloadFunction = (options: Array<{
-    url: URL;
-    isUrlSupportedByModel: boolean;
-}>) => PromiseLike<Array<{
-    data: Uint8Array;
-    mediaType: string | undefined;
-} | null>>;
-
+type ChunkDetector = (buffer: string) => string | undefined | null;
 /**
- * Function that you can use to provide different settings for a step.
+ * Smooths text and reasoning streaming output.
  *
- * @param options - The options for the step.
- * @param options.steps - The steps that have been executed so far.
- * @param options.stepNumber - The number of the step that is being executed.
- * @param options.model - The model that is being used.
- * @param options.messages - The messages that will be sent to the model for the current step.
- * @param options.experimental_context - The context passed via the experimental_context setting (experimental).
+ * @param delayInMs - The delay in milliseconds between each chunk. Defaults to 10ms. Can be set to `null` to skip the delay.
+ * @param chunking - Controls how the text is chunked for streaming. Use "word" to stream word by word (default), "line" to stream line by line, provide a custom RegExp pattern for custom chunking, provide an Intl.Segmenter for locale-aware word segmentation (recommended for CJK languages), or provide a custom ChunkDetector function.
  *
- * @returns An object that contains the settings for the step.
- * If you return undefined (or for undefined settings), the settings from the outer level will be used.
+ * @returns A transform stream that smooths text streaming output.
  */
-type PrepareStepFunction<TOOLS extends Record<string, Tool> = Record<string, Tool>> = (options: {
+declare function smoothStream<TOOLS extends ToolSet>({ delayInMs, chunking, _internal: { delay }, }?: {
+    delayInMs?: number | null;
+    chunking?: 'word' | 'line' | RegExp | ChunkDetector | Intl.Segmenter;
     /**
-     * The steps that have been executed so far.
+     * Internal. For test use only. May change without notice.
      */
-    steps: Array<StepResult<NoInfer<TOOLS>>>;
+    _internal?: {
+        delay?: (delayInMs: number | null) => Promise<void>;
+    };
+}): (options: {
+    tools: TOOLS;
+}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
+
+/**
+ * Tool output when the tool execution has been denied (for static tools).
+ */
+type StaticToolOutputDenied<TOOLS extends ToolSet> = ValueOf<{
+    [NAME in keyof TOOLS]: {
+        type: 'tool-output-denied';
+        toolCallId: string;
+        toolName: NAME & string;
+        providerExecuted?: boolean;
+        dynamic?: false | undefined;
+    };
+}>;
+/**
+ * Tool output when the tool execution has been denied.
+ */
+type TypedToolOutputDenied<TOOLS extends ToolSet> = StaticToolOutputDenied<TOOLS>;
+
+/**
+The data types that can be used in the UI message for the UI message data parts.
+ */
+type UIDataTypes = Record<string, unknown>;
+type UITool = {
+    input: unknown;
+    output: unknown | undefined;
+};
+/**
+ * Infer the input and output types of a tool so it can be used as a UI tool.
+ */
+type InferUITool<TOOL extends Tool> = {
+    input: InferToolInput<TOOL>;
+    output: InferToolOutput<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 UITools = Record<string, UITool>;
+/**
+AI SDK UI Messages. They are used in the client and to communicate between the frontend and the API routes.
+ */
+interface UIMessage<METADATA = unknown, DATA_PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> {
     /**
-     * The number of the step that is being executed.
+  A unique identifier for the message.
      */
-    stepNumber: number;
+    id: string;
     /**
-     * The model instance that is being used for this step.
+  The role of the message.
      */
-    model: LanguageModel;
+    role: 'system' | 'user' | 'assistant';
     /**
-     * The messages that will be sent to the model for the current step.
+  The metadata of the message.
      */
-    messages: Array<ModelMessage>;
+    metadata?: METADATA;
     /**
-     * The context passed via the experimental_context setting (experimental).
+  The parts of the message. Use this for rendering the message in the UI.
+  
+  System messages should be avoided (set the system prompt on the server instead).
+  They can have text parts.
+  
+  User messages can have text parts and file parts.
+  
+  Assistant messages can have text, reasoning, tool invocation, and file parts.
      */
-    experimental_context: unknown;
-}) => PromiseLike<PrepareStepResult<TOOLS>> | PrepareStepResult<TOOLS>;
+    parts: Array<UIMessagePart<DATA_PARTS, TOOLS>>;
+}
+type UIMessagePart<DATA_TYPES extends UIDataTypes, TOOLS extends UITools> = TextUIPart | ReasoningUIPart | ToolUIPart<TOOLS> | DynamicToolUIPart | SourceUrlUIPart | SourceDocumentUIPart | FileUIPart | DataUIPart<DATA_TYPES> | StepStartUIPart;
 /**
- * The result type returned by a {@link PrepareStepFunction},
- * allowing per-step overrides of model, tools, or messages.
+ * A text part of a message.
  */
-type PrepareStepResult<TOOLS extends Record<string, Tool> = Record<string, Tool>> = {
+type TextUIPart = {
+    type: 'text';
     /**
-     * Optionally override which LanguageModel instance is used for this step.
+     * The text content.
      */
-    model?: LanguageModel;
+    text: string;
     /**
-     * Optionally set which tool the model must call, or provide tool call configuration
-     * for this step.
+     * The state of the text part.
      */
-    toolChoice?: ToolChoice<NoInfer<TOOLS>>;
+    state?: 'streaming' | 'done';
     /**
-     * If provided, only these tools are enabled/available for this step.
+     * The provider metadata.
      */
-    activeTools?: Array<keyof NoInfer<TOOLS>>;
+    providerMetadata?: ProviderMetadata;
+};
+/**
+ * A reasoning part of a message.
+ */
+type ReasoningUIPart = {
+    type: 'reasoning';
     /**
-     * Optionally override the system message(s) sent to the model for this step.
+     * The reasoning text.
      */
-    system?: string | SystemModelMessage | Array<SystemModelMessage>;
+    text: string;
     /**
-     * Optionally override the full set of messages sent to the model
-     * for this step.
+     * The state of the reasoning part.
      */
-    messages?: Array<ModelMessage>;
+    state?: 'streaming' | 'done';
     /**
-     * Context that is passed into tool execution. Experimental.
-     *
-     * Changing the context will affect the context in this step
-     * and all subsequent steps.
+     * The provider metadata.
      */
-    experimental_context?: unknown;
+    providerMetadata?: ProviderMetadata;
+};
+/**
+ * A source part of a message.
+ */
+type SourceUrlUIPart = {
+    type: 'source-url';
+    sourceId: string;
+    url: string;
+    title?: string;
+    providerMetadata?: ProviderMetadata;
+};
+/**
+ * A document source part of a message.
+ */
+type SourceDocumentUIPart = {
+    type: 'source-document';
+    sourceId: string;
+    mediaType: string;
+    title: string;
+    filename?: string;
+    providerMetadata?: ProviderMetadata;
+};
+/**
+ * A file part of a message.
+ */
+type FileUIPart = {
+    type: 'file';
     /**
-     * Additional provider-specific options for this step.
+     * IANA media type of the file.
      *
-     * Can be used to pass provider-specific configuration such as
-     * container IDs for Anthropic's code execution.
+     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
      */
-    providerOptions?: ProviderOptions;
-} | undefined;
-
-type StopCondition<TOOLS extends ToolSet> = (options: {
-    steps: Array<StepResult<TOOLS>>;
-}) => PromiseLike<boolean> | boolean;
-declare function stepCountIs(stepCount: number): StopCondition<any>;
-declare function hasToolCall(toolName: string): StopCondition<any>;
-
-declare const symbol$e: unique symbol;
-declare class InvalidToolInputError extends AISDKError {
-    private readonly [symbol$e];
-    readonly toolName: string;
-    readonly toolInput: string;
-    constructor({ toolInput, toolName, cause, message, }: {
-        message?: string;
-        toolInput: string;
-        toolName: string;
-        cause: unknown;
-    });
-    static isInstance(error: unknown): error is InvalidToolInputError;
-}
-
-declare const symbol$d: unique symbol;
-declare class NoSuchToolError extends AISDKError {
-    private readonly [symbol$d];
-    readonly toolName: string;
-    readonly availableTools: string[] | undefined;
-    constructor({ toolName, availableTools, message, }: {
-        toolName: string;
-        availableTools?: string[] | undefined;
-        message?: string;
-    });
-    static isInstance(error: unknown): error is NoSuchToolError;
-}
-
-declare const systemModelMessageSchema: z.ZodType<SystemModelMessage>;
-declare const userModelMessageSchema: z.ZodType<UserModelMessage>;
-declare const assistantModelMessageSchema: z.ZodType<AssistantModelMessage>;
-declare const toolModelMessageSchema: z.ZodType<ToolModelMessage>;
-declare const modelMessageSchema: z.ZodType<ModelMessage>;
-
-/**
- * A function that attempts to repair a tool call that failed to parse.
- *
- * It receives the error and the context as arguments and returns the repair
- * tool call JSON as text.
- *
- * @param options.system - The system prompt.
- * @param options.messages - The messages in the current generation step.
- * @param options.toolCall - The tool call that failed to parse.
- * @param options.tools - The tools that are available.
- * @param options.inputSchema - A function that returns the JSON Schema for a tool.
- * @param options.error - The error that occurred while parsing the tool call.
- */
-type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
-    system: string | SystemModelMessage | Array<SystemModelMessage> | undefined;
-    messages: ModelMessage[];
-    toolCall: LanguageModelV3ToolCall;
-    tools: TOOLS;
-    inputSchema: (options: {
-        toolName: string;
-    }) => PromiseLike<JSONSchema7>;
-    error: NoSuchToolError | InvalidToolInputError;
-}) => Promise<LanguageModelV3ToolCall | null>;
-
-/**
-Callback that is set using the `onStepFinish` option.
-
-@param stepResult - The result of the step.
- */
-type GenerateTextOnStepFinishCallback<TOOLS extends ToolSet> = (stepResult: StepResult<TOOLS>) => Promise<void> | void;
-/**
-Callback that is set using the `onFinish` option.
-
-@param event - The event that is passed to the callback.
- */
-type GenerateTextOnFinishCallback<TOOLS extends ToolSet> = (event: StepResult<TOOLS> & {
+    mediaType: string;
     /**
-     * Details for all steps.
+     * Optional filename of the file.
      */
-    readonly steps: StepResult<TOOLS>[];
+    filename?: string;
     /**
-     * Total usage for all steps. This is the sum of the usage of all steps.
+     * The URL of the file.
+     * It can either be a URL to a hosted file or a [Data URL](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs).
      */
-    readonly totalUsage: LanguageModelUsage;
+    url: string;
     /**
-     * Context that is passed into tool execution.
-     *
-     * Experimental (can break in patch releases).
-     *
-     * @default undefined
+     * The provider metadata.
      */
-    experimental_context: unknown;
-}) => PromiseLike<void> | void;
+    providerMetadata?: ProviderMetadata;
+};
 /**
-Generate a text and call tools for a given prompt using a language model.
-
-This function does not stream the output. If you want to stream the output, use `streamText` instead.
-
-@param model - The language model to use.
-
-@param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
-@param toolChoice - The tool choice strategy. Default: 'auto'.
-
-@param system - A system message that will be part of the prompt.
-@param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
-@param messages - A list of messages. You can either use `prompt` or `messages` but not both.
-
-@param maxOutputTokens - Maximum number of tokens to generate.
-@param temperature - Temperature setting.
-The value is passed through to the provider. The range depends on the provider and model.
-It is recommended to set either `temperature` or `topP`, but not both.
-@param topP - Nucleus sampling.
-The value is passed through to the provider. The range depends on the provider and model.
-It is recommended to set either `temperature` or `topP`, but not both.
-@param topK - Only sample from the top K options for each subsequent token.
-Used to remove "long tail" low probability responses.
-Recommended for advanced use cases only. You usually only need to use temperature.
-@param presencePenalty - Presence penalty setting.
-It affects the likelihood of the model to repeat information that is already in the prompt.
-The value is passed through to the provider. The range depends on the provider and model.
-@param frequencyPenalty - Frequency penalty setting.
-It affects the likelihood of the model to repeatedly use the same words or phrases.
-The value is passed through to the provider. The range depends on the provider and model.
-@param stopSequences - Stop sequences.
-If set, the model will stop generating text when one of the stop sequences is generated.
-@param seed - The seed (integer) to use for random sampling.
-If set and supported by the model, calls will generate deterministic results.
-
-@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
-@param abortSignal - An optional abort signal that can be used to cancel the call.
-@param timeout - An optional timeout in milliseconds. The call will be aborted if it takes longer than the specified timeout.
-@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
-
-@param experimental_generateMessageId - Generate a unique ID for each message.
-
-@param onStepFinish - Callback that is called when each step (LLM call) is finished, including intermediate steps.
-@param onFinish - Callback that is called when all steps are finished and the response is complete.
-
-@returns
-A result object that contains the generated text, the results of the tool calls, and additional information.
+ * A step boundary part of a message.
  */
-declare function generateText<TOOLS extends ToolSet, OUTPUT extends Output = Output<string, string>>({ model: modelArg, tools, toolChoice, system, prompt, messages, maxRetries: maxRetriesArg, abortSignal, timeout, headers, stopWhen, experimental_output, output, experimental_telemetry: telemetry, providerOptions, experimental_activeTools, activeTools, experimental_prepareStep, prepareStep, experimental_repairToolCall: repairToolCall, experimental_download: download, experimental_context, _internal: { generateId }, onStepFinish, onFinish, ...settings }: CallSettings & Prompt & {
-    /**
-The language model to use.
-     */
-    model: LanguageModel;
-    /**
-The tools that the model can call. The model needs to support calling tools.
-*/
-    tools?: TOOLS;
-    /**
-The tool choice strategy. Default: 'auto'.
-     */
-    toolChoice?: ToolChoice<NoInfer<TOOLS>>;
+type StepStartUIPart = {
+    type: 'step-start';
+};
+type DataUIPart<DATA_TYPES extends UIDataTypes> = ValueOf<{
+    [NAME in keyof DATA_TYPES & string]: {
+        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.
+ */
+declare function isDataUIPart<DATA_TYPES extends UIDataTypes>(part: UIMessagePart<DATA_TYPES, UITools>): part is DataUIPart<DATA_TYPES>;
+/**
+ * A UI tool invocation contains all the information needed to render a tool invocation in the UI.
+ * It can be derived from a tool without knowing the tool name, and can be used to define
+ * UI components for the tool.
+ */
+type UIToolInvocation<TOOL extends UITool | Tool> = {
     /**
-Condition for stopping the generation when there are tool results in the last step.
-When the condition is an array, any of the conditions can be met to stop the generation.
-
-@default stepCountIs(1)
+     * ID of the tool call.
      */
-    stopWhen?: StopCondition<NoInfer<TOOLS>> | Array<StopCondition<NoInfer<TOOLS>>>;
+    toolCallId: string;
+    title?: string;
     /**
-Optional telemetry configuration (experimental).
+     * Whether the tool call was executed by the provider.
      */
-    experimental_telemetry?: TelemetrySettings;
-    /**
-Additional provider-specific options. They are passed through
-to the provider from the AI SDK and enable provider-specific
-functionality that can be fully encapsulated in the provider.
- */
-    providerOptions?: ProviderOptions;
+    providerExecuted?: boolean;
+} & ({
+    state: 'input-streaming';
+    input: DeepPartial<asUITool<TOOL>['input']> | undefined;
+    output?: never;
+    errorText?: never;
+    approval?: never;
+} | {
+    state: 'input-available';
+    input: asUITool<TOOL>['input'];
+    output?: never;
+    errorText?: never;
+    callProviderMetadata?: ProviderMetadata;
+    approval?: never;
+} | {
+    state: 'approval-requested';
+    input: asUITool<TOOL>['input'];
+    output?: never;
+    errorText?: never;
+    callProviderMetadata?: ProviderMetadata;
+    approval: {
+        id: string;
+        approved?: never;
+        reason?: never;
+    };
+} | {
+    state: 'approval-responded';
+    input: asUITool<TOOL>['input'];
+    output?: never;
+    errorText?: never;
+    callProviderMetadata?: ProviderMetadata;
+    approval: {
+        id: string;
+        approved: boolean;
+        reason?: string;
+    };
+} | {
+    state: 'output-available';
+    input: asUITool<TOOL>['input'];
+    output: asUITool<TOOL>['output'];
+    errorText?: never;
+    callProviderMetadata?: ProviderMetadata;
+    preliminary?: boolean;
+    approval?: {
+        id: string;
+        approved: true;
+        reason?: string;
+    };
+} | {
+    state: 'output-error';
+    input: asUITool<TOOL>['input'] | undefined;
+    rawInput?: unknown;
+    output?: never;
+    errorText: string;
+    callProviderMetadata?: ProviderMetadata;
+    approval?: {
+        id: string;
+        approved: true;
+        reason?: string;
+    };
+} | {
+    state: 'output-denied';
+    input: asUITool<TOOL>['input'];
+    output?: never;
+    errorText?: never;
+    callProviderMetadata?: ProviderMetadata;
+    approval: {
+        id: string;
+        approved: false;
+        reason?: string;
+    };
+});
+type ToolUIPart<TOOLS extends UITools = UITools> = ValueOf<{
+    [NAME in keyof TOOLS & string]: {
+        type: `tool-${NAME}`;
+    } & UIToolInvocation<TOOLS[NAME]>;
+}>;
+type DynamicToolUIPart = {
+    type: 'dynamic-tool';
     /**
-     * @deprecated Use `activeTools` instead.
+     * Name of the tool that is being called.
      */
-    experimental_activeTools?: Array<keyof NoInfer<TOOLS>>;
+    toolName: string;
     /**
-Limits the tools that are available for the model to call without
-changing the tool call and result types in the result.
+     * ID of the tool call.
      */
-    activeTools?: Array<keyof NoInfer<TOOLS>>;
+    toolCallId: string;
+    title?: string;
     /**
-Optional specification for parsing structured outputs from the LLM response.
+     * Whether the tool call was executed by the provider.
      */
-    output?: OUTPUT;
-    /**
-Optional specification for parsing structured outputs from the LLM response.
-
-@deprecated Use `output` instead.
-     */
-    experimental_output?: OUTPUT;
-    /**
-Custom download function to use for URLs.
-
-By default, files are downloaded if the model does not support the URL for the given media type.
-     */
-    experimental_download?: DownloadFunction | undefined;
-    /**
-     * @deprecated Use `prepareStep` instead.
-     */
-    experimental_prepareStep?: PrepareStepFunction<NoInfer<TOOLS>>;
-    /**
-Optional function that you can use to provide different settings for a step.
-    */
-    prepareStep?: PrepareStepFunction<NoInfer<TOOLS>>;
-    /**
-A function that attempts to repair a tool call that failed to parse.
-     */
-    experimental_repairToolCall?: ToolCallRepairFunction<NoInfer<TOOLS>>;
-    /**
-     * Callback that is called when each step (LLM call) is finished, including intermediate steps.
-     */
-    onStepFinish?: GenerateTextOnStepFinishCallback<NoInfer<TOOLS>>;
-    /**
-     * Callback that is called when all steps are finished and the response is complete.
-     */
-    onFinish?: GenerateTextOnFinishCallback<NoInfer<TOOLS>>;
-    /**
-     * Context that is passed into tool execution.
-     *
-     * Experimental (can break in patch releases).
-     *
-     * @default undefined
-     */
-    experimental_context?: unknown;
-    /**
-     * Internal. For test use only. May change without notice.
-     */
-    _internal?: {
-        generateId?: IdGenerator;
+    providerExecuted?: boolean;
+} & ({
+    state: 'input-streaming';
+    input: unknown | undefined;
+    output?: never;
+    errorText?: never;
+    approval?: never;
+} | {
+    state: 'input-available';
+    input: unknown;
+    output?: never;
+    errorText?: never;
+    callProviderMetadata?: ProviderMetadata;
+    approval?: never;
+} | {
+    state: 'approval-requested';
+    input: unknown;
+    output?: never;
+    errorText?: never;
+    callProviderMetadata?: ProviderMetadata;
+    approval: {
+        id: string;
+        approved?: never;
+        reason?: never;
     };
-}): Promise<GenerateTextResult<TOOLS, OUTPUT>>;
-
+} | {
+    state: 'approval-responded';
+    input: unknown;
+    output?: never;
+    errorText?: never;
+    callProviderMetadata?: ProviderMetadata;
+    approval: {
+        id: string;
+        approved: boolean;
+        reason?: string;
+    };
+} | {
+    state: 'output-available';
+    input: unknown;
+    output: unknown;
+    errorText?: never;
+    callProviderMetadata?: ProviderMetadata;
+    preliminary?: boolean;
+    approval?: {
+        id: string;
+        approved: true;
+        reason?: string;
+    };
+} | {
+    state: 'output-error';
+    input: unknown;
+    output?: never;
+    errorText: string;
+    callProviderMetadata?: ProviderMetadata;
+    approval?: {
+        id: string;
+        approved: true;
+        reason?: string;
+    };
+} | {
+    state: 'output-denied';
+    input: unknown;
+    output?: never;
+    errorText?: never;
+    callProviderMetadata?: ProviderMetadata;
+    approval: {
+        id: string;
+        approved: false;
+        reason?: string;
+    };
+});
 /**
- * Prunes model messages from a list of model messages.
- *
- * @param messages - The list of model messages to prune.
- * @param reasoning - How to remove reasoning content from assistant messages. Default is `'none'`.
- * @param toolCalls - How to prune tool call/results/approval content. Default is `[]`.
- * @param emptyMessages - Whether to keep or remove messages whose content is empty after pruning. Default is `'remove'`.
- *
- * @returns The pruned list of model messages.
+ * Type guard to check if a message part is a text part.
  */
-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<{
-        type: 'all' | 'before-last-message' | `before-last-${number}-messages`;
-        tools?: string[];
-    }>;
-    emptyMessages?: 'keep' | 'remove';
-}): ModelMessage[];
-
+declare function isTextUIPart(part: UIMessagePart<UIDataTypes, UITools>): part is TextUIPart;
 /**
- * Detects the first chunk in a buffer.
- *
- * @param buffer - The buffer to detect the first chunk in.
- *
- * @returns The first detected chunk, or `undefined` if no chunk was detected.
+ * Type guard to check if a message part is a file part.
  */
-type ChunkDetector = (buffer: string) => string | undefined | null;
+declare function isFileUIPart(part: UIMessagePart<UIDataTypes, UITools>): part is FileUIPart;
 /**
- * Smooths text and reasoning streaming output.
- *
- * @param delayInMs - The delay in milliseconds between each chunk. Defaults to 10ms. Can be set to `null` to skip the delay.
- * @param chunking - Controls how the text is chunked for streaming. Use "word" to stream word by word (default), "line" to stream line by line, provide a custom RegExp pattern for custom chunking, provide an Intl.Segmenter for locale-aware word segmentation (recommended for CJK languages), or provide a custom ChunkDetector function.
- *
- * @returns A transform stream that smooths text streaming output.
+ * Type guard to check if a message part is a reasoning part.
  */
-declare function smoothStream<TOOLS extends ToolSet>({ delayInMs, chunking, _internal: { delay }, }?: {
-    delayInMs?: number | null;
-    chunking?: 'word' | 'line' | RegExp | ChunkDetector | Intl.Segmenter;
-    /**
-     * Internal. For test use only. May change without notice.
-     */
-    _internal?: {
-        delay?: (delayInMs: number | null) => Promise<void>;
-    };
-}): (options: {
-    tools: TOOLS;
-}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
-
+declare function isReasoningUIPart(part: UIMessagePart<UIDataTypes, UITools>): part is ReasoningUIPart;
 /**
- * Tool output when the tool execution has been denied (for static tools).
+ * Check if a message part is a static tool part.
+ *
+ * Static tools are tools for which the types are known at development time.
  */
-type StaticToolOutputDenied<TOOLS extends ToolSet> = ValueOf<{
-    [NAME in keyof TOOLS]: {
-        type: 'tool-output-denied';
-        toolCallId: string;
-        toolName: NAME & string;
-        providerExecuted?: boolean;
-        dynamic?: false | undefined;
-    };
-}>;
+declare function isStaticToolUIPart<TOOLS extends UITools>(part: UIMessagePart<UIDataTypes, TOOLS>): part is ToolUIPart<TOOLS>;
 /**
- * Tool output when the tool execution has been denied.
+ * Check if a message part is a tool part.
+ *
+ * Tool parts are either static or dynamic tools.
+ *
+ * Use `isStaticToolUIPart` or `isDynamicToolUIPart` to check the type of the tool.
  */
-type TypedToolOutputDenied<TOOLS extends ToolSet> = StaticToolOutputDenied<TOOLS>;
-
+declare function isToolUIPart<TOOLS extends UITools>(part: UIMessagePart<UIDataTypes, TOOLS>): part is ToolUIPart<TOOLS> | DynamicToolUIPart;
 /**
-The data types that can be used in the UI message for the UI message data parts.
+ * @deprecated Use isToolUIPart instead.
  */
-type UIDataTypes = Record<string, unknown>;
-type UITool = {
-    input: unknown;
-    output: unknown | undefined;
-};
+declare const isToolOrDynamicToolUIPart: typeof isToolUIPart;
 /**
- * Infer the input and output types of a tool so it can be used as a UI tool.
+ * Returns the name of the static tool.
+ *
+ * The possible values are the keys of the tool set.
  */
-type InferUITool<TOOL extends Tool> = {
-    input: InferToolInput<TOOL>;
-    output: InferToolOutput<TOOL>;
-};
+declare function getStaticToolName<TOOLS extends UITools>(part: ToolUIPart<TOOLS>): keyof TOOLS;
 /**
- * Infer the input and output types of a tool set so it can be used as a UI tool set.
+ * Returns the name of the tool (static or dynamic).
+ *
+ * This function will not restrict the name to the keys of the tool set.
+ * If you need to restrict the name to the keys of the tool set, use `getStaticToolName` instead.
  */
-type InferUITools<TOOLS extends ToolSet> = {
-    [NAME in keyof TOOLS & string]: InferUITool<TOOLS[NAME]>;
-};
-type UITools = Record<string, UITool>;
+declare function getToolName(part: ToolUIPart<UITools> | DynamicToolUIPart): string;
 /**
-AI SDK UI Messages. They are used in the client and to communicate between the frontend and the API routes.
+ * @deprecated Use getToolName instead.
  */
-interface UIMessage<METADATA = unknown, DATA_PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> {
-    /**
-  A unique identifier for the message.
-     */
+declare const getToolOrDynamicToolName: typeof getToolName;
+type InferUIMessageMetadata<T extends UIMessage> = T extends UIMessage<infer METADATA> ? METADATA : unknown;
+type InferUIMessageData<T extends UIMessage> = T extends UIMessage<unknown, infer DATA_TYPES> ? DATA_TYPES : UIDataTypes;
+type InferUIMessageTools<T extends UIMessage> = T extends UIMessage<unknown, UIDataTypes, infer TOOLS> ? TOOLS : UITools;
+type InferUIMessageToolCall<UI_MESSAGE extends UIMessage> = ValueOf<{
+    [NAME in keyof InferUIMessageTools<UI_MESSAGE>]: ToolCall<NAME & string, InferUIMessageTools<UI_MESSAGE>[NAME] extends {
+        input: infer INPUT;
+    } ? INPUT : never> & {
+        dynamic?: false;
+    };
+}> | (ToolCall<string, unknown> & {
+    dynamic: true;
+});
+
+declare const uiMessageChunkSchema: _ai_sdk_provider_utils.LazySchema<{
+    type: "text-start";
     id: string;
-    /**
-  The role of the message.
-     */
-    role: 'system' | 'user' | 'assistant';
-    /**
-  The metadata of the message.
-     */
-    metadata?: METADATA;
-    /**
-  The parts of the message. Use this for rendering the message in the UI.
-  
-  System messages should be avoided (set the system prompt on the server instead).
-  They can have text parts.
-  
-  User messages can have text parts and file parts.
-  
-  Assistant messages can have text, reasoning, tool invocation, and file parts.
-     */
-    parts: Array<UIMessagePart<DATA_PARTS, TOOLS>>;
-}
-type UIMessagePart<DATA_TYPES extends UIDataTypes, TOOLS extends UITools> = TextUIPart | ReasoningUIPart | ToolUIPart<TOOLS> | DynamicToolUIPart | SourceUrlUIPart | SourceDocumentUIPart | FileUIPart | DataUIPart<DATA_TYPES> | StepStartUIPart;
-/**
- * A text part of a message.
- */
-type TextUIPart = {
-    type: 'text';
-    /**
-     * The text content.
-     */
-    text: string;
-    /**
-     * The state of the text part.
-     */
-    state?: 'streaming' | 'done';
-    /**
-     * The provider metadata.
-     */
-    providerMetadata?: ProviderMetadata;
-};
-/**
- * A reasoning part of a message.
- */
-type ReasoningUIPart = {
-    type: 'reasoning';
-    /**
-     * The reasoning text.
-     */
-    text: string;
-    /**
-     * The state of the reasoning part.
-     */
-    state?: 'streaming' | 'done';
-    /**
-     * The provider metadata.
-     */
-    providerMetadata?: ProviderMetadata;
-};
-/**
- * A source part of a message.
- */
-type SourceUrlUIPart = {
-    type: 'source-url';
+    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+} | {
+    type: "text-delta";
+    id: string;
+    delta: string;
+    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+} | {
+    type: "text-end";
+    id: string;
+    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+} | {
+    type: "error";
+    errorText: string;
+} | {
+    type: "tool-input-start";
+    toolCallId: string;
+    toolName: string;
+    providerExecuted?: boolean | undefined;
+    dynamic?: boolean | undefined;
+    title?: string | undefined;
+} | {
+    type: "tool-input-delta";
+    toolCallId: string;
+    inputTextDelta: string;
+} | {
+    type: "tool-input-available";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    providerExecuted?: boolean | undefined;
+    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+    dynamic?: boolean | undefined;
+    title?: string | undefined;
+} | {
+    type: "tool-input-error";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    errorText: string;
+    providerExecuted?: boolean | undefined;
+    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+    dynamic?: boolean | undefined;
+    title?: string | undefined;
+} | {
+    type: "tool-approval-request";
+    approvalId: string;
+    toolCallId: string;
+} | {
+    type: "tool-output-available";
+    toolCallId: string;
+    output: unknown;
+    providerExecuted?: boolean | undefined;
+    dynamic?: boolean | undefined;
+    preliminary?: boolean | undefined;
+} | {
+    type: "tool-output-error";
+    toolCallId: string;
+    errorText: string;
+    providerExecuted?: boolean | undefined;
+    dynamic?: boolean | undefined;
+} | {
+    type: "tool-output-denied";
+    toolCallId: string;
+} | {
+    type: "reasoning-start";
+    id: string;
+    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+} | {
+    type: "reasoning-delta";
+    id: string;
+    delta: string;
+    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+} | {
+    type: "reasoning-end";
+    id: string;
+    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+} | {
+    type: "source-url";
     sourceId: string;
     url: string;
-    title?: string;
-    providerMetadata?: ProviderMetadata;
-};
-/**
- * A document source part of a message.
- */
-type SourceDocumentUIPart = {
-    type: 'source-document';
+    title?: string | undefined;
+    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+} | {
+    type: "source-document";
     sourceId: string;
     mediaType: string;
     title: string;
-    filename?: string;
-    providerMetadata?: ProviderMetadata;
-};
-/**
- * A file part of a message.
- */
-type FileUIPart = {
-    type: 'file';
-    /**
-     * IANA media type of the file.
-     *
-     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
-     */
-    mediaType: string;
-    /**
-     * Optional filename of the file.
-     */
-    filename?: string;
-    /**
-     * The URL of the file.
-     * It can either be a URL to a hosted file or a [Data URL](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs).
-     */
+    filename?: string | undefined;
+    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+} | {
+    type: "file";
     url: string;
-    /**
-     * The provider metadata.
-     */
-    providerMetadata?: ProviderMetadata;
-};
-/**
- * A step boundary part of a message.
- */
-type StepStartUIPart = {
-    type: 'step-start';
-};
-type DataUIPart<DATA_TYPES extends UIDataTypes> = ValueOf<{
+    mediaType: string;
+    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+} | {
+    type: `data-${string}`;
+    data: unknown;
+    id?: string | undefined;
+    transient?: boolean | undefined;
+} | {
+    type: "start-step";
+} | {
+    type: "finish-step";
+} | {
+    type: "start";
+    messageId?: string | undefined;
+    messageMetadata?: unknown;
+} | {
+    type: "finish";
+    finishReason?: "length" | "error" | "stop" | "content-filter" | "tool-calls" | "other" | undefined;
+    messageMetadata?: unknown;
+} | {
+    type: "abort";
+    reason?: string | undefined;
+} | {
+    type: "message-metadata";
+    messageMetadata: unknown;
+}>;
+type DataUIMessageChunk<DATA_TYPES extends UIDataTypes> = ValueOf<{
     [NAME in keyof DATA_TYPES & string]: {
         type: `data-${NAME}`;
         id?: string;
         data: DATA_TYPES[NAME];
+        transient?: boolean;
     };
 }>;
-type asUITool<TOOL extends UITool | Tool> = TOOL extends Tool ? InferUITool<TOOL> : TOOL;
-/**
- * Check if a message part is a data part.
- */
-declare function isDataUIPart<DATA_TYPES extends UIDataTypes>(part: UIMessagePart<DATA_TYPES, UITools>): part is DataUIPart<DATA_TYPES>;
-/**
- * A UI tool invocation contains all the information needed to render a tool invocation in the UI.
- * It can be derived from a tool without knowing the tool name, and can be used to define
- * UI components for the tool.
- */
-type UIToolInvocation<TOOL extends UITool | Tool> = {
-    /**
-     * ID of the tool call.
-     */
-    toolCallId: string;
-    title?: string;
-    /**
-     * Whether the tool call was executed by the provider.
-     */
-    providerExecuted?: boolean;
-} & ({
-    state: 'input-streaming';
-    input: DeepPartial<asUITool<TOOL>['input']> | undefined;
-    output?: never;
-    errorText?: never;
-    approval?: never;
+type UIMessageChunk<METADATA = unknown, DATA_TYPES extends UIDataTypes = UIDataTypes> = {
+    type: 'text-start';
+    id: string;
+    providerMetadata?: ProviderMetadata;
 } | {
-    state: 'input-available';
-    input: asUITool<TOOL>['input'];
-    output?: never;
-    errorText?: never;
-    callProviderMetadata?: ProviderMetadata;
-    approval?: never;
+    type: 'text-delta';
+    delta: string;
+    id: string;
+    providerMetadata?: ProviderMetadata;
 } | {
-    state: 'approval-requested';
-    input: asUITool<TOOL>['input'];
-    output?: never;
-    errorText?: never;
-    callProviderMetadata?: ProviderMetadata;
-    approval: {
-        id: string;
-        approved?: never;
-        reason?: never;
-    };
+    type: 'text-end';
+    id: string;
+    providerMetadata?: ProviderMetadata;
 } | {
-    state: 'approval-responded';
-    input: asUITool<TOOL>['input'];
-    output?: never;
-    errorText?: never;
-    callProviderMetadata?: ProviderMetadata;
-    approval: {
-        id: string;
-        approved: boolean;
-        reason?: string;
-    };
-} | {
-    state: 'output-available';
-    input: asUITool<TOOL>['input'];
-    output: asUITool<TOOL>['output'];
-    errorText?: never;
-    callProviderMetadata?: ProviderMetadata;
-    preliminary?: boolean;
-    approval?: {
-        id: string;
-        approved: true;
-        reason?: string;
-    };
-} | {
-    state: 'output-error';
-    input: asUITool<TOOL>['input'] | undefined;
-    rawInput?: unknown;
-    output?: never;
-    errorText: string;
-    callProviderMetadata?: ProviderMetadata;
-    approval?: {
-        id: string;
-        approved: true;
-        reason?: string;
-    };
-} | {
-    state: 'output-denied';
-    input: asUITool<TOOL>['input'];
-    output?: never;
-    errorText?: never;
-    callProviderMetadata?: ProviderMetadata;
-    approval: {
-        id: string;
-        approved: false;
-        reason?: string;
-    };
-});
-type ToolUIPart<TOOLS extends UITools = UITools> = ValueOf<{
-    [NAME in keyof TOOLS & string]: {
-        type: `tool-${NAME}`;
-    } & UIToolInvocation<TOOLS[NAME]>;
-}>;
-type DynamicToolUIPart = {
-    type: 'dynamic-tool';
-    /**
-     * Name of the tool that is being called.
-     */
-    toolName: string;
-    /**
-     * ID of the tool call.
-     */
-    toolCallId: string;
-    title?: string;
-    /**
-     * Whether the tool call was executed by the provider.
-     */
-    providerExecuted?: boolean;
-} & ({
-    state: 'input-streaming';
-    input: unknown | undefined;
-    output?: never;
-    errorText?: never;
-    approval?: never;
-} | {
-    state: 'input-available';
-    input: unknown;
-    output?: never;
-    errorText?: never;
-    callProviderMetadata?: ProviderMetadata;
-    approval?: never;
-} | {
-    state: 'approval-requested';
-    input: unknown;
-    output?: never;
-    errorText?: never;
-    callProviderMetadata?: ProviderMetadata;
-    approval: {
-        id: string;
-        approved?: never;
-        reason?: never;
-    };
-} | {
-    state: 'approval-responded';
-    input: unknown;
-    output?: never;
-    errorText?: never;
-    callProviderMetadata?: ProviderMetadata;
-    approval: {
-        id: string;
-        approved: boolean;
-        reason?: string;
-    };
-} | {
-    state: 'output-available';
-    input: unknown;
-    output: unknown;
-    errorText?: never;
-    callProviderMetadata?: ProviderMetadata;
-    preliminary?: boolean;
-    approval?: {
-        id: string;
-        approved: true;
-        reason?: string;
-    };
-} | {
-    state: 'output-error';
-    input: unknown;
-    output?: never;
-    errorText: string;
-    callProviderMetadata?: ProviderMetadata;
-    approval?: {
-        id: string;
-        approved: true;
-        reason?: string;
-    };
-} | {
-    state: 'output-denied';
-    input: unknown;
-    output?: never;
-    errorText?: never;
-    callProviderMetadata?: ProviderMetadata;
-    approval: {
-        id: string;
-        approved: false;
-        reason?: string;
-    };
-});
-/**
- * Type guard to check if a message part is a text part.
- */
-declare function isTextUIPart(part: UIMessagePart<UIDataTypes, UITools>): part is TextUIPart;
-/**
- * Type guard to check if a message part is a file part.
- */
-declare function isFileUIPart(part: UIMessagePart<UIDataTypes, UITools>): part is FileUIPart;
-/**
- * Type guard to check if a message part is a reasoning part.
- */
-declare function isReasoningUIPart(part: UIMessagePart<UIDataTypes, UITools>): part is ReasoningUIPart;
-/**
- * Check if a message part is a static tool part.
- *
- * Static tools are tools for which the types are known at development time.
- */
-declare function isStaticToolUIPart<TOOLS extends UITools>(part: UIMessagePart<UIDataTypes, TOOLS>): part is ToolUIPart<TOOLS>;
-/**
- * Check if a message part is a tool part.
- *
- * Tool parts are either static or dynamic tools.
- *
- * Use `isStaticToolUIPart` or `isDynamicToolUIPart` to check the type of the tool.
- */
-declare function isToolUIPart<TOOLS extends UITools>(part: UIMessagePart<UIDataTypes, TOOLS>): part is ToolUIPart<TOOLS> | DynamicToolUIPart;
-/**
- * @deprecated Use isToolUIPart instead.
- */
-declare const isToolOrDynamicToolUIPart: typeof isToolUIPart;
-/**
- * Returns the name of the static tool.
- *
- * The possible values are the keys of the tool set.
- */
-declare function getStaticToolName<TOOLS extends UITools>(part: ToolUIPart<TOOLS>): keyof TOOLS;
-/**
- * Returns the name of the tool (static or dynamic).
- *
- * This function will not restrict the name to the keys of the tool set.
- * If you need to restrict the name to the keys of the tool set, use `getStaticToolName` instead.
- */
-declare function getToolName(part: ToolUIPart<UITools> | DynamicToolUIPart): string;
-/**
- * @deprecated Use getToolName instead.
- */
-declare const getToolOrDynamicToolName: typeof getToolName;
-type InferUIMessageMetadata<T extends UIMessage> = T extends UIMessage<infer METADATA> ? METADATA : unknown;
-type InferUIMessageData<T extends UIMessage> = T extends UIMessage<unknown, infer DATA_TYPES> ? DATA_TYPES : UIDataTypes;
-type InferUIMessageTools<T extends UIMessage> = T extends UIMessage<unknown, UIDataTypes, infer TOOLS> ? TOOLS : UITools;
-type InferUIMessageToolCall<UI_MESSAGE extends UIMessage> = ValueOf<{
-    [NAME in keyof InferUIMessageTools<UI_MESSAGE>]: ToolCall<NAME & string, InferUIMessageTools<UI_MESSAGE>[NAME] extends {
-        input: infer INPUT;
-    } ? INPUT : never> & {
-        dynamic?: false;
-    };
-}> | (ToolCall<string, unknown> & {
-    dynamic: true;
-});
-
-declare const uiMessageChunkSchema: _ai_sdk_provider_utils.LazySchema<{
-    type: "text-start";
+    type: 'reasoning-start';
     id: string;
-    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+    providerMetadata?: ProviderMetadata;
 } | {
-    type: "text-delta";
+    type: 'reasoning-delta';
     id: string;
     delta: string;
-    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+    providerMetadata?: ProviderMetadata;
 } | {
-    type: "text-end";
+    type: 'reasoning-end';
     id: string;
-    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+    providerMetadata?: ProviderMetadata;
 } | {
-    type: "error";
+    type: 'error';
     errorText: string;
 } | {
-    type: "tool-input-start";
-    toolCallId: string;
-    toolName: string;
-    providerExecuted?: boolean | undefined;
-    dynamic?: boolean | undefined;
-    title?: string | undefined;
-} | {
-    type: "tool-input-delta";
-    toolCallId: string;
-    inputTextDelta: string;
-} | {
-    type: "tool-input-available";
+    type: 'tool-input-available';
     toolCallId: string;
     toolName: string;
     input: unknown;
-    providerExecuted?: boolean | undefined;
-    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
-    dynamic?: boolean | undefined;
-    title?: string | undefined;
+    providerExecuted?: boolean;
+    providerMetadata?: ProviderMetadata;
+    dynamic?: boolean;
+    title?: string;
 } | {
-    type: "tool-input-error";
+    type: 'tool-input-error';
     toolCallId: string;
     toolName: string;
     input: unknown;
+    providerExecuted?: boolean;
+    providerMetadata?: ProviderMetadata;
+    dynamic?: boolean;
     errorText: string;
-    providerExecuted?: boolean | undefined;
-    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
-    dynamic?: boolean | undefined;
-    title?: string | undefined;
+    title?: string;
 } | {
-    type: "tool-approval-request";
+    type: 'tool-approval-request';
     approvalId: string;
     toolCallId: string;
 } | {
-    type: "tool-output-available";
+    type: 'tool-output-available';
     toolCallId: string;
     output: unknown;
-    providerExecuted?: boolean | undefined;
-    dynamic?: boolean | undefined;
-    preliminary?: boolean | undefined;
+    providerExecuted?: boolean;
+    dynamic?: boolean;
+    preliminary?: boolean;
 } | {
-    type: "tool-output-error";
+    type: 'tool-output-error';
     toolCallId: string;
     errorText: string;
-    providerExecuted?: boolean | undefined;
-    dynamic?: boolean | undefined;
+    providerExecuted?: boolean;
+    dynamic?: boolean;
 } | {
-    type: "tool-output-denied";
+    type: 'tool-output-denied';
     toolCallId: string;
 } | {
-    type: "reasoning-start";
-    id: string;
-    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
-} | {
-    type: "reasoning-delta";
-    id: string;
-    delta: string;
-    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+    type: 'tool-input-start';
+    toolCallId: string;
+    toolName: string;
+    providerExecuted?: boolean;
+    dynamic?: boolean;
+    title?: string;
 } | {
-    type: "reasoning-end";
-    id: string;
-    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+    type: 'tool-input-delta';
+    toolCallId: string;
+    inputTextDelta: string;
 } | {
-    type: "source-url";
+    type: 'source-url';
     sourceId: string;
     url: string;
-    title?: string | undefined;
-    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+    title?: string;
+    providerMetadata?: ProviderMetadata;
 } | {
-    type: "source-document";
+    type: 'source-document';
     sourceId: string;
     mediaType: string;
     title: string;
-    filename?: string | undefined;
-    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
+    filename?: string;
+    providerMetadata?: ProviderMetadata;
 } | {
-    type: "file";
+    type: 'file';
     url: string;
     mediaType: string;
-    providerMetadata?: _ai_sdk_provider.SharedV3ProviderMetadata | undefined;
-} | {
-    type: `data-${string}`;
-    data: unknown;
-    id?: string | undefined;
-    transient?: boolean | undefined;
-} | {
-    type: "start-step";
+    providerMetadata?: ProviderMetadata;
+} | DataUIMessageChunk<DATA_TYPES> | {
+    type: 'start-step';
 } | {
-    type: "finish-step";
+    type: 'finish-step';
 } | {
-    type: "start";
-    messageId?: string | undefined;
-    messageMetadata?: unknown;
+    type: 'start';
+    messageId?: string;
+    messageMetadata?: METADATA;
 } | {
-    type: "finish";
-    finishReason?: "length" | "error" | "stop" | "content-filter" | "tool-calls" | "other" | undefined;
-    messageMetadata?: unknown;
+    type: 'finish';
+    finishReason?: FinishReason;
+    messageMetadata?: METADATA;
 } | {
-    type: "abort";
-    reason?: string | undefined;
+    type: 'abort';
+    reason?: string;
 } | {
-    type: "message-metadata";
-    messageMetadata: unknown;
-}>;
-type DataUIMessageChunk<DATA_TYPES extends UIDataTypes> = ValueOf<{
-    [NAME in keyof DATA_TYPES & string]: {
-        type: `data-${NAME}`;
-        id?: string;
-        data: DATA_TYPES[NAME];
-        transient?: boolean;
-    };
-}>;
-type UIMessageChunk<METADATA = unknown, DATA_TYPES extends UIDataTypes = UIDataTypes> = {
+    type: 'message-metadata';
+    messageMetadata: METADATA;
+};
+type InferUIMessageChunk<T extends UIMessage> = UIMessageChunk<InferUIMessageMetadata<T>, InferUIMessageData<T>>;
+
+type UIMessageStreamOnFinishCallback<UI_MESSAGE extends UIMessage> = (event: {
+    /**
+     * The updated list of UI messages.
+     */
+    messages: UI_MESSAGE[];
+    /**
+     * Indicates whether the response message is a continuation of the last original message,
+     * or if a new message was created.
+     */
+    isContinuation: boolean;
+    /**
+     * Indicates whether the stream was aborted.
+     */
+    isAborted: boolean;
+    /**
+     * The message that was sent to the client as a response
+     * (including the original message if it was extended).
+     */
+    responseMessage: UI_MESSAGE;
+    /**
+     * The reason why the generation finished.
+     */
+    finishReason?: FinishReason;
+}) => PromiseLike<void> | void;
+
+type UIMessageStreamResponseInit = ResponseInit & {
+    consumeSseStream?: (options: {
+        stream: ReadableStream<string>;
+    }) => PromiseLike<void> | void;
+};
+
+/**
+ * A type that combines AsyncIterable and ReadableStream.
+ * This allows a ReadableStream to be consumed using for-await-of syntax.
+ */
+type AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
+
+type ErrorHandler = (error: unknown) => void;
+
+type UIMessageStreamOptions<UI_MESSAGE extends UIMessage> = {
+    /**
+     * The original messages. If they are provided, persistence mode is assumed,
+     * and a message ID is provided for the response message.
+     */
+    originalMessages?: UI_MESSAGE[];
+    /**
+     * Generate a message ID for the response message.
+     *
+     * If not provided, no message ID will be set for the response message (unless
+     * the original messages are provided and the last message is an assistant message).
+     */
+    generateMessageId?: IdGenerator;
+    onFinish?: UIMessageStreamOnFinishCallback<UI_MESSAGE>;
+    /**
+     * Extracts message metadata that will be send to the client.
+     *
+     * Called on `start` and `finish` events.
+     */
+    messageMetadata?: (options: {
+        part: TextStreamPart<ToolSet>;
+    }) => InferUIMessageMetadata<UI_MESSAGE> | undefined;
+    /**
+     * Send reasoning parts to the client.
+     * Default to true.
+     */
+    sendReasoning?: boolean;
+    /**
+     * Send source parts to the client.
+     * Default to false.
+     */
+    sendSources?: boolean;
+    /**
+     * Send the finish event to the client.
+     * Set to false if you are using additional streamText calls
+     * that send additional data.
+     * Default to true.
+     */
+    sendFinish?: boolean;
+    /**
+     * Send the message start event to the client.
+     * Set to false if you are using additional streamText calls
+     * and the message start event has already been sent.
+     * Default to true.
+     */
+    sendStart?: boolean;
+    /**
+     * Process an error, e.g. to log it. Default to `() => 'An error occurred.'`.
+     *
+     * @return error message to include in the data stream.
+     */
+    onError?: (error: unknown) => string;
+};
+type ConsumeStreamOptions = {
+    onError?: ErrorHandler;
+};
+/**
+A result object for accessing different stream types and additional information.
+ */
+interface StreamTextResult<TOOLS extends ToolSet, OUTPUT extends Output> {
+    /**
+  The content that was generated in the last step.
+  
+  Automatically consumes the stream.
+     */
+    readonly content: PromiseLike<Array<ContentPart<TOOLS>>>;
+    /**
+  The full text that has been generated by the last step.
+  
+  Automatically consumes the stream.
+       */
+    readonly text: PromiseLike<string>;
+    /**
+  The full reasoning that the model has generated.
+  
+  Automatically consumes the stream.
+     */
+    readonly reasoning: PromiseLike<Array<ReasoningOutput>>;
+    /**
+  The reasoning that has been generated by the last step.
+  
+  Automatically consumes the stream.
+       */
+    readonly reasoningText: PromiseLike<string | undefined>;
+    /**
+  Files that have been generated by the model in the last step.
+  
+  Automatically consumes the stream.
+     */
+    readonly files: PromiseLike<GeneratedFile[]>;
+    /**
+  Sources that have been used as references in the last step.
+  
+  Automatically consumes the stream.
+     */
+    readonly sources: PromiseLike<Source[]>;
+    /**
+  The tool calls that have been executed in the last step.
+  
+  Automatically consumes the stream.
+       */
+    readonly toolCalls: PromiseLike<TypedToolCall<TOOLS>[]>;
+    /**
+  The static tool calls that have been executed in the last step.
+  
+  Automatically consumes the stream.
+       */
+    readonly staticToolCalls: PromiseLike<StaticToolCall<TOOLS>[]>;
+    /**
+  The dynamic tool calls that have been executed in the last step.
+  
+  Automatically consumes the stream.
+       */
+    readonly dynamicToolCalls: PromiseLike<DynamicToolCall[]>;
+    /**
+  The static tool results that have been generated in the last step.
+  
+  Automatically consumes the stream.
+       */
+    readonly staticToolResults: PromiseLike<StaticToolResult<TOOLS>[]>;
+    /**
+  The dynamic tool results that have been generated in the last step.
+  
+  Automatically consumes the stream.
+       */
+    readonly dynamicToolResults: PromiseLike<DynamicToolResult[]>;
+    /**
+  The tool results that have been generated in the last step.
+  
+  Automatically consumes the stream.
+     */
+    readonly toolResults: PromiseLike<TypedToolResult<TOOLS>[]>;
+    /**
+     * The unified finish reason why the generation finished. Taken from the last step.
+     *
+     * Automatically consumes the stream.
+     */
+    readonly finishReason: PromiseLike<FinishReason>;
+    /**
+     * The raw reason why the generation finished (from the provider). Taken from the last step.
+     *
+     * Automatically consumes the stream.
+     */
+    readonly rawFinishReason: PromiseLike<string | undefined>;
+    /**
+  The token usage of the last step.
+  
+  Automatically consumes the stream.
+     */
+    readonly usage: PromiseLike<LanguageModelUsage>;
+    /**
+  The total token usage of the generated response.
+  When there are multiple steps, the usage is the sum of all step usages.
+  
+  Automatically consumes the stream.
+       */
+    readonly totalUsage: PromiseLike<LanguageModelUsage>;
+    /**
+  Warnings from the model provider (e.g. unsupported settings) for the first step.
+  
+  Automatically consumes the stream.
+       */
+    readonly warnings: PromiseLike<CallWarning[] | undefined>;
+    /**
+  Details for all steps.
+  You can use this to get information about intermediate steps,
+  such as the tool calls or the response headers.
+  
+  Automatically consumes the stream.
+     */
+    readonly steps: PromiseLike<Array<StepResult<TOOLS>>>;
+    /**
+  Additional request information from the last step.
+  
+  Automatically consumes the stream.
+   */
+    readonly request: PromiseLike<LanguageModelRequestMetadata>;
+    /**
+  Additional response information from the last step.
+  
+  Automatically consumes the stream.
+   */
+    readonly response: PromiseLike<LanguageModelResponseMetadata & {
+        /**
+  The response messages that were generated during the call. It consists of an assistant message,
+  potentially containing tool calls.
+  
+  When there are tool results, there is an additional tool message with the tool results that are available.
+  If there are tools that do not have execute functions, they are not included in the tool results and
+  need to be added separately.
+         */
+        messages: Array<ResponseMessage>;
+    }>;
+    /**
+  Additional provider-specific metadata from the last step.
+  Metadata is passed through from the provider to the AI SDK and
+  enables provider-specific results that can be fully encapsulated in the provider.
+     */
+    readonly providerMetadata: PromiseLike<ProviderMetadata | undefined>;
+    /**
+    A text stream that returns only the generated text deltas. You can use it
+    as either an AsyncIterable or a ReadableStream. When an error occurs, the
+    stream will throw the error.
+       */
+    readonly textStream: AsyncIterableStream<string>;
+    /**
+    A stream with all events, including text deltas, tool calls, tool results, and
+    errors.
+    You can use it as either an AsyncIterable or a ReadableStream.
+    Only errors that stop the stream, such as network errors, are thrown.
+       */
+    readonly fullStream: AsyncIterableStream<TextStreamPart<TOOLS>>;
+    /**
+     * A stream of partial outputs. It uses the `output` specification.
+     *
+     * @deprecated Use `partialOutputStream` instead.
+     */
+    readonly experimental_partialOutputStream: AsyncIterableStream<InferPartialOutput<OUTPUT>>;
+    /**
+     * A stream of partial parsed outputs. It uses the `output` specification.
+     */
+    readonly partialOutputStream: AsyncIterableStream<InferPartialOutput<OUTPUT>>;
+    /**
+     * A stream of individual array elements as they complete.
+     * Only available when using `output: Output.array()`.
+     */
+    readonly elementStream: AsyncIterableStream<InferElementOutput<OUTPUT>>;
+    /**
+     * The complete parsed output. It uses the `output` specification.
+     */
+    readonly output: PromiseLike<InferCompleteOutput<OUTPUT>>;
+    /**
+  Consumes the stream without processing the parts.
+  This is useful to force the stream to finish.
+  It effectively removes the backpressure and allows the stream to finish,
+  triggering the `onFinish` callback and the promise resolution.
+  
+  If an error occurs, it is passed to the optional `onError` callback.
+    */
+    consumeStream(options?: ConsumeStreamOptions): PromiseLike<void>;
+    /**
+  Converts the result to a UI message stream.
+  
+  @return A UI message stream.
+       */
+    toUIMessageStream<UI_MESSAGE extends UIMessage>(options?: UIMessageStreamOptions<UI_MESSAGE>): AsyncIterableStream<InferUIMessageChunk<UI_MESSAGE>>;
+    /**
+     *Writes UI message stream output to a Node.js response-like object.
+     */
+    pipeUIMessageStreamToResponse<UI_MESSAGE extends UIMessage>(response: ServerResponse, options?: UIMessageStreamResponseInit & UIMessageStreamOptions<UI_MESSAGE>): void;
+    /**
+  Writes text delta output to a Node.js response-like object.
+  It sets a `Content-Type` header to `text/plain; charset=utf-8` and
+  writes each text delta as a separate chunk.
+  
+  @param response A Node.js response-like object (ServerResponse).
+  @param init Optional headers, status code, and status text.
+       */
+    pipeTextStreamToResponse(response: ServerResponse, init?: ResponseInit): void;
+    /**
+  Converts the result to a streamed response object with a stream data part stream.
+  
+  @return A response object.
+       */
+    toUIMessageStreamResponse<UI_MESSAGE extends UIMessage>(options?: UIMessageStreamResponseInit & UIMessageStreamOptions<UI_MESSAGE>): Response;
+    /**
+    Creates a simple text stream response.
+    Each text delta is encoded as UTF-8 and sent as a separate chunk.
+    Non-text-delta events are ignored.
+    @param init Optional headers, status code, and status text.
+       */
+    toTextStreamResponse(init?: ResponseInit): Response;
+}
+type TextStreamPart<TOOLS extends ToolSet> = {
     type: 'text-start';
     id: string;
     providerMetadata?: ProviderMetadata;
-} | {
-    type: 'text-delta';
-    delta: string;
-    id: string;
-    providerMetadata?: ProviderMetadata;
 } | {
     type: 'text-end';
     id: string;
     providerMetadata?: ProviderMetadata;
 } | {
-    type: 'reasoning-start';
+    type: 'text-delta';
     id: string;
     providerMetadata?: ProviderMetadata;
+    text: string;
 } | {
-    type: 'reasoning-delta';
+    type: 'reasoning-start';
     id: string;
-    delta: string;
     providerMetadata?: ProviderMetadata;
 } | {
     type: 'reasoning-end';
     id: string;
     providerMetadata?: ProviderMetadata;
 } | {
-    type: 'error';
-    errorText: string;
-} | {
-    type: 'tool-input-available';
-    toolCallId: string;
-    toolName: string;
-    input: unknown;
-    providerExecuted?: boolean;
-    providerMetadata?: ProviderMetadata;
-    dynamic?: boolean;
-    title?: string;
-} | {
-    type: 'tool-input-error';
-    toolCallId: string;
-    toolName: string;
-    input: unknown;
-    providerExecuted?: boolean;
+    type: 'reasoning-delta';
     providerMetadata?: ProviderMetadata;
-    dynamic?: boolean;
-    errorText: string;
-    title?: string;
-} | {
-    type: 'tool-approval-request';
-    approvalId: string;
-    toolCallId: string;
-} | {
-    type: 'tool-output-available';
-    toolCallId: string;
-    output: unknown;
-    providerExecuted?: boolean;
-    dynamic?: boolean;
-    preliminary?: boolean;
-} | {
-    type: 'tool-output-error';
-    toolCallId: string;
-    errorText: string;
-    providerExecuted?: boolean;
-    dynamic?: boolean;
-} | {
-    type: 'tool-output-denied';
-    toolCallId: string;
+    id: string;
+    text: string;
 } | {
     type: 'tool-input-start';
-    toolCallId: string;
+    id: string;
     toolName: string;
+    providerMetadata?: ProviderMetadata;
     providerExecuted?: boolean;
     dynamic?: boolean;
     title?: string;
 } | {
-    type: 'tool-input-delta';
-    toolCallId: string;
-    inputTextDelta: string;
-} | {
-    type: 'source-url';
-    sourceId: string;
-    url: string;
-    title?: string;
+    type: 'tool-input-end';
+    id: string;
     providerMetadata?: ProviderMetadata;
 } | {
-    type: 'source-document';
-    sourceId: string;
-    mediaType: string;
-    title: string;
-    filename?: string;
+    type: 'tool-input-delta';
+    id: string;
+    delta: string;
     providerMetadata?: ProviderMetadata;
-} | {
+} | ({
+    type: 'source';
+} & Source) | {
     type: 'file';
-    url: string;
-    mediaType: string;
-    providerMetadata?: ProviderMetadata;
-} | DataUIMessageChunk<DATA_TYPES> | {
+    file: GeneratedFile;
+} | ({
+    type: 'tool-call';
+} & TypedToolCall<TOOLS>) | ({
+    type: 'tool-result';
+} & TypedToolResult<TOOLS>) | ({
+    type: 'tool-error';
+} & TypedToolError<TOOLS>) | ({
+    type: 'tool-output-denied';
+} & StaticToolOutputDenied<TOOLS>) | ToolApprovalRequestOutput<TOOLS> | {
     type: 'start-step';
+    request: LanguageModelRequestMetadata;
+    warnings: CallWarning[];
 } | {
     type: 'finish-step';
+    response: LanguageModelResponseMetadata;
+    usage: LanguageModelUsage;
+    finishReason: FinishReason;
+    rawFinishReason: string | undefined;
+    providerMetadata: ProviderMetadata | undefined;
 } | {
     type: 'start';
-    messageId?: string;
-    messageMetadata?: METADATA;
 } | {
     type: 'finish';
-    finishReason?: FinishReason;
-    messageMetadata?: METADATA;
+    finishReason: FinishReason;
+    rawFinishReason: string | undefined;
+    totalUsage: LanguageModelUsage;
 } | {
     type: 'abort';
     reason?: string;
 } | {
-    type: 'message-metadata';
-    messageMetadata: METADATA;
+    type: 'error';
+    error: unknown;
+} | {
+    type: 'raw';
+    rawValue: unknown;
 };
-type InferUIMessageChunk<T extends UIMessage> = UIMessageChunk<InferUIMessageMetadata<T>, InferUIMessageData<T>>;
 
-type UIMessageStreamOnFinishCallback<UI_MESSAGE extends UIMessage> = (event: {
-    /**
-     * The updated list of UI messages.
-     */
-    messages: UI_MESSAGE[];
+/**
+A transformation that is applied to the stream.
+
+@param stopStream - A function that stops the source stream.
+@param tools - The tools that are accessible to and can be called by the model. The model needs to support calling tools.
+ */
+type StreamTextTransform<TOOLS extends ToolSet> = (options: {
+    tools: TOOLS;
+    stopStream: () => void;
+}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
+/**
+Callback that is set using the `onError` option.
+
+@param event - The event that is passed to the callback.
+ */
+type StreamTextOnErrorCallback = (event: {
+    error: unknown;
+}) => PromiseLike<void> | void;
+/**
+Callback that is set using the `onStepFinish` option.
+
+@param stepResult - The result of the step.
+ */
+type StreamTextOnStepFinishCallback<TOOLS extends ToolSet> = (stepResult: StepResult<TOOLS>) => PromiseLike<void> | void;
+/**
+Callback that is set using the `onChunk` option.
+
+@param event - The event that is passed to the callback.
+ */
+type StreamTextOnChunkCallback<TOOLS extends ToolSet> = (event: {
+    chunk: Extract<TextStreamPart<TOOLS>, {
+        type: 'text-delta' | 'reasoning-delta' | 'source' | 'tool-call' | 'tool-input-start' | 'tool-input-delta' | 'tool-result' | 'raw';
+    }>;
+}) => PromiseLike<void> | void;
+/**
+Callback that is set using the `onFinish` option.
+
+@param event - The event that is passed to the callback.
+ */
+type StreamTextOnFinishCallback<TOOLS extends ToolSet> = (event: StepResult<TOOLS> & {
     /**
-     * Indicates whether the response message is a continuation of the last original message,
-     * or if a new message was created.
+     * Details for all steps.
      */
-    isContinuation: boolean;
+    readonly steps: StepResult<TOOLS>[];
     /**
-     * Indicates whether the stream was aborted.
+     * Total usage for all steps. This is the sum of the usage of all steps.
      */
-    isAborted: boolean;
+    readonly totalUsage: LanguageModelUsage;
     /**
-     * The message that was sent to the client as a response
-     * (including the original message if it was extended).
+     * Context that is passed into tool execution.
+     *
+     * Experimental (can break in patch releases).
+     *
+     * @default undefined
      */
-    responseMessage: UI_MESSAGE;
+    experimental_context: unknown;
+}) => PromiseLike<void> | void;
+/**
+Callback that is set using the `onAbort` option.
+
+@param event - The event that is passed to the callback.
+ */
+type StreamTextOnAbortCallback<TOOLS extends ToolSet> = (event: {
     /**
-     * The reason why the generation finished.
+  Details for all previously finished steps.
      */
-    finishReason?: FinishReason;
+    readonly steps: StepResult<TOOLS>[];
 }) => PromiseLike<void> | void;
+/**
+Generate a text and call tools for a given prompt using a language model.
 
-type UIMessageStreamResponseInit = ResponseInit & {
-    consumeSseStream?: (options: {
-        stream: ReadableStream<string>;
-    }) => PromiseLike<void> | void;
-};
+This function streams the output. If you do not want to stream the output, use `generateText` instead.
 
-/**
- * A type that combines AsyncIterable and ReadableStream.
- * This allows a ReadableStream to be consumed using for-await-of syntax.
- */
-type AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
+@param model - The language model to use.
+@param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
 
-type ErrorHandler = (error: unknown) => void;
+@param system - A system message that will be part of the prompt.
+@param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
+@param messages - A list of messages. You can either use `prompt` or `messages` but not both.
 
-type UIMessageStreamOptions<UI_MESSAGE extends UIMessage> = {
-    /**
-     * The original messages. If they are provided, persistence mode is assumed,
-     * and a message ID is provided for the response message.
-     */
-    originalMessages?: UI_MESSAGE[];
-    /**
-     * Generate a message ID for the response message.
-     *
-     * If not provided, no message ID will be set for the response message (unless
-     * the original messages are provided and the last message is an assistant message).
-     */
-    generateMessageId?: IdGenerator;
-    onFinish?: UIMessageStreamOnFinishCallback<UI_MESSAGE>;
+@param maxOutputTokens - Maximum number of tokens to generate.
+@param temperature - Temperature setting.
+The value is passed through to the provider. The range depends on the provider and model.
+It is recommended to set either `temperature` or `topP`, but not both.
+@param topP - Nucleus sampling.
+The value is passed through to the provider. The range depends on the provider and model.
+It is recommended to set either `temperature` or `topP`, but not both.
+@param topK - Only sample from the top K options for each subsequent token.
+Used to remove "long tail" low probability responses.
+Recommended for advanced use cases only. You usually only need to use temperature.
+@param presencePenalty - Presence penalty setting.
+It affects the likelihood of the model to repeat information that is already in the prompt.
+The value is passed through to the provider. The range depends on the provider and model.
+@param frequencyPenalty - Frequency penalty setting.
+It affects the likelihood of the model to repeatedly use the same words or phrases.
+The value is passed through to the provider. The range depends on the provider and model.
+@param stopSequences - Stop sequences.
+If set, the model will stop generating text when one of the stop sequences is generated.
+@param seed - The seed (integer) to use for random sampling.
+If set and supported by the model, calls will generate deterministic results.
+
+@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+@param abortSignal - An optional abort signal that can be used to cancel the call.
+@param timeout - An optional timeout in milliseconds. The call will be aborted if it takes longer than the specified timeout.
+@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+
+@param onChunk - Callback that is called for each chunk of the stream. The stream processing will pause until the callback promise is resolved.
+@param onError - Callback that is called when an error occurs during streaming. You can use it to log errors.
+@param onStepFinish - Callback that is called when each step (LLM call) is finished, including intermediate steps.
+@param onFinish - Callback that is called when all steps are finished and the response is complete.
+
+@return
+A result object for accessing different stream types and additional information.
+ */
+declare function streamText<TOOLS extends ToolSet, OUTPUT extends Output = Output<string, string, never>>({ model, tools, toolChoice, system, prompt, messages, maxRetries, abortSignal, timeout, headers, stopWhen, experimental_output, output, experimental_telemetry: telemetry, prepareStep, providerOptions, experimental_activeTools, activeTools, experimental_repairToolCall: repairToolCall, experimental_transform: transform, experimental_download: download, includeRawChunks, onChunk, onError, onFinish, onAbort, onStepFinish, experimental_context, _internal: { now, generateId }, ...settings }: CallSettings & Prompt & {
     /**
-     * Extracts message metadata that will be send to the client.
-     *
-     * Called on `start` and `finish` events.
+The language model to use.
      */
-    messageMetadata?: (options: {
-        part: TextStreamPart<ToolSet>;
-    }) => InferUIMessageMetadata<UI_MESSAGE> | undefined;
+    model: LanguageModel;
     /**
-     * Send reasoning parts to the client.
-     * Default to true.
-     */
-    sendReasoning?: boolean;
+The tools that the model can call. The model needs to support calling tools.
+    */
+    tools?: TOOLS;
     /**
-     * Send source parts to the client.
-     * Default to false.
+The tool choice strategy. Default: 'auto'.
      */
-    sendSources?: boolean;
+    toolChoice?: ToolChoice<TOOLS>;
     /**
-     * Send the finish event to the client.
-     * Set to false if you are using additional streamText calls
-     * that send additional data.
-     * Default to true.
+Condition for stopping the generation when there are tool results in the last step.
+When the condition is an array, any of the conditions can be met to stop the generation.
+
+@default stepCountIs(1)
      */
-    sendFinish?: boolean;
+    stopWhen?: StopCondition<NoInfer<TOOLS>> | Array<StopCondition<NoInfer<TOOLS>>>;
     /**
-     * Send the message start event to the client.
-     * Set to false if you are using additional streamText calls
-     * and the message start event has already been sent.
-     * Default to true.
+Optional telemetry configuration (experimental).
      */
-    sendStart?: boolean;
+    experimental_telemetry?: TelemetrySettings;
     /**
-     * Process an error, e.g. to log it. Default to `() => 'An error occurred.'`.
-     *
-     * @return error message to include in the data stream.
-     */
-    onError?: (error: unknown) => string;
-};
-type ConsumeStreamOptions = {
-    onError?: ErrorHandler;
-};
-/**
-A result object for accessing different stream types and additional information.
+Additional provider-specific options. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
  */
-interface StreamTextResult<TOOLS extends ToolSet, OUTPUT extends Output> {
+    providerOptions?: ProviderOptions;
     /**
-  The content that was generated in the last step.
-  
-  Automatically consumes the stream.
+     * @deprecated Use `activeTools` instead.
      */
-    readonly content: PromiseLike<Array<ContentPart<TOOLS>>>;
+    experimental_activeTools?: Array<keyof NoInfer<TOOLS>>;
     /**
-  The full text that has been generated by the last step.
-  
-  Automatically consumes the stream.
-       */
-    readonly text: PromiseLike<string>;
+   Limits the tools that are available for the model to call without
+   changing the tool call and result types in the result.
+        */
+    activeTools?: Array<keyof NoInfer<TOOLS>>;
     /**
-  The full reasoning that the model has generated.
-  
-  Automatically consumes the stream.
+Optional specification for parsing structured outputs from the LLM response.
      */
-    readonly reasoning: PromiseLike<Array<ReasoningOutput>>;
+    output?: OUTPUT;
     /**
-  The reasoning that has been generated by the last step.
-  
-  Automatically consumes the stream.
-       */
-    readonly reasoningText: PromiseLike<string | undefined>;
+Optional specification for parsing structured outputs from the LLM response.
+
+@deprecated Use `output` instead.
+ */
+    experimental_output?: OUTPUT;
     /**
-  Files that have been generated by the model in the last step.
-  
-  Automatically consumes the stream.
-     */
-    readonly files: PromiseLike<GeneratedFile[]>;
+Optional function that you can use to provide different settings for a step.
+
+@param options - The options for the step.
+@param options.steps - The steps that have been executed so far.
+@param options.stepNumber - The number of the step that is being executed.
+@param options.model - The model that is being used.
+
+@returns An object that contains the settings for the step.
+If you return undefined (or for undefined settings), the settings from the outer level will be used.
+    */
+    prepareStep?: PrepareStepFunction<NoInfer<TOOLS>>;
     /**
-  Sources that have been used as references in the last step.
-  
-  Automatically consumes the stream.
+A function that attempts to repair a tool call that failed to parse.
      */
-    readonly sources: PromiseLike<Source[]>;
-    /**
-  The tool calls that have been executed in the last step.
-  
-  Automatically consumes the stream.
-       */
-    readonly toolCalls: PromiseLike<TypedToolCall<TOOLS>[]>;
-    /**
-  The static tool calls that have been executed in the last step.
-  
-  Automatically consumes the stream.
-       */
-    readonly staticToolCalls: PromiseLike<StaticToolCall<TOOLS>[]>;
-    /**
-  The dynamic tool calls that have been executed in the last step.
-  
-  Automatically consumes the stream.
-       */
-    readonly dynamicToolCalls: PromiseLike<DynamicToolCall[]>;
-    /**
-  The static tool results that have been generated in the last step.
-  
-  Automatically consumes the stream.
-       */
-    readonly staticToolResults: PromiseLike<StaticToolResult<TOOLS>[]>;
-    /**
-  The dynamic tool results that have been generated in the last step.
-  
-  Automatically consumes the stream.
-       */
-    readonly dynamicToolResults: PromiseLike<DynamicToolResult[]>;
+    experimental_repairToolCall?: ToolCallRepairFunction<TOOLS>;
     /**
-  The tool results that have been generated in the last step.
-  
-  Automatically consumes the stream.
+Optional stream transformations.
+They are applied in the order they are provided.
+The stream transformations must maintain the stream structure for streamText to work correctly.
      */
-    readonly toolResults: PromiseLike<TypedToolResult<TOOLS>[]>;
+    experimental_transform?: StreamTextTransform<TOOLS> | Array<StreamTextTransform<TOOLS>>;
     /**
-     * The unified finish reason why the generation finished. Taken from the last step.
-     *
-     * Automatically consumes the stream.
+Custom download function to use for URLs.
+
+By default, files are downloaded if the model does not support the URL for the given media type.
      */
-    readonly finishReason: PromiseLike<FinishReason>;
+    experimental_download?: DownloadFunction | undefined;
     /**
-     * The raw reason why the generation finished (from the provider). Taken from the last step.
-     *
-     * Automatically consumes the stream.
+Whether to include raw chunks from the provider in the stream.
+When enabled, you will receive raw chunks with type 'raw' that contain the unprocessed data from the provider.
+This allows access to cutting-edge provider features not yet wrapped by the AI SDK.
+Defaults to false.
      */
-    readonly rawFinishReason: PromiseLike<string | undefined>;
+    includeRawChunks?: boolean;
     /**
-  The token usage of the last step.
-  
-  Automatically consumes the stream.
+Callback that is called for each chunk of the stream.
+The stream processing will pause until the callback promise is resolved.
      */
-    readonly usage: PromiseLike<LanguageModelUsage>;
-    /**
-  The total token usage of the generated response.
-  When there are multiple steps, the usage is the sum of all step usages.
-  
-  Automatically consumes the stream.
-       */
-    readonly totalUsage: PromiseLike<LanguageModelUsage>;
-    /**
-  Warnings from the model provider (e.g. unsupported settings) for the first step.
-  
-  Automatically consumes the stream.
-       */
-    readonly warnings: PromiseLike<CallWarning[] | undefined>;
+    onChunk?: StreamTextOnChunkCallback<TOOLS>;
     /**
-  Details for all steps.
-  You can use this to get information about intermediate steps,
-  such as the tool calls or the response headers.
-  
-  Automatically consumes the stream.
+Callback that is invoked when an error occurs during streaming.
+You can use it to log errors.
+The stream processing will pause until the callback promise is resolved.
      */
-    readonly steps: PromiseLike<Array<StepResult<TOOLS>>>;
-    /**
-  Additional request information from the last step.
-  
-  Automatically consumes the stream.
-   */
-    readonly request: PromiseLike<LanguageModelRequestMetadata>;
-    /**
-  Additional response information from the last step.
-  
-  Automatically consumes the stream.
-   */
-    readonly response: PromiseLike<LanguageModelResponseMetadata & {
-        /**
-  The response messages that were generated during the call. It consists of an assistant message,
-  potentially containing tool calls.
-  
-  When there are tool results, there is an additional tool message with the tool results that are available.
-  If there are tools that do not have execute functions, they are not included in the tool results and
-  need to be added separately.
-         */
-        messages: Array<ResponseMessage>;
-    }>;
+    onError?: StreamTextOnErrorCallback;
     /**
-  Additional provider-specific metadata from the last step.
-  Metadata is passed through from the provider to the AI SDK and
-  enables provider-specific results that can be fully encapsulated in the provider.
+Callback that is called when the LLM response and all request tool executions
+(for tools that have an `execute` function) are finished.
+
+The usage is the combined usage of all steps.
      */
-    readonly providerMetadata: PromiseLike<ProviderMetadata | undefined>;
-    /**
-    A text stream that returns only the generated text deltas. You can use it
-    as either an AsyncIterable or a ReadableStream. When an error occurs, the
-    stream will throw the error.
-       */
-    readonly textStream: AsyncIterableStream<string>;
+    onFinish?: StreamTextOnFinishCallback<TOOLS>;
+    onAbort?: StreamTextOnAbortCallback<TOOLS>;
     /**
-    A stream with all events, including text deltas, tool calls, tool results, and
-    errors.
-    You can use it as either an AsyncIterable or a ReadableStream.
-    Only errors that stop the stream, such as network errors, are thrown.
-       */
-    readonly fullStream: AsyncIterableStream<TextStreamPart<TOOLS>>;
+Callback that is called when each step (LLM call) is finished, including intermediate steps.
+    */
+    onStepFinish?: StreamTextOnStepFinishCallback<TOOLS>;
     /**
-     * A stream of partial outputs. It uses the `output` specification.
+     * Context that is passed into tool execution.
      *
-     * @deprecated Use `partialOutputStream` instead.
+     * Experimental (can break in patch releases).
+     *
+     * @default undefined
      */
-    readonly experimental_partialOutputStream: AsyncIterableStream<InferPartialOutput<OUTPUT>>;
+    experimental_context?: unknown;
     /**
-     * A stream of partial parsed outputs. It uses the `output` specification.
+Internal. For test use only. May change without notice.
      */
-    readonly partialOutputStream: AsyncIterableStream<InferPartialOutput<OUTPUT>>;
+    _internal?: {
+        now?: () => number;
+        generateId?: IdGenerator;
+    };
+}): StreamTextResult<TOOLS, OUTPUT>;
+type EnrichedStreamPart<TOOLS extends ToolSet, PARTIAL_OUTPUT> = {
+    part: TextStreamPart<TOOLS>;
+    partialOutput: PARTIAL_OUTPUT | undefined;
+};
+
+interface Output<OUTPUT = any, PARTIAL = any, ELEMENT = any> {
     /**
-     * The complete parsed output. It uses the `output` specification.
+     * The name of the output mode.
      */
-    readonly output: PromiseLike<InferCompleteOutput<OUTPUT>>;
-    /**
-  Consumes the stream without processing the parts.
-  This is useful to force the stream to finish.
-  It effectively removes the backpressure and allows the stream to finish,
-  triggering the `onFinish` callback and the promise resolution.
-  
-  If an error occurs, it is passed to the optional `onError` callback.
-    */
-    consumeStream(options?: ConsumeStreamOptions): PromiseLike<void>;
+    name: string;
     /**
-  Converts the result to a UI message stream.
-  
-  @return A UI message stream.
-       */
-    toUIMessageStream<UI_MESSAGE extends UIMessage>(options?: UIMessageStreamOptions<UI_MESSAGE>): AsyncIterableStream<InferUIMessageChunk<UI_MESSAGE>>;
-    /**
-     *Writes UI message stream output to a Node.js response-like object.
+     * The response format to use for the model.
      */
-    pipeUIMessageStreamToResponse<UI_MESSAGE extends UIMessage>(response: ServerResponse, options?: UIMessageStreamResponseInit & UIMessageStreamOptions<UI_MESSAGE>): void;
+    responseFormat: PromiseLike<LanguageModelV3CallOptions['responseFormat']>;
     /**
-  Writes text delta output to a Node.js response-like object.
-  It sets a `Content-Type` header to `text/plain; charset=utf-8` and
-  writes each text delta as a separate chunk.
-  
-  @param response A Node.js response-like object (ServerResponse).
-  @param init Optional headers, status code, and status text.
-       */
-    pipeTextStreamToResponse(response: ServerResponse, init?: ResponseInit): void;
+     * Parses the complete output of the model.
+     */
+    parseCompleteOutput(options: {
+        text: string;
+    }, context: {
+        response: LanguageModelResponseMetadata;
+        usage: LanguageModelUsage;
+        finishReason: FinishReason;
+    }): Promise<OUTPUT>;
     /**
-  Converts the result to a streamed response object with a stream data part stream.
-  
-  @return A response object.
-       */
-    toUIMessageStreamResponse<UI_MESSAGE extends UIMessage>(options?: UIMessageStreamResponseInit & UIMessageStreamOptions<UI_MESSAGE>): Response;
+     * Parses the partial output of the model.
+     */
+    parsePartialOutput(options: {
+        text: string;
+    }): Promise<{
+        partial: PARTIAL;
+    } | undefined>;
     /**
-    Creates a simple text stream response.
-    Each text delta is encoded as UTF-8 and sent as a separate chunk.
-    Non-text-delta events are ignored.
-    @param init Optional headers, status code, and status text.
-       */
-    toTextStreamResponse(init?: ResponseInit): Response;
+     * Creates a stream transform that emits individual elements as they complete.
+     */
+    createElementStreamTransform(): TransformStream<EnrichedStreamPart<any, PARTIAL>, ELEMENT> | undefined;
 }
-type TextStreamPart<TOOLS extends ToolSet> = {
-    type: 'text-start';
-    id: string;
-    providerMetadata?: ProviderMetadata;
-} | {
-    type: 'text-end';
-    id: string;
-    providerMetadata?: ProviderMetadata;
-} | {
-    type: 'text-delta';
-    id: string;
-    providerMetadata?: ProviderMetadata;
-    text: string;
-} | {
-    type: 'reasoning-start';
-    id: string;
-    providerMetadata?: ProviderMetadata;
-} | {
-    type: 'reasoning-end';
-    id: string;
-    providerMetadata?: ProviderMetadata;
-} | {
-    type: 'reasoning-delta';
-    providerMetadata?: ProviderMetadata;
-    id: string;
-    text: string;
-} | {
-    type: 'tool-input-start';
-    id: string;
-    toolName: string;
-    providerMetadata?: ProviderMetadata;
-    providerExecuted?: boolean;
-    dynamic?: boolean;
-    title?: string;
-} | {
-    type: 'tool-input-end';
-    id: string;
-    providerMetadata?: ProviderMetadata;
-} | {
-    type: 'tool-input-delta';
-    id: string;
-    delta: string;
-    providerMetadata?: ProviderMetadata;
-} | ({
-    type: 'source';
-} & Source) | {
-    type: 'file';
-    file: GeneratedFile;
-} | ({
-    type: 'tool-call';
-} & TypedToolCall<TOOLS>) | ({
-    type: 'tool-result';
-} & TypedToolResult<TOOLS>) | ({
-    type: 'tool-error';
-} & TypedToolError<TOOLS>) | ({
-    type: 'tool-output-denied';
-} & StaticToolOutputDenied<TOOLS>) | ToolApprovalRequestOutput<TOOLS> | {
-    type: 'start-step';
-    request: LanguageModelRequestMetadata;
-    warnings: CallWarning[];
-} | {
-    type: 'finish-step';
-    response: LanguageModelResponseMetadata;
-    usage: LanguageModelUsage;
-    finishReason: FinishReason;
-    rawFinishReason: string | undefined;
-    providerMetadata: ProviderMetadata | undefined;
-} | {
-    type: 'start';
-} | {
-    type: 'finish';
-    finishReason: FinishReason;
-    rawFinishReason: string | undefined;
-    totalUsage: LanguageModelUsage;
-} | {
-    type: 'abort';
-    reason?: string;
-} | {
-    type: 'error';
-    error: unknown;
-} | {
-    type: 'raw';
-    rawValue: unknown;
-};
-
-/**
-A transformation that is applied to the stream.
-
-@param stopStream - A function that stops the source stream.
-@param tools - The tools that are accessible to and can be called by the model. The model needs to support calling tools.
- */
-type StreamTextTransform<TOOLS extends ToolSet> = (options: {
-    tools: TOOLS;
-    stopStream: () => void;
-}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
-/**
-Callback that is set using the `onError` option.
-
-@param event - The event that is passed to the callback.
- */
-type StreamTextOnErrorCallback = (event: {
-    error: unknown;
-}) => PromiseLike<void> | void;
 /**
-Callback that is set using the `onStepFinish` option.
-
-@param stepResult - The result of the step.
+ * Output specification for text generation.
+ * This is the default output mode that generates plain text.
+ *
+ * @returns An output specification for generating text.
  */
-type StreamTextOnStepFinishCallback<TOOLS extends ToolSet> = (stepResult: StepResult<TOOLS>) => PromiseLike<void> | void;
+declare const text: () => Output<string, string, never>;
 /**
-Callback that is set using the `onChunk` option.
-
-@param event - The event that is passed to the callback.
+ * Output specification for typed object generation using schemas.
+ * When the model generates a text response, it will return an object that matches the schema.
+ *
+ * @param schema - The schema of the object to generate.
+ * @param name - Optional name of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema name.
+ * @param description - Optional description of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema description.
+ *
+ * @returns An output specification for generating objects with the specified schema.
  */
-type StreamTextOnChunkCallback<TOOLS extends ToolSet> = (event: {
-    chunk: Extract<TextStreamPart<TOOLS>, {
-        type: 'text-delta' | 'reasoning-delta' | 'source' | 'tool-call' | 'tool-input-start' | 'tool-input-delta' | 'tool-result' | 'raw';
-    }>;
-}) => PromiseLike<void> | void;
+declare const object: <OBJECT>({ schema: inputSchema, name, description, }: {
+    schema: FlexibleSchema<OBJECT>;
+    /**
+     * Optional name of the output that should be generated.
+     * Used by some providers for additional LLM guidance, e.g. via tool or schema name.
+     */
+    name?: string;
+    /**
+     * Optional description of the output that should be generated.
+     * Used by some providers for additional LLM guidance, e.g. via tool or schema description.
+     */
+    description?: string;
+}) => Output<OBJECT, DeepPartial<OBJECT>, never>;
 /**
-Callback that is set using the `onFinish` option.
-
-@param event - The event that is passed to the callback.
+ * Output specification for array generation.
+ * When the model generates a text response, it will return an array of elements.
+ *
+ * @param element - The schema of the array elements to generate.
+ * @param name - Optional name of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema name.
+ * @param description - Optional description of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema description.
+ *
+ * @returns An output specification for generating an array of elements.
  */
-type StreamTextOnFinishCallback<TOOLS extends ToolSet> = (event: StepResult<TOOLS> & {
+declare const array: <ELEMENT>({ element: inputElementSchema, name, description, }: {
+    element: FlexibleSchema<ELEMENT>;
     /**
-     * Details for all steps.
+     * Optional name of the output that should be generated.
+     * Used by some providers for additional LLM guidance, e.g. via tool or schema name.
      */
-    readonly steps: StepResult<TOOLS>[];
+    name?: string;
     /**
-     * Total usage for all steps. This is the sum of the usage of all steps.
+     * Optional description of the output that should be generated.
+     * Used by some providers for additional LLM guidance, e.g. via tool or schema description.
      */
-    readonly totalUsage: LanguageModelUsage;
+    description?: string;
+}) => Output<Array<ELEMENT>, Array<ELEMENT>, ELEMENT>;
+/**
+ * Output specification for choice generation.
+ * When the model generates a text response, it will return a one of the choice options.
+ *
+ * @param options - The available choices.
+ * @param name - Optional name of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema name.
+ * @param description - Optional description of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema description.
+ *
+ * @returns An output specification for generating a choice.
+ */
+declare const choice: <CHOICE extends string>({ options: choiceOptions, name, description, }: {
+    options: Array<CHOICE>;
     /**
-     * Context that is passed into tool execution.
-     *
-     * Experimental (can break in patch releases).
-     *
-     * @default undefined
+     * Optional name of the output that should be generated.
+     * Used by some providers for additional LLM guidance, e.g. via tool or schema name.
+     */
+    name?: string;
+    /**
+     * Optional description of the output that should be generated.
+     * Used by some providers for additional LLM guidance, e.g. via tool or schema description.
      */
-    experimental_context: unknown;
-}) => PromiseLike<void> | void;
+    description?: string;
+}) => Output<CHOICE, CHOICE, never>;
 /**
-Callback that is set using the `onAbort` option.
-
-@param event - The event that is passed to the callback.
+ * Output specification for unstructured JSON generation.
+ * When the model generates a text response, it will return a JSON object.
+ *
+ * @param name - Optional name of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema name.
+ * @param description - Optional description of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema description.
+ *
+ * @returns An output specification for generating JSON.
  */
-type StreamTextOnAbortCallback<TOOLS extends ToolSet> = (event: {
+declare const json: ({ name, description, }?: {
     /**
-  Details for all previously finished steps.
+     * Optional name of the output that should be generated.
+     * Used by some providers for additional LLM guidance, e.g. via tool or schema name.
      */
-    readonly steps: StepResult<TOOLS>[];
-}) => PromiseLike<void> | void;
-/**
-Generate a text and call tools for a given prompt using a language model.
-
-This function streams the output. If you do not want to stream the output, use `generateText` instead.
-
-@param model - The language model to use.
-@param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
-
-@param system - A system message that will be part of the prompt.
-@param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
-@param messages - A list of messages. You can either use `prompt` or `messages` but not both.
-
-@param maxOutputTokens - Maximum number of tokens to generate.
-@param temperature - Temperature setting.
-The value is passed through to the provider. The range depends on the provider and model.
-It is recommended to set either `temperature` or `topP`, but not both.
-@param topP - Nucleus sampling.
-The value is passed through to the provider. The range depends on the provider and model.
-It is recommended to set either `temperature` or `topP`, but not both.
-@param topK - Only sample from the top K options for each subsequent token.
-Used to remove "long tail" low probability responses.
-Recommended for advanced use cases only. You usually only need to use temperature.
-@param presencePenalty - Presence penalty setting.
-It affects the likelihood of the model to repeat information that is already in the prompt.
-The value is passed through to the provider. The range depends on the provider and model.
-@param frequencyPenalty - Frequency penalty setting.
-It affects the likelihood of the model to repeatedly use the same words or phrases.
-The value is passed through to the provider. The range depends on the provider and model.
-@param stopSequences - Stop sequences.
-If set, the model will stop generating text when one of the stop sequences is generated.
-@param seed - The seed (integer) to use for random sampling.
-If set and supported by the model, calls will generate deterministic results.
-
-@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
-@param abortSignal - An optional abort signal that can be used to cancel the call.
-@param timeout - An optional timeout in milliseconds. The call will be aborted if it takes longer than the specified timeout.
-@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+    name?: string;
+    /**
+     * Optional description of the output that should be generated.
+     * Used by some providers for additional LLM guidance, e.g. via tool or schema description.
+     */
+    description?: string;
+}) => Output<JSONValue$1, JSONValue$1, never>;
 
-@param onChunk - Callback that is called for each chunk of the stream. The stream processing will pause until the callback promise is resolved.
-@param onError - Callback that is called when an error occurs during streaming. You can use it to log errors.
-@param onStepFinish - Callback that is called when each step (LLM call) is finished, including intermediate steps.
-@param onFinish - Callback that is called when all steps are finished and the response is complete.
+type output_Output<OUTPUT = any, PARTIAL = any, ELEMENT = any> = Output<OUTPUT, PARTIAL, ELEMENT>;
+declare const output_array: typeof array;
+declare const output_choice: typeof choice;
+declare const output_json: typeof json;
+declare const output_object: typeof object;
+declare const output_text: typeof text;
+declare namespace output {
+  export {
+    output_Output as Output,
+    output_array as array,
+    output_choice as choice,
+    output_json as json,
+    output_object as object,
+    output_text as text,
+  };
+}
 
-@return
-A result object for accessing different stream types and additional information.
+/**
+The result of a `generateText` call.
+It contains the generated text, the tool calls that were made during the generation, and the results of the tool calls.
  */
-declare function streamText<TOOLS extends ToolSet, OUTPUT extends Output = Output<string, string>>({ model, tools, toolChoice, system, prompt, messages, maxRetries, abortSignal, timeout, headers, stopWhen, experimental_output, output, experimental_telemetry: telemetry, prepareStep, providerOptions, experimental_activeTools, activeTools, experimental_repairToolCall: repairToolCall, experimental_transform: transform, experimental_download: download, includeRawChunks, onChunk, onError, onFinish, onAbort, onStepFinish, experimental_context, _internal: { now, generateId }, ...settings }: CallSettings & Prompt & {
+interface GenerateTextResult<TOOLS extends ToolSet, OUTPUT extends Output> {
     /**
-The language model to use.
+  The content that was generated in the last step.
      */
-    model: LanguageModel;
+    readonly content: Array<ContentPart<TOOLS>>;
     /**
-The tools that the model can call. The model needs to support calling tools.
-    */
-    tools?: TOOLS;
+  The text that was generated in the last step.
+       */
+    readonly text: string;
     /**
-The tool choice strategy. Default: 'auto'.
+  The full reasoning that the model has generated in the last step.
      */
-    toolChoice?: ToolChoice<TOOLS>;
+    readonly reasoning: Array<ReasoningOutput>;
     /**
-Condition for stopping the generation when there are tool results in the last step.
-When the condition is an array, any of the conditions can be met to stop the generation.
-
-@default stepCountIs(1)
+  The reasoning text that the model has generated in the last step. Can be undefined if the model
+  has only generated text.
      */
-    stopWhen?: StopCondition<NoInfer<TOOLS>> | Array<StopCondition<NoInfer<TOOLS>>>;
+    readonly reasoningText: string | undefined;
     /**
-Optional telemetry configuration (experimental).
+  The files that were generated in the last step.
+  Empty array if no files were generated.
+       */
+    readonly files: Array<GeneratedFile>;
+    /**
+  Sources that have been used as references in the last step.
      */
-    experimental_telemetry?: TelemetrySettings;
+    readonly sources: Array<Source>;
     /**
-Additional provider-specific options. They are passed through
-to the provider from the AI SDK and enable provider-specific
-functionality that can be fully encapsulated in the provider.
- */
-    providerOptions?: ProviderOptions;
+  The tool calls that were made in the last step.
+     */
+    readonly toolCalls: Array<TypedToolCall<TOOLS>>;
     /**
-     * @deprecated Use `activeTools` instead.
+  The static tool calls that were made in the last step.
      */
-    experimental_activeTools?: Array<keyof NoInfer<TOOLS>>;
+    readonly staticToolCalls: Array<StaticToolCall<TOOLS>>;
     /**
-   Limits the tools that are available for the model to call without
-   changing the tool call and result types in the result.
-        */
-    activeTools?: Array<keyof NoInfer<TOOLS>>;
+  The dynamic tool calls that were made in the last step.
+     */
+    readonly dynamicToolCalls: Array<DynamicToolCall>;
     /**
-Optional specification for parsing structured outputs from the LLM response.
+  The results of the tool calls from the last step.
      */
-    output?: OUTPUT;
+    readonly toolResults: Array<TypedToolResult<TOOLS>>;
     /**
-Optional specification for parsing structured outputs from the LLM response.
-
-@deprecated Use `output` instead.
- */
-    experimental_output?: OUTPUT;
+  The static tool results that were made in the last step.
+     */
+    readonly staticToolResults: Array<StaticToolResult<TOOLS>>;
     /**
-Optional function that you can use to provide different settings for a step.
-
-@param options - The options for the step.
-@param options.steps - The steps that have been executed so far.
-@param options.stepNumber - The number of the step that is being executed.
-@param options.model - The model that is being used.
-
-@returns An object that contains the settings for the step.
-If you return undefined (or for undefined settings), the settings from the outer level will be used.
-    */
-    prepareStep?: PrepareStepFunction<NoInfer<TOOLS>>;
+  The dynamic tool results that were made in the last step.
+     */
+    readonly dynamicToolResults: Array<DynamicToolResult>;
     /**
-A function that attempts to repair a tool call that failed to parse.
+     * The unified reason why the generation finished.
      */
-    experimental_repairToolCall?: ToolCallRepairFunction<TOOLS>;
+    readonly finishReason: FinishReason;
     /**
-Optional stream transformations.
-They are applied in the order they are provided.
-The stream transformations must maintain the stream structure for streamText to work correctly.
+     * The raw reason why the generation finished (from the provider).
      */
-    experimental_transform?: StreamTextTransform<TOOLS> | Array<StreamTextTransform<TOOLS>>;
+    readonly rawFinishReason: string | undefined;
     /**
-Custom download function to use for URLs.
-
-By default, files are downloaded if the model does not support the URL for the given media type.
+  The token usage of the last step.
      */
-    experimental_download?: DownloadFunction | undefined;
+    readonly usage: LanguageModelUsage;
     /**
-Whether to include raw chunks from the provider in the stream.
-When enabled, you will receive raw chunks with type 'raw' that contain the unprocessed data from the provider.
-This allows access to cutting-edge provider features not yet wrapped by the AI SDK.
-Defaults to false.
+  The total token usage of all steps.
+  When there are multiple steps, the usage is the sum of all step usages.
      */
-    includeRawChunks?: boolean;
+    readonly totalUsage: LanguageModelUsage;
     /**
-Callback that is called for each chunk of the stream.
-The stream processing will pause until the callback promise is resolved.
+  Warnings from the model provider (e.g. unsupported settings)
      */
-    onChunk?: StreamTextOnChunkCallback<TOOLS>;
+    readonly warnings: CallWarning[] | undefined;
     /**
-Callback that is invoked when an error occurs during streaming.
-You can use it to log errors.
-The stream processing will pause until the callback promise is resolved.
+  Additional request information.
      */
-    onError?: StreamTextOnErrorCallback;
+    readonly request: LanguageModelRequestMetadata;
     /**
-Callback that is called when the LLM response and all request tool executions
-(for tools that have an `execute` function) are finished.
-
-The usage is the combined usage of all steps.
+  Additional response information.
      */
-    onFinish?: StreamTextOnFinishCallback<TOOLS>;
-    onAbort?: StreamTextOnAbortCallback<TOOLS>;
+    readonly response: LanguageModelResponseMetadata & {
+        /**
+    The response messages that were generated during the call. It consists of an assistant message,
+    potentially containing tool calls.
+    
+    When there are tool results, there is an additional tool message with the tool results that are available.
+    If there are tools that do not have execute functions, they are not included in the tool results and
+    need to be added separately.
+           */
+        messages: Array<ResponseMessage>;
+        /**
+    Response body (available only for providers that use HTTP requests).
+         */
+        body?: unknown;
+    };
     /**
-Callback that is called when each step (LLM call) is finished, including intermediate steps.
-    */
-    onStepFinish?: StreamTextOnStepFinishCallback<TOOLS>;
+  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.
+     */
+    readonly providerMetadata: ProviderMetadata | undefined;
     /**
-     * Context that is passed into tool execution.
-     *
-     * Experimental (can break in patch releases).
-     *
-     * @default undefined
+  Details for all steps.
+  You can use this to get information about intermediate steps,
+  such as the tool calls or the response headers.
      */
-    experimental_context?: unknown;
+    readonly steps: Array<StepResult<TOOLS>>;
     /**
-Internal. For test use only. May change without notice.
+  The generated structured output. It uses the `output` specification.
+  
+  @deprecated Use `output` instead.
      */
-    _internal?: {
-        now?: () => number;
-        generateId?: IdGenerator;
-    };
-}): StreamTextResult<TOOLS, OUTPUT>;
+    readonly experimental_output: InferCompleteOutput<OUTPUT>;
+    /**
+  The generated structured output. It uses the `output` specification.
+  
+     */
+    readonly output: InferCompleteOutput<OUTPUT>;
+}
 
 /**
  * Parameters for calling an agent.