ai 3.2.33 → 3.2.34

package/dist/index.d.mts

@@ -3,8 +3,8 @@ export { AssistantMessage, AssistantStatus, ChatRequest, ChatRequestOptions, Cre
 import { EmbeddingModelV1, EmbeddingModelV1Embedding, LanguageModelV1, LanguageModelV1FinishReason, LanguageModelV1LogProbs, LanguageModelV1CallWarning, LanguageModelV1StreamPart } from '@ai-sdk/provider';
 export { APICallError, EmptyResponseBodyError, InvalidArgumentError, InvalidDataContentError, InvalidPromptError, InvalidResponseDataError, InvalidToolArgumentsError, JSONParseError, LoadAPIKeyError, NoObjectGeneratedError, NoSuchToolError, RetryError, ToolCallParseError, TypeValidationError, UnsupportedFunctionalityError, UnsupportedJSONSchemaError } from '@ai-sdk/provider';
 import { z } from 'zod';
-import { ServerResponse } from 'http';
 import { AttributeValue, Span } from '@opentelemetry/api';
+import { ServerResponse } from 'http';
 import { ServerResponse as ServerResponse$1 } from 'node:http';
 import { AssistantStream } from 'openai/lib/AssistantStream';
 import { Run } from 'openai/resources/beta/threads/runs/runs';
@@ -89,6 +89,34 @@ type CoreToolChoice<TOOLS extends Record<string, unknown>> = 'auto' | 'none' | '
 type TokenUsage = CompletionTokenUsage$1;
 type CompletionTokenUsage = CompletionTokenUsage$1;
 
+/**
+The result of a `embed` call.
+It contains the embedding, the value, and additional information.
+ */
+interface EmbedResult<VALUE> {
+    /**
+    The value that was embedded.
+       */
+    readonly value: VALUE;
+    /**
+    The embedding of the value.
+      */
+    readonly embedding: Embedding;
+    /**
+    The embedding token usage.
+      */
+    readonly usage: EmbeddingTokenUsage;
+    /**
+    Optional raw response data.
+       */
+    readonly rawResponse?: {
+        /**
+      Response headers.
+           */
+        headers?: Record<string, string>;
+    };
+}
+
 /**
 Embed a value using an embedding model. The type of the value is defined by the embedding model.
 
@@ -126,40 +154,24 @@ declare function embed<VALUE>({ model, value, maxRetries, abortSignal, headers,
    */
     headers?: Record<string, string>;
 }): Promise<EmbedResult<VALUE>>;
+
 /**
-The result of a `embed` call.
-It contains the embedding, the value, and additional information.
+The result of a `embedMany` call.
+It contains the embeddings, the values, and additional information.
  */
-declare class EmbedResult<VALUE> {
+interface EmbedManyResult<VALUE> {
     /**
-  The value that was embedded.
-     */
-    readonly value: VALUE;
+    The values that were embedded.
+       */
+    readonly values: Array<VALUE>;
     /**
-  The embedding of the value.
-    */
-    readonly embedding: Embedding;
+    The embeddings. They are in the same order as the values.
+      */
+    readonly embeddings: Array<Embedding>;
     /**
-  The embedding token usage.
-    */
+    The embedding token usage.
+      */
     readonly usage: EmbeddingTokenUsage;
-    /**
-  Optional raw response data.
-     */
-    readonly rawResponse?: {
-        /**
-    Response headers.
-         */
-        headers?: Record<string, string>;
-    };
-    constructor(options: {
-        value: VALUE;
-        embedding: Embedding;
-        usage: EmbeddingTokenUsage;
-        rawResponse?: {
-            headers?: Record<string, string>;
-        };
-    });
 }
 
 /**
@@ -203,29 +215,6 @@ declare function embedMany<VALUE>({ model, values, maxRetries, abortSignal, head
    */
     headers?: Record<string, string>;
 }): Promise<EmbedManyResult<VALUE>>;
