ai 3.3.15 → 3.3.17

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { Schema, DeepPartial, Attachment, JSONValue, CreateMessage, FunctionCall as FunctionCall$1, AssistantMessage, DataMessage } from '@ai-sdk/ui-utils';
+import { Schema, DeepPartial, Attachment, JSONValue as JSONValue$1, 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, Schema, StreamPart, Tool, ToolCall, ToolCallHandler, ToolChoice, ToolInvocation, UseAssistantOptions, formatStreamPart, jsonSchema, parseComplexResponse, parseStreamPart, readDataStream } from '@ai-sdk/ui-utils';
-import { AttributeValue, Span } from '@opentelemetry/api';
-import { EmbeddingModelV1, EmbeddingModelV1Embedding, LanguageModelV1, LanguageModelV1FinishReason, LanguageModelV1LogProbs, LanguageModelV1CallWarning, LanguageModelV1ProviderMetadata, LanguageModelV1StreamPart, AISDKError } from '@ai-sdk/provider';
+import { AttributeValue } from '@opentelemetry/api';
+import { EmbeddingModelV1, EmbeddingModelV1Embedding, LanguageModelV1, LanguageModelV1FinishReason, LanguageModelV1LogProbs, LanguageModelV1CallWarning, LanguageModelV1ProviderMetadata, JSONValue, AISDKError } from '@ai-sdk/provider';
 export { AISDKError, APICallError, EmptyResponseBodyError, InvalidPromptError, InvalidResponseDataError, JSONParseError, LoadAPIKeyError, TypeValidationError, UnsupportedFunctionalityError } from '@ai-sdk/provider';
 import { z } from 'zod';
 import { ServerResponse } from 'http';
@@ -592,63 +592,30 @@ Generate a structured, typed object for a given prompt and schema using a langua
 
 This function does not stream the output. If you want to stream the output, use `streamObject` instead.
 
-@param model - The language model to use.
-
-@param schema - The schema of the object that the model should generate.
-@param schemaName - Optional name of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema name.
-@param schemaDescription - Optional description of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema description.
-@param mode - The mode to use for object generation. Not all models support all modes. Defaults to 'auto'.
-
-@param system - A system message that will be part of the prompt.
-@param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
-@param messages - A list of messages. You can either use `prompt` or `messages` but not both.
-
-@param maxTokens - Maximum number of tokens to generate.
-@param temperature - Temperature setting.
-The value is passed through to the provider. The range depends on the provider and model.
-It is recommended to set either `temperature` or `topP`, but not both.
-@param topP - Nucleus sampling.
-The value is passed through to the provider. The range depends on the provider and model.
-It is recommended to set either `temperature` or `topP`, but not both.
-@param topK - Only sample from the top K options for each subsequent token.
-Used to remove "long tail" low probability responses.
-Recommended for advanced use cases only. You usually only need to use temperature.
-@param presencePenalty - Presence penalty setting.
-It affects the likelihood of the model to repeat information that is already in the prompt.
-The value is passed through to the provider. The range depends on the provider and model.
-@param frequencyPenalty - Frequency penalty setting.
-It affects the likelihood of the model to repeatedly use the same words or phrases.
-The value is passed through to the provider. The range depends on the provider and model.
-@param seed - The seed (integer) to use for random sampling.
-If set and supported by the model, calls will generate deterministic results.
-
-@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
-@param abortSignal - An optional abort signal that can be used to cancel the call.
-@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
-
 @returns
 A result object that contains the generated object, the finish reason, the token usage, and additional information.
  */
