ai 3.2.33 → 3.2.35

package/dist/index.d.mts

@@ -1,14 +1,34 @@
 import { DeepPartial, Attachment, JSONValue, CreateMessage, FunctionCall as FunctionCall$1, AssistantMessage, DataMessage } from '@ai-sdk/ui-utils';
 export { AssistantMessage, AssistantStatus, ChatRequest, ChatRequestOptions, CreateMessage, DataMessage, DeepPartial, Function, FunctionCall, FunctionCallHandler, IdGenerator, JSONValue, Message, RequestOptions, StreamPart, Tool, ToolCall, ToolCallHandler, ToolChoice, ToolInvocation, UseAssistantOptions, formatStreamPart, parseComplexResponse, parseStreamPart, readDataStream } from '@ai-sdk/ui-utils';
+import { AttributeValue, Span } from '@opentelemetry/api';
 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 { Validator } from '@ai-sdk/provider-utils';
+import { JSONSchema7 } from 'json-schema';
 import { ServerResponse } from 'http';
-import { AttributeValue, Span } from '@opentelemetry/api';
 import { ServerResponse as ServerResponse$1 } from 'node:http';
 import { AssistantStream } from 'openai/lib/AssistantStream';
 import { Run } from 'openai/resources/beta/threads/runs/runs';
 
+/**
+ * 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>;
+};
+
 /**
 Represents the number of tokens used in a prompt and completion.
  */
@@ -89,6 +109,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.
 
@@ -101,7 +149,7 @@ Embed a value using an embedding model. The type of the value is defined by the
 
 @returns A result object that contains the embedding, the value, and additional information.
  */