-/**
-The result of a `embedMany` call.
-It contains the embeddings, the values, and additional information.
- */
-declare class EmbedManyResult<VALUE> {
-    /**
-  The values that were embedded.
-     */
-    readonly values: Array<VALUE>;
-    /**
-  The embeddings. They are in the same order as the values.
-    */
-    readonly embeddings: Array<Embedding>;
-    /**
-  The embedding token usage.
-    */
-    readonly usage: EmbeddingTokenUsage;
-    constructor(options: {
-        values: Array<VALUE>;
-        embeddings: Array<Embedding>;
-        usage: EmbeddingTokenUsage;
-    });
-}
 
 type CallSettings = {
     /**
@@ -251,6 +240,13 @@ type CallSettings = {
      */
     topP?: number;
     /**
+  Only sample from the top K options for each subsequent token.
+  
+  Used to remove "long tail" low probability responses.
+  Recommended for advanced use cases only. You usually only need to use temperature.
+     */
+    topK?: number;
+    /**
   Presence penalty setting. It affects the likelihood of the model to
   repeat information that is already in the prompt.
   
@@ -271,6 +267,12 @@ type CallSettings = {
      */
     frequencyPenalty?: number;
     /**
+  Stop sequences.
+  If set, the model will stop generating text when one of the stop sequences is generated.
+  Providers may have limits on the number of stop sequences.
+     */
+    stopSequences?: string[];
+    /**
   The seed (integer) to use for random sampling. If set and supported
   by the model, calls will generate deterministic results.
      */
@@ -470,6 +472,65 @@ type Prompt = {
     messages?: Array<CoreMessage>;
 };
 
+/**
+ * Telemetry configuration.
+ */
+type TelemetrySettings = {
+    /**
+     * Enable or disable telemetry. Disabled by default while experimental.
+     */
+    isEnabled?: 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>;
+};
+
+/**
+The result of a `generateObject` call.
+ */
+interface GenerateObjectResult<T> {
+    /**
+    The generated object (typed according to the schema).
+       */
+    readonly object: T;
+    /**
+    The reason why the generation finished.
+       */
+    readonly finishReason: FinishReason;
+    /**
+    The token usage of the generated text.
+       */
+    readonly usage: CompletionTokenUsage$1;
+    /**
+    Warnings from the model provider (e.g. unsupported settings)
+       */
+    readonly warnings: CallWarning[] | undefined;
+    /**
+    Optional raw response data.
+       */
+    readonly rawResponse?: {
+        /**
+      Response headers.
+       */
+        headers?: Record<string, string>;
+    };
+    /**
+    Logprobs for the completion.
+    `undefined` if the mode does not support logprobs or if was not enabled
+       */
+    readonly logprobs: LogProbs | undefined;
+    /**
+    Converts the object to a JSON response.
+    The response will have a status code of 200 and a content type of `application/json; charset=utf-8`.
+       */
+    toJsonResponse(init?: ResponseInit): Response;
+}
+
 /**
 Generate a structured, typed object for a given prompt and schema using a language model.
 
@@ -491,6 +552,9 @@ 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.
@@ -507,7 +571,7 @@ If set and supported by the model, calls will generate deterministic results.
 @returns
 A result object that contains the generated object, the finish reason, the token usage, and additional information.
  */
-declare function generateObject<T>({ model, schema, mode, system, prompt, messages, maxRetries, abortSignal, headers, ...settings }: CallSettings & Prompt & {
+declare function generateObject<T>({ model, schema, mode, system, prompt, messages, maxRetries, abortSignal, headers, experimental_telemetry: telemetry, ...settings }: Omit<CallSettings, 'stopSequences'> & Prompt & {
     /**
 The language model to use.
      */
@@ -523,63 +587,33 @@ The Zod schema is converted in a JSON schema and used in one of the following wa
 
 - 'auto': The provider will choose the best mode for the model.
 - 'tool': A tool with the JSON schema as parameters is is provided and the provider is instructed to use it.
-- 'json': The JSON schema and a instruction is injected into the prompt. If the provider supports JSON mode, it is enabled.
-- 'grammar': The provider is instructed to converted the JSON schema into a provider specific grammar and use it to select the output tokens.
+- 'json': The JSON schema and an instruction is injected into the prompt. If the provider supports JSON mode, it is enabled. If the provider supports JSON grammars, the grammar is used.
 
 Please note that most providers do not support all modes.
 
 Default and recommended: 'auto' (best mode for the model).
      */
-    mode?: 'auto' | 'json' | 'tool' | 'grammar';
-}): Promise<GenerateObjectResult<T>>;
-/**
-The result of a `generateObject` call.
- */
-declare class GenerateObjectResult<T> {
-    /**
-  The generated object (typed according to the schema).
-     */
-    readonly object: T;
-    /**
-  The reason why the generation finished.
-     */
-    readonly finishReason: FinishReason;
-    /**
-  The token usage of the generated text.
-     */
-    readonly usage: CompletionTokenUsage$1;
-    /**
-  Warnings from the model provider (e.g. unsupported settings)
-     */
-    readonly warnings: CallWarning[] | undefined;
-    /**
-  Optional raw response data.
-     */
-    rawResponse?: {
-        /**
-    Response headers.
-     */
-        headers?: Record<string, string>;
-    };
+    mode?: 'auto' | 'json' | 'tool';
     /**
-  Logprobs for the completion.
-  `undefined` if the mode does not support logprobs or if was not enabled
+     * Optional telemetry configuration (experimental).
      */
-    readonly logprobs: LogProbs | undefined;
+    experimental_telemetry?: TelemetrySettings;
+}): Promise<DefaultGenerateObjectResult<T>>;
+declare class DefaultGenerateObjectResult<T> implements GenerateObjectResult<T> {
+    readonly object: GenerateObjectResult<T>['object'];
+    readonly finishReason: GenerateObjectResult<T>['finishReason'];
+    readonly usage: GenerateObjectResult<T>['usage'];
+    readonly warnings: GenerateObjectResult<T>['warnings'];
+    readonly rawResponse: GenerateObjectResult<T>['rawResponse'];
+    readonly logprobs: GenerateObjectResult<T>['logprobs'];
     constructor(options: {
-        object: T;
-        finishReason: FinishReason;
-        usage: CompletionTokenUsage$1;
-        warnings: CallWarning[] | undefined;
-        rawResponse?: {
-            headers?: Record<string, string>;
-        };
-        logprobs: LogProbs | undefined;
+        object: GenerateObjectResult<T>['object'];
+        finishReason: GenerateObjectResult<T>['finishReason'];
+        usage: GenerateObjectResult<T>['usage'];
+        warnings: GenerateObjectResult<T>['warnings'];
+        rawResponse: GenerateObjectResult<T>['rawResponse'];
+        logprobs: GenerateObjectResult<T>['logprobs'];
     });
-    /**
-  Converts the object to a JSON response.
-  The response will have a status code of 200 and a content type of `application/json; charset=utf-8`.
-     */
     toJsonResponse(init?: ResponseInit): Response;
 }
 /**
@@ -589,6 +623,91 @@ declare const experimental_generateObject: typeof generateObject;
 
 type AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
 
+/**
+The result of a `streamObject` call that contains the partial object stream and additional information.
+ */
+interface StreamObjectResult<T> {
+    /**
+    Warnings from the model provider (e.g. unsupported settings)
+       */
+    readonly warnings: CallWarning[] | undefined;
+    /**
+    The token usage of the generated response. Resolved when the response is finished.
+       */
+    readonly usage: Promise<CompletionTokenUsage$1>;
+    /**
+    Optional raw response data.
+       */
+    readonly rawResponse?: {
+        /**
+      Response headers.
+       */
+        headers?: Record<string, string>;
+    };
+    /**
+    The generated object (typed according to the schema). Resolved when the response is finished.
+       */
+    readonly object: Promise<T>;
+    /**
+    Stream of partial objects. It gets more complete as the stream progresses.
+  
+    Note that the partial object is not validated.
+    If you want to be certain that the actual content matches your schema, you need to implement your own validation for partial results.
+       */
+    readonly partialObjectStream: AsyncIterableStream<DeepPartial<T>>;
+    /**
+    Text stream of the JSON representation of the generated object. It contains text chunks.
+    When the stream is finished, the object is valid JSON that can be parsed.
+       */
+    readonly textStream: AsyncIterableStream<string>;
+    /**
+    Stream of different types of events, including partial objects, errors, and finish events.
+    Only errors that stop the stream, such as network errors, are thrown.
+       */
+    readonly fullStream: AsyncIterableStream<ObjectStreamPart<T>>;
+    /**
+    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 and status code.
+       */
+    pipeTextStreamToResponse(response: ServerResponse, init?: {
+        headers?: Record<string, string>;
+        status?: number;
+    }): void;
+    /**
+    Creates a simple text stream response.
+    The response has a `Content-Type` header set to `text/plain; charset=utf-8`.
+    Each text delta is encoded as UTF-8 and sent as a separate chunk.
+    Non-text-delta events are ignored.
+  
+    @param init Optional headers and status code.
+       */
+    toTextStreamResponse(init?: ResponseInit): Response;
+}
+type ObjectStreamInputPart = {
+    type: 'error';
+    error: unknown;
+} | {
+    type: 'finish';
+    finishReason: FinishReason;
+    logprobs?: LogProbs;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+};
+type ObjectStreamPart<T> = ObjectStreamInputPart | {
+    type: 'object';
+    object: DeepPartial<T>;
+} | {
+    type: 'text-delta';
+    textDelta: string;
+};
+
 /**
 Generate a structured, typed object for a given prompt and schema using a language model.
 
@@ -610,6 +729,9 @@ 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.
@@ -626,7 +748,7 @@ If set and supported by the model, calls will generate deterministic results.
 @return
 A result object for accessing the partial object stream and additional information.
  */
-declare function streamObject<T>({ model, schema, mode, system, prompt, messages, maxRetries, abortSignal, headers, onFinish, ...settings }: CallSettings & Prompt & {
+declare function streamObject<T>({ model, schema, mode, system, prompt, messages, maxRetries, abortSignal, headers, onFinish, ...settings }: Omit<CallSettings, 'stopSequences'> & Prompt & {
     /**
 The language model to use.
      */
@@ -642,14 +764,13 @@ The Zod schema is converted in a JSON schema and used in one of the following wa
 
 - 'auto': The provider will choose the best mode for the model.
 - 'tool': A tool with the JSON schema as parameters is is provided and the provider is instructed to use it.
-- 'json': The JSON schema and a instruction is injected into the prompt. If the provider supports JSON mode, it is enabled.
-- 'grammar': The provider is instructed to converted the JSON schema into a provider specific grammar and use it to select the output tokens.
+- 'json': The JSON schema and an instruction is injected into the prompt. If the provider supports JSON mode, it is enabled. If the provider supports JSON grammars, the grammar is used.
 
 Please note that most providers do not support all modes.
 
 Default and recommended: 'auto' (best mode for the model).
      */
-    mode?: 'auto' | 'json' | 'tool' | 'grammar';
+    mode?: 'auto' | 'json' | 'tool';
     /**
 Callback that is called when the LLM response and the final object validation are finished.
      */
@@ -680,99 +801,28 @@ Callback that is called when the LLM response and the final object validation ar
          */
         warnings?: CallWarning[];
     }) => Promise<void> | void;
-}): Promise<StreamObjectResult<T>>;
-type ObjectStreamInputPart = {
-    type: 'error';
-    error: unknown;
-} | {
-    type: 'finish';
-    finishReason: FinishReason;
-    logprobs?: LogProbs;
-    usage: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-};
-type ObjectStreamPart<T> = ObjectStreamInputPart | {
-    type: 'object';
-    object: DeepPartial<T>;
-} | {
-    type: 'text-delta';
-    textDelta: string;
-};
-/**
-The result of a `streamObject` call that contains the partial object stream and additional information.
- */
-declare class StreamObjectResult<T> {
+}): Promise<DefaultStreamObjectResult<T>>;
+declare class DefaultStreamObjectResult<T> implements StreamObjectResult<T> {
     private readonly originalStream;
     private readonly objectPromise;
-    /**
-  Warnings from the model provider (e.g. unsupported settings)
-     */
-    readonly warnings: CallWarning[] | undefined;
-    /**
-  The token usage of the generated response. Resolved when the response is finished.
-     */
-    readonly usage: Promise<CompletionTokenUsage$1>;
-    /**
-  Optional raw response data.
-     */
-    rawResponse?: {
-        /**
-    Response headers.
-     */
-        headers?: Record<string, string>;
-    };
+    readonly warnings: StreamObjectResult<T>['warnings'];
+    readonly usage: StreamObjectResult<T>['usage'];
+    readonly rawResponse: StreamObjectResult<T>['rawResponse'];
     constructor({ stream, warnings, rawResponse, schema, onFinish, }: {
         stream: ReadableStream<string | Omit<LanguageModelV1StreamPart, 'text-delta'>>;
-        warnings: CallWarning[] | undefined;
-        rawResponse?: {
-            headers?: Record<string, string>;
-        };
+        warnings: StreamObjectResult<T>['warnings'];
+        rawResponse?: StreamObjectResult<T>['rawResponse'];
         schema: z.Schema<T>;
         onFinish: Parameters<typeof streamObject<T>>[0]['onFinish'];
     });
-    /**
-  The generated object (typed according to the schema). Resolved when the response is finished.
-     */
     get object(): Promise<T>;
-    /**
-  Stream of partial objects. It gets more complete as the stream progresses.
-    
-  Note that the partial object is not validated.
-  If you want to be certain that the actual content matches your schema, you need to implement your own validation for partial results.
-     */
     get partialObjectStream(): AsyncIterableStream<DeepPartial<T>>;
-    /**
-  Text stream of the JSON representation of the generated object. It contains text chunks.
-  When the stream is finished, the object is valid JSON that can be parsed.
-     */
     get textStream(): AsyncIterableStream<string>;
-    /**
-  Stream of different types of events, including partial objects, errors, and finish events.
-     */
     get fullStream(): AsyncIterableStream<ObjectStreamPart<T>>;
-    /**
-  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 and status code.
-     */
     pipeTextStreamToResponse(response: ServerResponse, init?: {
         headers?: Record<string, string>;
         status?: number;
     }): void;
-    /**
-  Creates a simple text stream response.
-  The response has a `Content-Type` header set to `text/plain; charset=utf-8`.
-  Each text delta is encoded as UTF-8 and sent as a separate chunk.
-  Non-text-delta events are ignored.
-  
-  @param init Optional headers and status code.
-     */
     toTextStreamResponse(init?: ResponseInit): Response;
 }
 /**
@@ -931,24 +981,6 @@ declare class InvalidMessageRoleError extends Error {
     };
 }
 
-/**
- * Telemetry configuration.
- */
-type TelemetrySettings = {
-    /**
-     * Enable or disable telemetry. Disabled by default while experimental.
-     */
-    isEnabled?: 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>;
-};
-
 type ToToolCall<TOOLS extends Record<string, CoreTool>> = ValueOf<{
     [NAME in keyof TOOLS]: {
         type: 'tool-call';
@@ -959,6 +991,103 @@ type ToToolCall<TOOLS extends Record<string, CoreTool>> = ValueOf<{
 }>;
 type ToToolCallArray<TOOLS extends Record<string, CoreTool>> = Array<ToToolCall<TOOLS>>;
 
+/**
+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.
+ */
+interface GenerateTextResult<TOOLS extends Record<string, CoreTool>> {
+    /**
+    The generated text.
+       */
+    readonly text: string;
+    /**
+    The tool calls that were made during the generation.
+     */
+    readonly toolCalls: ToToolCallArray<TOOLS>;
+    /**
+    The results of the tool calls.
+     */
+    readonly toolResults: ToToolResultArray<TOOLS>;
+    /**
+    The reason why the generation finished.
+     */
+    readonly finishReason: FinishReason;
+    /**
+    The token usage of the generated text.
+     */
+    readonly usage: CompletionTokenUsage$1;
+    /**
+    Warnings from the model provider (e.g. unsupported settings)
+     */
+    readonly warnings: CallWarning[] | undefined;
+    /**
+    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.
+       */
+    readonly responseMessages: Array<CoreAssistantMessage | CoreToolMessage>;
+    /**
+    Response information for every roundtrip.
+    You can use this to get information about intermediate steps, such as the tool calls or the response headers.
+     */
+    readonly roundtrips: Array<{
+        /**
+      The generated text.
+       */
+        readonly text: string;
+        /**
+      The tool calls that were made during the generation.
+      */
+        readonly toolCalls: ToToolCallArray<TOOLS>;
+        /**
+      The results of the tool calls.
+      */
+        readonly toolResults: ToToolResultArray<TOOLS>;
+        /**
+      The reason why the generation finished.
+       */
+        readonly finishReason: FinishReason;
+        /**
+      The token usage of the generated text.
+      */
+        readonly usage: CompletionTokenUsage$1;
+        /**
+      Warnings from the model provider (e.g. unsupported settings)
+       */
+        readonly warnings: CallWarning[] | undefined;
+        /**
+      Logprobs for the completion.
+      `undefined` if the mode does not support logprobs or if was not enabled.
+       */
+        readonly logprobs: LogProbs | undefined;
+        /**
+      Optional raw response data.
+         */
+        readonly rawResponse?: {
+            /**
+        Response headers.
+           */
+            readonly headers?: Record<string, string>;
+        };
+    }>;
+    /**
+    Optional raw response data.
+     */
+    readonly rawResponse?: {
+        /**
+      Response headers.
+       */
+        readonly headers?: Record<string, string>;
+    };
+    /**
+    Logprobs for the completion.
+    `undefined` if the mode does not support logprobs or if was not enabled.
+       */
+    readonly logprobs: LogProbs | undefined;
+}
+
 /**
 Generate a text and call tools for a given prompt using a language model.
 
@@ -980,12 +1109,17 @@ 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.
 
@@ -1034,117 +1168,145 @@ By default, it's set to 0, which will disable the feature.
     experimental_telemetry?: TelemetrySettings;
 }): Promise<GenerateTextResult<TOOLS>>;
 /**
-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.
+ * @deprecated Use `generateText` instead.
  */
-declare class GenerateTextResult<TOOLS extends Record<string, CoreTool>> {
-    /**
-  The generated text.
-     */
-    readonly text: string;
+declare const experimental_generateText: typeof generateText;
+
+/**
+A result object for accessing different stream types and additional information.
+ */
+interface StreamTextResult<TOOLS extends Record<string, CoreTool>> {
     /**
-  The tool calls that were made during the generation.
-     */
-    readonly toolCalls: ToToolCallArray<TOOLS>;
+    Warnings from the model provider (e.g. unsupported settings).
+       */
+    readonly warnings: CallWarning[] | undefined;
     /**
-  The results of the tool calls.
-     */
-    readonly toolResults: ToToolResultArray<TOOLS>;
+    The token usage of the generated response. Resolved when the response is finished.
+       */
+    readonly usage: Promise<CompletionTokenUsage$1>;
     /**
-  The reason why the generation finished.
-     */
-    readonly finishReason: FinishReason;
+    The reason why the generation finished. Resolved when the response is finished.
+       */
+    readonly finishReason: Promise<FinishReason>;
     /**
-  The token usage of the generated text.
-     */
-    readonly usage: CompletionTokenUsage$1;
+    The full text that has been generated. Resolved when the response is finished.
+       */
+    readonly text: Promise<string>;
     /**
-  Warnings from the model provider (e.g. unsupported settings)
-     */
-    readonly warnings: CallWarning[] | undefined;
+    The tool calls that have been executed. Resolved when the response is finished.
+       */
+    readonly toolCalls: Promise<ToToolCall<TOOLS>[]>;
     /**
-  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.
-     */
-    readonly responseMessages: Array<CoreAssistantMessage | CoreToolMessage>;
+    The tool results that have been generated. Resolved when the all tool executions are finished.
+       */
+    readonly toolResults: Promise<ToToolResult<TOOLS>[]>;
     /**
-  Response information for every roundtrip.
-  You can use this to get information about intermediate steps, such as the tool calls or the response headers.
-     */
-    readonly roundtrips: Array<{
-        /**
-    The generated text.
+    Optional raw response data.
        */
-        readonly text: string;
-        /**
-    The tool calls that were made during the generation.
-     */
-        readonly toolCalls: ToToolCallArray<TOOLS>;
-        /**
-    The results of the tool calls.
-     */
-        readonly toolResults: ToToolResultArray<TOOLS>;
+    readonly rawResponse?: {
         /**
-    The reason why the generation finished.
+      Response headers.
+           */
+        headers?: Record<string, string>;
+    };
+    /**
+    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 finishReason: FinishReason;
-        /**
-    The token usage of the generated text.
-     */
-        readonly usage: CompletionTokenUsage$1;
-        /**
-    Warnings from the model provider (e.g. unsupported settings)
+    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 warnings: CallWarning[] | undefined;
-        /**
-    Logprobs for the completion.
-    `undefined` if the mode does not support logprobs or if was not enabled.
+    readonly fullStream: AsyncIterableStream<TextStreamPart<TOOLS>>;
+    /**
+    Converts the result to an `AIStream` object that is compatible with `StreamingTextResponse`.
+    It can be used with the `useChat` and `useCompletion` hooks.
+  
+    @param callbacks
+    Stream callbacks that will be called when the stream emits events.
+  
+    @returns an `AIStream` object.
        */
-        readonly logprobs: LogProbs | undefined;
-        /**
-      Optional raw response data.
-         */
-        readonly rawResponse?: {
-            /**
-        Response headers.
-           */
-            readonly headers?: Record<string, string>;
-        };
-    }>;
+    toAIStream(callbacks?: AIStreamCallbacksAndOptions): ReadableStream<Uint8Array>;
     /**
-  Optional raw response data.
-     */
-    readonly rawResponse?: {
-        /**
-    Response headers.
+    Writes stream data output to a Node.js response-like object.
+    It sets a `Content-Type` header to `text/plain; charset=utf-8` and
+    writes each stream data part as a separate chunk.
+  
+    @param response A Node.js response-like object (ServerResponse).
+    @param init Optional headers and status code.
        */
-        readonly headers?: Record<string, string>;
-    };
+    pipeAIStreamToResponse(response: ServerResponse$1, init?: {
+        headers?: Record<string, string>;
+        status?: number;
+    }): void;
     /**
-  Logprobs for the completion.
-  `undefined` if the mode does not support logprobs or if was not enabled.
-     */
-    readonly logprobs: LogProbs | undefined;
-    constructor(options: {
-        text: GenerateTextResult<TOOLS>['text'];
-        toolCalls: GenerateTextResult<TOOLS>['toolCalls'];
-        toolResults: GenerateTextResult<TOOLS>['toolResults'];
-        finishReason: GenerateTextResult<TOOLS>['finishReason'];
-        usage: GenerateTextResult<TOOLS>['usage'];
-        warnings: GenerateTextResult<TOOLS>['warnings'];
-        rawResponse?: GenerateTextResult<TOOLS>['rawResponse'];
-        logprobs: GenerateTextResult<TOOLS>['logprobs'];
-        responseMessages: GenerateTextResult<TOOLS>['responseMessages'];
-        roundtrips: GenerateTextResult<TOOLS>['roundtrips'];
-    });
+    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 and status code.
+       */
+    pipeTextStreamToResponse(response: ServerResponse$1, init?: {
+        headers?: Record<string, string>;
+        status?: number;
+    }): void;
+    /**
+    Converts the result to a streamed response object with a stream data part stream.
+    It can be used with the `useChat` and `useCompletion` hooks.
+  
+    @param options An object with an init property (ResponseInit) and a data property.
+    You can also pass in a ResponseInit directly (deprecated).
+  
+    @return A response object.
+       */
+    toAIStreamResponse(options?: ResponseInit | {
+        init?: ResponseInit;
+        data?: StreamData;
+    }): 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 and status code.
+       */
+    toTextStreamResponse(init?: ResponseInit): Response;
 }
-/**
- * @deprecated Use `generateText` instead.
- */
-declare const experimental_generateText: typeof generateText;
+type TextStreamPart<TOOLS extends Record<string, CoreTool>> = {
+    type: 'text-delta';
+    textDelta: string;
+} | ({
+    type: 'tool-call';
+} & ToToolCall<TOOLS>) | {
+    type: 'tool-call-streaming-start';
+    toolCallId: string;
+    toolName: string;
+} | {
+    type: 'tool-call-delta';
+    toolCallId: string;
+    toolName: string;
+    argsTextDelta: string;
+} | ({
+    type: 'tool-result';
+} & ToToolResult<TOOLS>) | {
+    type: 'finish';
+    finishReason: FinishReason;
+    logprobs?: LogProbs;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+} | {
+    type: 'error';
+    error: unknown;
+};
 
 /**
 Generate a text and call tools for a given prompt using a language model.
@@ -1165,12 +1327,17 @@ 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.
 
@@ -1244,81 +1411,21 @@ Callback that is called when the LLM response and all request tool executions
          */
         warnings?: CallWarning[];
     }) => Promise<void> | void;
-}): Promise<StreamTextResult<TOOLS>>;
-type TextStreamPart<TOOLS extends Record<string, CoreTool>> = {
-    type: 'text-delta';
-    textDelta: string;
-} | ({
-    type: 'tool-call';
-} & ToToolCall<TOOLS>) | {
-    type: 'tool-call-streaming-start';
-    toolCallId: string;
-    toolName: string;
-} | {
-    type: 'tool-call-delta';
-    toolCallId: string;
-    toolName: string;
-    argsTextDelta: string;
-} | ({
-    type: 'tool-result';
-} & ToToolResult<TOOLS>) | {
-    type: 'finish';
-    finishReason: FinishReason;
-    logprobs?: LogProbs;
-    usage: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-} | {
-    type: 'error';
-    error: unknown;
-};
-/**
-A result object for accessing different stream types and additional information.
- */
-declare class StreamTextResult<TOOLS extends Record<string, CoreTool>> {
+}): Promise<DefaultStreamTextResult<TOOLS>>;
+declare class DefaultStreamTextResult<TOOLS extends Record<string, CoreTool>> implements StreamTextResult<TOOLS> {
     private originalStream;
     private onFinish?;
-    /**
-  Warnings from the model provider (e.g. unsupported settings).
-     */
-    readonly warnings: CallWarning[] | undefined;
-    /**
-  The token usage of the generated response. Resolved when the response is finished.
-     */
-    readonly usage: Promise<CompletionTokenUsage$1>;
-    /**
-  The reason why the generation finished. Resolved when the response is finished.
-     */
-    readonly finishReason: Promise<FinishReason>;
-    /**
-  The full text that has been generated. Resolved when the response is finished.
-     */
-    readonly text: Promise<string>;
-    /**
-  The tool calls that have been executed. Resolved when the response is finished.
-     */
-    readonly toolCalls: Promise<ToToolCall<TOOLS>[]>;
-    /**
-  The tool results that have been generated. Resolved when the all tool executions are finished.
-     */
-    readonly toolResults: Promise<ToToolResult<TOOLS>[]>;
-    /**
-  Optional raw response data.
-     */
-    readonly rawResponse?: {
-        /**
-    Response headers.
-         */
-        headers?: Record<string, string>;
-    };
+    readonly warnings: StreamTextResult<TOOLS>['warnings'];
+    readonly usage: StreamTextResult<TOOLS>['usage'];
+    readonly finishReason: StreamTextResult<TOOLS>['finishReason'];
+    readonly text: StreamTextResult<TOOLS>['text'];
+    readonly toolCalls: StreamTextResult<TOOLS>['toolCalls'];
+    readonly toolResults: StreamTextResult<TOOLS>['toolResults'];
+    readonly rawResponse: StreamTextResult<TOOLS>['rawResponse'];
     constructor({ stream, warnings, rawResponse, onFinish, rootSpan, doStreamSpan, }: {
         stream: ReadableStream<TextStreamPart<TOOLS>>;
-        warnings: CallWarning[] | undefined;
-        rawResponse?: {
-            headers?: Record<string, string>;
-        };
+        warnings: StreamTextResult<TOOLS>['warnings'];
+        rawResponse: StreamTextResult<TOOLS>['rawResponse'];
         onFinish?: Parameters<typeof streamText>[0]['onFinish'];
         rootSpan: Span;
         doStreamSpan: Span;
@@ -1332,73 +1439,21 @@ declare class StreamTextResult<TOOLS extends Record<string, CoreTool>> {
   However, the LLM results are expected to be small enough to not cause issues.
      */
     private teeStream;
-    /**
-  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.
-     */
     get 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. When an error occurs, the
-  stream will throw the error.
-     */
     get fullStream(): AsyncIterableStream<TextStreamPart<TOOLS>>;
-    /**
-  Converts the result to an `AIStream` object that is compatible with `StreamingTextResponse`.
-  It can be used with the `useChat` and `useCompletion` hooks.
-  
-  @param callbacks
-  Stream callbacks that will be called when the stream emits events.
-  
-  @returns an `AIStream` object.
-     */
     toAIStream(callbacks?: AIStreamCallbacksAndOptions): ReadableStream<Uint8Array>;
-    /**
-  Writes stream data output to a Node.js response-like object.
-  It sets a `Content-Type` header to `text/plain; charset=utf-8` and
-  writes each stream data part as a separate chunk.
-  
-  @param response A Node.js response-like object (ServerResponse).
-  @param init Optional headers and status code.
-     */
     pipeAIStreamToResponse(response: ServerResponse$1, init?: {
         headers?: Record<string, string>;
         status?: number;
     }): 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 and status code.
-     */
     pipeTextStreamToResponse(response: ServerResponse$1, init?: {
         headers?: Record<string, string>;
         status?: number;
     }): void;
-    /**
-  Converts the result to a streamed response object with a stream data part stream.
-  It can be used with the `useChat` and `useCompletion` hooks.
-  
-  @param options An object with an init property (ResponseInit) and a data property.
-  You can also pass in a ResponseInit directly (deprecated).
-  
-  @return A response object.
-     */
     toAIStreamResponse(options?: ResponseInit | {
         init?: ResponseInit;
         data?: StreamData;
     }): 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 and status code.
-     */
     toTextStreamResponse(init?: ResponseInit): Response;
 }
 /**