-declare function generateObject<T>({ model, schema: inputSchema, schemaName, schemaDescription, mode, system, prompt, messages, maxRetries, abortSignal, headers, experimental_telemetry: telemetry, ...settings }: Omit<CallSettings, 'stopSequences'> & Prompt & {
+declare function generateObject<OBJECT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output?: 'object' | undefined;
     /**
 The language model to use.
-     */
+   */
     model: LanguageModel;
     /**
 The schema of the object that the model should generate.
-     */
-    schema: z.Schema<T, z.ZodTypeDef, any> | Schema<T>;
+   */
+    schema: z.Schema<OBJECT, z.ZodTypeDef, any> | Schema<OBJECT>;
     /**
 Optional name of the output that should be generated.
 Used by some providers for additional LLM guidance, e.g.
 via tool or schema name.
-     */
+   */
     schemaName?: string;
     /**
 Optional description of the output that should be generated.
 Used by some providers for additional LLM guidance, e.g.
 via tool or schema description.
-     */
+   */
     schemaDescription?: string;
     /**
 The mode to use for object generation.
@@ -662,32 +629,85 @@ The schema is converted in a JSON schema and used in one of the following ways
 Please note that most providers do not support all modes.
 
 Default and recommended: 'auto' (best mode for the model).
+   */
+    mode?: 'auto' | 'json' | 'tool';
+    /**
+Optional telemetry configuration (experimental).
      */
+    experimental_telemetry?: TelemetrySettings;
+}): Promise<GenerateObjectResult<OBJECT>>;
+/**
+Generate an array with structured, typed elements for a given prompt and element schema using a language model.
+
+This function does not stream the output. If you want to stream the output, use `streamObject` instead.
+
+@return
+A result object that contains the generated object, the finish reason, the token usage, and additional information.
+ */
+declare function generateObject<ELEMENT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output: 'array';
+    /**
+The language model to use.
+   */
+    model: LanguageModel;
+    /**
+The element schema of the array that the model should generate.
+*/
+    schema: z.Schema<ELEMENT, z.ZodTypeDef, any> | Schema<ELEMENT>;
+    /**
+Optional name of the array that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema name.
+   */
+    schemaName?: string;
+    /**
+Optional description of the array that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema description.
+*/
+    schemaDescription?: string;
+    /**
+The mode to use for object generation.
+
+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 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';
     /**
-     * Optional telemetry configuration (experimental).
+Optional telemetry configuration (experimental).
+   */
+    experimental_telemetry?: TelemetrySettings;
+}): Promise<GenerateObjectResult<Array<ELEMENT>>>;
+/**
+Generate JSON with any schema for a given prompt using a language model.
+
+This function does not stream the output. If you want to stream the output, use `streamObject` instead.
+
+@returns
+A result object that contains the generated object, the finish reason, the token usage, and additional information.
+ */
+declare function generateObject(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output: 'no-schema';
+    /**
+The language model to use.
+   */
+    model: LanguageModel;
+    /**
+The mode to use for object generation. Must be "json" for no-schema output.
+   */
+    mode?: 'json';
+    /**
+Optional telemetry configuration (experimental).
      */
     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'];
-    readonly experimental_providerMetadata: GenerateObjectResult<T>['experimental_providerMetadata'];
-    constructor(options: {
-        object: GenerateObjectResult<T>['object'];
-        finishReason: GenerateObjectResult<T>['finishReason'];
-        usage: GenerateObjectResult<T>['usage'];
-        warnings: GenerateObjectResult<T>['warnings'];
-        rawResponse: GenerateObjectResult<T>['rawResponse'];
-        logprobs: GenerateObjectResult<T>['logprobs'];
-        providerMetadata: GenerateObjectResult<T>['experimental_providerMetadata'];
-    });
-    toJsonResponse(init?: ResponseInit): Response;
-}
+}): Promise<GenerateObjectResult<JSONValue>>;
 /**
  * @deprecated Use `generateObject` instead.
  */