-declare function embed<VALUE>({ model, value, maxRetries, abortSignal, headers, }: {
+declare function embed<VALUE>({ model, value, maxRetries, abortSignal, headers, experimental_telemetry: telemetry, }: {
     /**
   The embedding model to use.
        */
@@ -125,41 +173,29 @@ declare function embed<VALUE>({ model, value, maxRetries, abortSignal, headers,
   Only applicable for HTTP-based providers.
    */
     headers?: Record<string, string>;
+    /**
+     * Optional telemetry configuration (experimental).
+     */
+    experimental_telemetry?: TelemetrySettings;
 }): 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 +239,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 +264,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 +291,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 +496,81 @@ type Prompt = {
     messages?: Array<CoreMessage>;
 };
 
+/**
+ * Used to mark schemas so we can support both Zod and custom schemas.
+ */
+declare const schemaSymbol: unique symbol;
+type Schema<OBJECT = unknown> = Validator<OBJECT> & {
+    /**
+     * Used to mark schemas so we can support both Zod and custom schemas.
+     */
+    [schemaSymbol]: true;
+    /**
+     * Schema type for inference.
+     */
+    _type: OBJECT;
+    /**
+     * The JSON Schema for the schema. It is passed to the providers.
+     */
+    readonly jsonSchema: JSONSchema7;
+};
+/**
+ * Create a schema using a JSON Schema.
+ *
+ * @param jsonSchema The JSON Schema for the schema.
+ * @param options.validate Optional. A validation function for the schema.
+ */
+declare function jsonSchema<OBJECT = unknown>(jsonSchema: JSONSchema7, { validate, }?: {
+    validate?: (value: unknown) => {
+        success: true;
+        value: OBJECT;
+    } | {
+        success: false;
+        error: Error;
+    };
+}): Schema<OBJECT>;
+
+/**
+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 +592,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 +611,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: inputSchema, mode, system, prompt, messages, maxRetries, abortSignal, headers, experimental_telemetry: telemetry, ...settings }: Omit<CallSettings, 'stopSequences'> & Prompt & {
     /**
 The language model to use.
      */
@@ -515,71 +619,41 @@ The language model to use.
     /**
 The schema of the object that the model should generate.
      */
-    schema: z.Schema<T>;
+    schema: z.Schema<T> | Schema<T>;
     /**
 The mode to use for object generation.
 
-The Zod schema is converted in a JSON schema and used in one of the following ways
+The schema is converted in a JSON schema and used in one of the following ways
 
 - '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 +663,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 +769,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 +788,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: inputSchema, mode, system, prompt, messages, maxRetries, abortSignal, headers, onFinish, ...settings }: Omit<CallSettings, 'stopSequences'> & Prompt & {
     /**
 The language model to use.
      */
@@ -634,22 +796,21 @@ The language model to use.
     /**
 The schema of the object that the model should generate.
  */
-    schema: z.Schema<T>;
+    schema: z.Schema<T> | Schema<T>;
     /**
 The mode to use for object generation.
 
-The Zod schema is converted in a JSON schema and used in one of the following ways
+The schema is converted in a JSON schema and used in one of the following ways
 
 - '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 +841,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>;
-        };
-        schema: z.Schema<T>;
+        warnings: StreamObjectResult<T>['warnings'];
+        rawResponse?: StreamObjectResult<T>['rawResponse'];
+        schema: z.Schema<T> | 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;
 }
 /**
@@ -780,13 +870,15 @@ declare class StreamObjectResult<T> {
  */
 declare const experimental_streamObject: typeof streamObject;
 
+type Parameters$1 = z.ZodTypeAny | Schema<any>;
+type inferParameters<PARAMETERS extends Parameters$1> = PARAMETERS extends Schema<any> ? PARAMETERS['_type'] : PARAMETERS extends z.ZodTypeAny ? z.infer<PARAMETERS> : never;
 /**
 A tool contains the description and the schema of the input that the tool expects.
 This enables the language model to generate the input.
 
 The tool can also contain an optional execute function for the actual execution function of the tool.
  */
-interface CoreTool<PARAMETERS extends z.ZodTypeAny = any, RESULT = any> {
+interface CoreTool<PARAMETERS extends Parameters$1 = any, RESULT = any> {
     /**
   An optional description of what the tool does. Will be used by the language model to decide whether to use the tool.
      */
@@ -801,17 +893,17 @@ interface CoreTool<PARAMETERS extends z.ZodTypeAny = any, RESULT = any> {
   An async function that is called with the arguments from the tool call and produces a result.
   If not provided, the tool will not be executed automatically.
      */
-    execute?: (args: z.infer<PARAMETERS>) => PromiseLike<RESULT>;
+    execute?: (args: inferParameters<PARAMETERS>) => PromiseLike<RESULT>;
 }
 /**
 Helper function for inferring the execute args of a tool.
  */
-declare function tool<PARAMETERS extends z.ZodTypeAny, RESULT>(tool: CoreTool<PARAMETERS, RESULT> & {
-    execute: (args: z.infer<PARAMETERS>) => PromiseLike<RESULT>;
+declare function tool<PARAMETERS extends Parameters$1, RESULT>(tool: CoreTool<PARAMETERS, RESULT> & {
+    execute: (args: inferParameters<PARAMETERS>) => PromiseLike<RESULT>;
 }): CoreTool<PARAMETERS, RESULT> & {
-    execute: (args: z.infer<PARAMETERS>) => PromiseLike<RESULT>;
+    execute: (args: inferParameters<PARAMETERS>) => PromiseLike<RESULT>;
 };
-declare function tool<PARAMETERS extends z.ZodTypeAny, RESULT>(tool: CoreTool<PARAMETERS, RESULT> & {
+declare function tool<PARAMETERS extends Parameters$1, RESULT>(tool: CoreTool<PARAMETERS, RESULT> & {
     execute?: undefined;
 }): CoreTool<PARAMETERS, RESULT> & {
     execute: undefined;
@@ -898,7 +990,7 @@ type ToToolResultObject<TOOLS extends Record<string, CoreTool>> = ValueOf<{
         type: 'tool-result';
         toolCallId: string;
         toolName: NAME & string;
-        args: z.infer<TOOLS[NAME]['parameters']>;
+        args: inferParameters<TOOLS[NAME]['parameters']>;
         result: Awaited<ReturnType<Exclude<TOOLS[NAME]['execute'], undefined>>>;
     };
 }>;
@@ -931,33 +1023,112 @@ declare class InvalidMessageRoleError extends Error {
     };
 }
 
+type ToToolCall<TOOLS extends Record<string, CoreTool>> = ValueOf<{
+    [NAME in keyof TOOLS]: {
+        type: 'tool-call';
+        toolCallId: string;
+        toolName: NAME & string;
+        args: inferParameters<TOOLS[NAME]['parameters']>;
+    };
+}>;
+type ToToolCallArray<TOOLS extends Record<string, CoreTool>> = Array<ToToolCall<TOOLS>>;
+
 /**
- * Telemetry configuration.
+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.
  */
-type TelemetrySettings = {
+interface GenerateTextResult<TOOLS extends Record<string, CoreTool>> {
     /**
-     * Enable or disable telemetry. Disabled by default while experimental.
+    The generated text.
+       */
+    readonly text: string;
+    /**
+    The tool calls that were made during the generation.
      */
-    isEnabled?: boolean;
+    readonly toolCalls: ToToolCallArray<TOOLS>;
     /**
-     * Identifier for this function. Used to group telemetry data by function.
+    The results of the tool calls.
      */
-    functionId?: string;
+    readonly toolResults: ToToolResultArray<TOOLS>;
     /**
-     * Additional information to include in the telemetry data.
+    The reason why the generation finished.
      */
-    metadata?: Record<string, AttributeValue>;
-};
-
-type ToToolCall<TOOLS extends Record<string, CoreTool>> = ValueOf<{
-    [NAME in keyof TOOLS]: {
-        type: 'tool-call';
-        toolCallId: string;
-        toolName: NAME & string;
-        args: z.infer<TOOLS[NAME]['parameters']>;
+    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>;
     };
-}>;
-type ToToolCallArray<TOOLS extends Record<string, CoreTool>> = Array<ToToolCall<TOOLS>>;
+    /**
+    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 +1151,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 +1210,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 +1369,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 +1453,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 +1481,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;
 }
 /**
@@ -2257,4 +2354,4 @@ declare const generateId: (size?: number | undefined) => string;
  */
 declare const nanoid: (size?: number | undefined) => string;
 
-export { AIStream, AIStreamCallbacksAndOptions, AIStreamParser, AIStreamParserOptions, AWSBedrockAnthropicMessagesStream, AWSBedrockAnthropicStream, AWSBedrockCohereStream, AWSBedrockLlama2Stream, AWSBedrockStream, AnthropicStream, AssistantContent, AssistantResponse, CallWarning, CohereStream, CompletionTokenUsage, CompletionUsage, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreTool, CoreToolChoice, CoreToolMessage, CoreUserMessage, DataContent, EmbedManyResult, EmbedResult, Embedding, EmbeddingModel, EmbeddingTokenUsage, ExperimentalAssistantMessage, ExperimentalMessage, ExperimentalTool, ExperimentalToolMessage, ExperimentalUserMessage, FinishReason, FunctionCallPayload, GenerateObjectResult, GenerateTextResult, GoogleGenerativeAIStream, HuggingFaceStream, ImagePart, InkeepAIStreamCallbacksAndOptions, InkeepChatResultCallbacks, InkeepOnFinalMetadata, InkeepStream, InvalidMessageRoleError, InvalidModelIdError, langchainAdapter as LangChainAdapter, LangChainStream, LanguageModel, LogProbs, MistralStream, NoSuchModelError, NoSuchProviderError, ObjectStreamInputPart, ObjectStreamPart, OpenAIStream, OpenAIStreamCallbacks, ReplicateStream, StreamData, StreamObjectResult, StreamTextResult, StreamingTextResponse, TextPart$1 as TextPart, TextStreamPart, TokenUsage, ToolCallPart, ToolCallPayload, ToolContent, ToolResultPart, UserContent, convertDataContentToBase64String, convertDataContentToUint8Array, convertToCoreMessages, convertUint8ArrayToText, cosineSimilarity, createCallbacksTransformer, createEventStreamTransformer, createStreamDataTransformer, embed, embedMany, experimental_AssistantResponse, experimental_ModelRegistry, experimental_ProviderRegistry, experimental_StreamData, experimental_createModelRegistry, experimental_createProviderRegistry, experimental_generateObject, experimental_generateText, experimental_streamObject, experimental_streamText, generateId, generateObject, generateText, nanoid, readableFromAsyncIterable, streamObject, streamText, streamToResponse, tool, trimStartOfStreamHelper };
+export { AIStream, AIStreamCallbacksAndOptions, AIStreamParser, AIStreamParserOptions, AWSBedrockAnthropicMessagesStream, AWSBedrockAnthropicStream, AWSBedrockCohereStream, AWSBedrockLlama2Stream, AWSBedrockStream, AnthropicStream, AssistantContent, AssistantResponse, CallWarning, CohereStream, CompletionTokenUsage, CompletionUsage, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreTool, CoreToolChoice, CoreToolMessage, CoreUserMessage, DataContent, EmbedManyResult, EmbedResult, Embedding, EmbeddingModel, EmbeddingTokenUsage, ExperimentalAssistantMessage, ExperimentalMessage, ExperimentalTool, ExperimentalToolMessage, ExperimentalUserMessage, FinishReason, FunctionCallPayload, GenerateObjectResult, GenerateTextResult, GoogleGenerativeAIStream, HuggingFaceStream, ImagePart, InkeepAIStreamCallbacksAndOptions, InkeepChatResultCallbacks, InkeepOnFinalMetadata, InkeepStream, InvalidMessageRoleError, InvalidModelIdError, langchainAdapter as LangChainAdapter, LangChainStream, LanguageModel, LogProbs, MistralStream, NoSuchModelError, NoSuchProviderError, ObjectStreamInputPart, ObjectStreamPart, OpenAIStream, OpenAIStreamCallbacks, ReplicateStream, StreamData, StreamObjectResult, StreamTextResult, StreamingTextResponse, TextPart$1 as TextPart, TextStreamPart, TokenUsage, ToolCallPart, ToolCallPayload, ToolContent, ToolResultPart, UserContent, convertDataContentToBase64String, convertDataContentToUint8Array, convertToCoreMessages, convertUint8ArrayToText, cosineSimilarity, createCallbacksTransformer, createEventStreamTransformer, createStreamDataTransformer, embed, embedMany, experimental_AssistantResponse, experimental_ModelRegistry, experimental_ProviderRegistry, experimental_StreamData, experimental_createModelRegistry, experimental_createProviderRegistry, experimental_generateObject, experimental_generateText, experimental_streamObject, experimental_streamText, generateId, generateObject, generateText, jsonSchema, nanoid, readableFromAsyncIterable, streamObject, streamText, streamToResponse, tool, trimStartOfStreamHelper };