ai 3.3.16 → 3.3.17

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 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, JSONValue, 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';
@@ -595,7 +595,7 @@ This function does not stream the output. If you want to stream the output, use
 @returns
 A result object that contains the generated object, the finish reason, the token usage, and additional information.
  */
-declare function generateObject<T>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+declare function generateObject<OBJECT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
     output?: 'object' | undefined;
     /**
 The language model to use.
@@ -604,7 +604,7 @@ The language model to use.
     /**
 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.
@@ -635,7 +635,56 @@ Default and recommended: 'auto' (best mode for the model).
 Optional telemetry configuration (experimental).
      */
     experimental_telemetry?: TelemetrySettings;
-}): Promise<DefaultGenerateObjectResult<T>>;
+}): 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).
+   */
+    experimental_telemetry?: TelemetrySettings;
+}): Promise<GenerateObjectResult<Array<ELEMENT>>>;
 /**
 Generate JSON with any schema for a given prompt using a language model.
 
@@ -658,26 +707,7 @@ The mode to use for object generation. Must be "json" for no-schema output.
 Optional telemetry configuration (experimental).
      */
     experimental_telemetry?: TelemetrySettings;
-}): Promise<DefaultGenerateObjectResult<JSONValue>>;
-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.
  */
@@ -688,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)
        */
@@ -715,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.
@@ -732,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
@@ -769,14 +803,47 @@ 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.
 
@@ -785,7 +852,8 @@ This function streams the output. If you do not want to stream the output, use `
 @return
 A result object for accessing the partial object stream and additional information.
  */
-declare function streamObject<T>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+declare function streamObject<OBJECT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output?: 'object' | undefined;
     /**
 The language model to use.
    */
@@ -793,7 +861,7 @@ The language model to use.
     /**
 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.
@@ -827,40 +895,61 @@ Optional telemetry configuration (experimental).
     /**
 Callback that is called when the LLM response and the final object validation are finished.
    */
-    onFinish?: (event: {
-        /**
-The token usage of the generated response.
+    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<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.
 */
-        usage: CompletionTokenUsage$1;
-        /**
-The generated object (typed according to the schema). Can be undefined if the final object does not match the schema.
+    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.
    */
-        object: T | undefined;
-        /**
-Optional error object. This is e.g. a TypeValidationError when the final object does not match the schema.
+    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).
    */
-        error: unknown | undefined;
-        /**
-Optional raw response data.
+    mode?: 'auto' | 'json' | 'tool';
+    /**
+Optional telemetry configuration (experimental).
    */
-        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_telemetry?: TelemetrySettings;
+    /**
+Callback that is called when the LLM response and the final object validation are finished.
    */
-        experimental_providerMetadata: ProviderMetadata | undefined;
-    }) => Promise<void> | void;
-}): Promise<DefaultStreamObjectResult<T>>;
+    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.
 
@@ -886,82 +975,22 @@ Optional telemetry configuration (experimental).
     /**
 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: JSONValue | 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<JSONValue>>;
-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<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.
      */
@@ -981,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;
@@ -1421,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.
@@ -1580,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.
  */