@@ -698,7 +718,7 @@ 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> {
+interface StreamObjectResult<PARTIAL, RESULT, ELEMENT_STREAM> {
     /**
     Warnings from the model provider (e.g. unsupported settings)
        */
@@ -725,14 +745,18 @@ interface StreamObjectResult<T> {
     /**
     The generated object (typed according to the schema). Resolved when the response is finished.
        */
-    readonly object: Promise<T>;
+    readonly object: Promise<RESULT>;
     /**
     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>>;
+    readonly partialObjectStream: AsyncIterableStream<PARTIAL>;
+    /**
+     * Stream over complete array elements. Only available if the output strategy is set to `array`.
+     */
+    readonly elementStream: ELEMENT_STREAM;
     /**
     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.
@@ -742,7 +766,7 @@ interface StreamObjectResult<T> {
     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>>;
+    readonly fullStream: AsyncIterableStream<ObjectStreamPart<PARTIAL>>;
     /**
     Writes text delta output to a Node.js response-like object.
     It sets a `Content-Type` header to `text/plain; charset=utf-8` and
@@ -779,76 +803,129 @@ type ObjectStreamInputPart = {
     };
     providerMetadata?: ProviderMetadata;
 };
-type ObjectStreamPart<T> = ObjectStreamInputPart | {
+type ObjectStreamPart<PARTIAL> = ObjectStreamInputPart | {
     type: 'object';
-    object: DeepPartial<T>;
+    object: PARTIAL;
 } | {
     type: 'text-delta';
     textDelta: string;
 };
 
+type OnFinishCallback<RESULT> = (event: {
+    /**
+  The token usage of the generated response.
+  */
+    usage: CompletionTokenUsage$1;
+    /**
+  The generated object. Can be undefined if the final object does not match the schema.
+  */
+    object: RESULT | undefined;
+    /**
+  Optional error object. This is e.g. a TypeValidationError when the final object does not match the schema.
+  */
+    error: unknown | undefined;
+    /**
+  Optional raw response data.
+  */
+    rawResponse?: {
+        /**
+    Response headers.
+    */
+        headers?: Record<string, string>;
+    };
+    /**
+  Warnings from the model provider (e.g. unsupported settings).
+  */
+    warnings?: CallWarning[];
+    /**
+  Additional provider-specific metadata. They are passed through
+  from the provider to the AI SDK and enable provider-specific
+  results that can be fully encapsulated in the provider.
+  */
+    experimental_providerMetadata: ProviderMetadata | undefined;
+}) => Promise<void> | void;
 /**
 Generate a structured, typed object for a given prompt and schema using a language model.
 
 This function streams the output. If you do not want to stream the output, use `generateObject` instead.
 
-@param model - The language model to use.
+@return
+A result object for accessing the partial object stream and additional information.
+ */
+declare function streamObject<OBJECT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output?: 'object' | undefined;
+    /**
+The language model to use.
+   */
+    model: LanguageModel;
+    /**
+The schema of the object that the model should generate.
+*/
+    schema: z.Schema<OBJECT, z.ZodTypeDef, any> | Schema<OBJECT>;
+    /**
+Optional name of the output that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema name.
+   */
+    schemaName?: string;
+    /**
+Optional description of the output that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema description.
+*/
+    schemaDescription?: string;
+    /**
+The mode to use for object generation.
 
-@param schema - The schema of the object that the model should generate.
-@param schemaName - Optional name of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema name.
-@param schemaDescription - Optional description of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema description.
-@param mode - The mode to use for object generation. Not all models support all modes. Defaults to 'auto'.
+The schema is converted in a JSON schema and used in one of the following ways
 
-@param system - A system message that will be part of the prompt.
-@param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
-@param messages - A list of messages. You can either use `prompt` or `messages` but not both.
+- '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 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.
 
-@param maxTokens - Maximum number of tokens to generate.
-@param temperature - Temperature setting.
-The value is passed through to the provider. The range depends on the provider and model.
-It is recommended to set either `temperature` or `topP`, but not both.
-@param topP - Nucleus sampling.
-The value is passed through to the provider. The range depends on the provider and model.
-It is recommended to set either `temperature` or `topP`, but not both.
-@param topK - Only sample from the top K options for each subsequent token.
-Used to remove "long tail" low probability responses.
-Recommended for advanced use cases only. You usually only need to use temperature.
-@param presencePenalty - Presence penalty setting.
-It affects the likelihood of the model to repeat information that is already in the prompt.
-The value is passed through to the provider. The range depends on the provider and model.
-@param frequencyPenalty - Frequency penalty setting.
-It affects the likelihood of the model to repeatedly use the same words or phrases.
-The value is passed through to the provider. The range depends on the provider and model.
-@param seed - The seed (integer) to use for random sampling.
-If set and supported by the model, calls will generate deterministic results.
+Please note that most providers do not support all modes.
 
-@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
-@param abortSignal - An optional abort signal that can be used to cancel the call.
-@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+Default and recommended: 'auto' (best mode for the model).
+   */
+    mode?: 'auto' | 'json' | 'tool';
+    /**
+Optional telemetry configuration (experimental).
+   */
+    experimental_telemetry?: TelemetrySettings;
+    /**
+Callback that is called when the LLM response and the final object validation are finished.
+   */
+    onFinish?: OnFinishCallback<OBJECT>;
+}): Promise<StreamObjectResult<DeepPartial<OBJECT>, OBJECT, never>>;
+/**
+Generate an array with structured, typed elements for a given prompt and element schema using a language model.
+
+This function streams the output. If you do not want to stream the output, use `generateObject` instead.
 
 @return
 A result object for accessing the partial object stream and additional information.
  */
-declare function streamObject<T>({ model, schema: inputSchema, schemaName, schemaDescription, mode, system, prompt, messages, maxRetries, abortSignal, headers, experimental_telemetry: telemetry, onFinish, ...settings }: Omit<CallSettings, 'stopSequences'> & Prompt & {
+declare function streamObject<ELEMENT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output: 'array';
     /**
 The language model to use.
-     */
+   */
     model: LanguageModel;
     /**
-The schema of the object that the model should generate.
- */
-    schema: z.Schema<T, z.ZodTypeDef, any> | Schema<T>;
+The element schema of the array that the model should generate.
+*/
+    schema: z.Schema<ELEMENT, z.ZodTypeDef, any> | Schema<ELEMENT>;
     /**
-Optional name of the output that should be generated.
+Optional name of the array that should be generated.
 Used by some providers for additional LLM guidance, e.g.
 via tool or schema name.
-     */
+   */
     schemaName?: string;
     /**
-Optional description of the output that should be generated.
+Optional description of the array that should be generated.
 Used by some providers for additional LLM guidance, e.g.
 via tool or schema description.
- */
+*/
     schemaDescription?: string;
     /**
 The mode to use for object generation.
@@ -862,91 +939,58 @@ The schema is converted in a JSON schema and used in one of the following ways
 Please note that most providers do not support all modes.
 
 Default and recommended: 'auto' (best mode for the model).
-     */
+   */
     mode?: 'auto' | 'json' | 'tool';
     /**
 Optional telemetry configuration (experimental).
-     */
+   */
     experimental_telemetry?: TelemetrySettings;
     /**
 Callback that is called when the LLM response and the final object validation are finished.
-     */
-    onFinish?: (event: {
-        /**
-  The token usage of the generated response.
-  */
-        usage: CompletionTokenUsage$1;
-        /**
-  The generated object (typed according to the schema). Can be undefined if the final object does not match the schema.
-     */
-        object: T | undefined;
-        /**
-  Optional error object. This is e.g. a TypeValidationError when the final object does not match the schema.
-     */
-        error: unknown | undefined;
-        /**
-  Optional raw response data.
-     */
-        rawResponse?: {
-            /**
-    Response headers.
-         */
-            headers?: Record<string, string>;
-        };
-        /**
-  Warnings from the model provider (e.g. unsupported settings).
-         */
-        warnings?: CallWarning[];
-        /**
-  Additional provider-specific metadata. They are passed through
-  from the provider to the AI SDK and enable provider-specific
-  results that can be fully encapsulated in the provider.
-     */
-        experimental_providerMetadata: ProviderMetadata | undefined;
-    }) => Promise<void> | void;
-}): Promise<DefaultStreamObjectResult<T>>;
-declare class DefaultStreamObjectResult<T> implements StreamObjectResult<T> {
-    private readonly originalStream;
-    private readonly objectPromise;
-    readonly warnings: StreamObjectResult<T>['warnings'];
-    readonly usage: StreamObjectResult<T>['usage'];
-    readonly experimental_providerMetadata: StreamObjectResult<T>['experimental_providerMetadata'];
-    readonly rawResponse: StreamObjectResult<T>['rawResponse'];
-    constructor({ stream, warnings, rawResponse, schema, onFinish, rootSpan, doStreamSpan, telemetry, startTimestamp, }: {
-        stream: ReadableStream<string | Omit<LanguageModelV1StreamPart, 'text-delta'>>;
-        warnings: StreamObjectResult<T>['warnings'];
-        rawResponse?: StreamObjectResult<T>['rawResponse'];
-        schema: z.Schema<T, z.ZodTypeDef, any> | Schema<T>;
-        onFinish: Parameters<typeof streamObject<T>>[0]['onFinish'];
-        rootSpan: Span;
-        doStreamSpan: Span;
-        telemetry: TelemetrySettings | undefined;
-        startTimestamp: number;
-    });
-    get object(): Promise<T>;
-    get partialObjectStream(): AsyncIterableStream<DeepPartial<T>>;
-    get textStream(): AsyncIterableStream<string>;
-    get fullStream(): AsyncIterableStream<ObjectStreamPart<T>>;
-    pipeTextStreamToResponse(response: ServerResponse, init?: {
-        headers?: Record<string, string>;
-        status?: number;
-    }): void;
-    toTextStreamResponse(init?: ResponseInit): Response;
-}
+   */
+    onFinish?: OnFinishCallback<Array<ELEMENT>>;
+}): Promise<StreamObjectResult<Array<ELEMENT>, Array<ELEMENT>, AsyncIterableStream<ELEMENT>>>;
+/**
+Generate JSON with any schema for a given prompt using a language model.
+
+This function streams the output. If you do not want to stream the output, use `generateObject` instead.
+
+@return
+A result object for accessing the partial object stream and additional information.
+ */
+declare function streamObject(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output: 'no-schema';
+    /**
+The language model to use.
+   */
+    model: LanguageModel;
+    /**
+The mode to use for object generation. Must be "json" for no-schema output.
+   */
+    mode?: 'json';
+    /**
+Optional telemetry configuration (experimental).
+   */
+    experimental_telemetry?: TelemetrySettings;
+    /**
+Callback that is called when the LLM response and the final object validation are finished.
+   */
+    onFinish?: OnFinishCallback<JSONValue>;
+}): Promise<StreamObjectResult<JSONValue, JSONValue, never>>;
 /**
  * @deprecated Use `streamObject` instead.
  */
 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;
+type Parameters = z.ZodTypeAny | Schema<any>;
+type inferParameters<PARAMETERS extends Parameters> = 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 Parameters$1 = any, RESULT = any> {
+interface CoreTool<PARAMETERS extends Parameters = 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.
      */
@@ -966,12 +1010,12 @@ interface CoreTool<PARAMETERS extends Parameters$1 = any, RESULT = any> {
 /**
 Helper function for inferring the execute args of a tool.
  */
-declare function tool<PARAMETERS extends Parameters$1, RESULT>(tool: CoreTool<PARAMETERS, RESULT> & {
+declare function tool<PARAMETERS extends Parameters, RESULT>(tool: CoreTool<PARAMETERS, RESULT> & {
     execute: (args: inferParameters<PARAMETERS>) => PromiseLike<RESULT>;
 }): CoreTool<PARAMETERS, RESULT> & {
     execute: (args: inferParameters<PARAMETERS>) => PromiseLike<RESULT>;
 };
-declare function tool<PARAMETERS extends Parameters$1, RESULT>(tool: CoreTool<PARAMETERS, RESULT> & {
+declare function tool<PARAMETERS extends Parameters, RESULT>(tool: CoreTool<PARAMETERS, RESULT> & {
     execute?: undefined;
 }): CoreTool<PARAMETERS, RESULT> & {
     execute: undefined;
@@ -1406,6 +1450,7 @@ interface StreamTextResult<TOOLS extends Record<string, CoreTool>> {
     toDataStreamResponse(options?: ResponseInit | {
         init?: ResponseInit;
         data?: StreamData;
+        getErrorMessage?: (error: unknown) => string;
     }): Response;
     /**
     Creates a simple text stream response.
@@ -1565,64 +1610,7 @@ Callback that is called when the LLM response and all request tool executions
      */
         readonly experimental_providerMetadata: ProviderMetadata | undefined;
     }) => Promise<void> | void;
-}): Promise<DefaultStreamTextResult<TOOLS>>;
-declare class DefaultStreamTextResult<TOOLS extends Record<string, CoreTool>> implements StreamTextResult<TOOLS> {
-    private originalStream;
-    readonly warnings: StreamTextResult<TOOLS>['warnings'];
-    readonly usage: StreamTextResult<TOOLS>['usage'];
-    readonly finishReason: StreamTextResult<TOOLS>['finishReason'];
-    readonly experimental_providerMetadata: StreamTextResult<TOOLS>['experimental_providerMetadata'];
-    readonly text: StreamTextResult<TOOLS>['text'];
-    readonly toolCalls: StreamTextResult<TOOLS>['toolCalls'];
-    readonly toolResults: StreamTextResult<TOOLS>['toolResults'];
-    readonly rawResponse: StreamTextResult<TOOLS>['rawResponse'];
-    constructor({ stream, warnings, rawResponse, onChunk, onFinish, rootSpan, doStreamSpan, telemetry, startTimestamp, }: {
-        stream: ReadableStream<TextStreamPart<TOOLS>>;
-        warnings: StreamTextResult<TOOLS>['warnings'];
-        rawResponse: StreamTextResult<TOOLS>['rawResponse'];
-        onChunk: Parameters<typeof streamText>[0]['onChunk'];
-        onFinish: Parameters<typeof streamText>[0]['onFinish'];
-        rootSpan: Span;
-        doStreamSpan: Span;
-        telemetry: TelemetrySettings | undefined;
-        startTimestamp: number;
-    });
-    /**
-  Split out a new stream from the original stream.
-  The original stream is replaced to allow for further splitting,
-  since we do not know how many times the stream will be split.
-  
-  Note: this leads to buffering the stream content on the server.
-  However, the LLM results are expected to be small enough to not cause issues.
-     */
-    private teeStream;
-    get textStream(): AsyncIterableStream<string>;
-    get fullStream(): AsyncIterableStream<TextStreamPart<TOOLS>>;
-    toAIStream(callbacks?: AIStreamCallbacksAndOptions): ReadableStream<Uint8Array>;
-    private toDataStream;
-    pipeAIStreamToResponse(response: ServerResponse$1, init?: {
-        headers?: Record<string, string>;
-        status?: number;
-    }): void;
-    pipeDataStreamToResponse(response: ServerResponse$1, init?: {
-        headers?: Record<string, string>;
-        status?: number;
-    }): void;
-    pipeTextStreamToResponse(response: ServerResponse$1, init?: {
-        headers?: Record<string, string>;
-        status?: number;
-    }): void;
-    toAIStreamResponse(options?: ResponseInit | {
-        init?: ResponseInit;
-        data?: StreamData;
-    }): Response;
-    toDataStreamResponse(options?: ResponseInit | {
-        init?: ResponseInit;
-        data?: StreamData;
-        getErrorMessage?: (error: unknown) => string;
-    }): Response;
-    toTextStreamResponse(init?: ResponseInit): Response;
-}
+}): Promise<StreamTextResult<TOOLS>>;
 /**
  * @deprecated Use `streamText` instead.
  */
@@ -2083,7 +2071,7 @@ type OpenAIStreamCallbacks = AIStreamCallbacksAndOptions & {
      * })
      * ```
      */
-    experimental_onFunctionCall?: (functionCallPayload: FunctionCallPayload, createFunctionCallMessages: (functionCallResult: JSONValue) => CreateMessage[]) => Promise<Response | undefined | void | string | AsyncIterableOpenAIStreamReturnTypes>;
+    experimental_onFunctionCall?: (functionCallPayload: FunctionCallPayload, createFunctionCallMessages: (functionCallResult: JSONValue$1) => CreateMessage[]) => Promise<Response | undefined | void | string | AsyncIterableOpenAIStreamReturnTypes>;
     /**
      * @example
      * ```js
@@ -2122,7 +2110,7 @@ type OpenAIStreamCallbacks = AIStreamCallbacksAndOptions & {
     experimental_onToolCall?: (toolCallPayload: ToolCallPayload, appendToolCallMessage: (result?: {
         tool_call_id: string;
         function_name: string;
-        tool_call_result: JSONValue;
+        tool_call_result: JSONValue$1;
     }) => CreateMessage[]) => Promise<Response | undefined | void | string | AsyncIterableOpenAIStreamReturnTypes>;
 };
 interface ChatCompletionChunk {
@@ -2583,8 +2571,8 @@ declare class StreamData {
     private warningTimeout;
     constructor();
     close(): Promise<void>;
-    append(value: JSONValue): void;
-    appendMessageAnnotation(value: JSONValue): void;
+    append(value: JSONValue$1): void;
+    appendMessageAnnotation(value: JSONValue$1): void;
 }
 /**
  * A TransformStream for LLMs that do not have their own transform stream handlers managing encoding (e.g. OpenAIStream has one for function call handling).