@mastra/ai-sdk 1.10.6 → 1.10.7-alpha.1

package/dist/_types/@internal_ai-sdk-v5/dist/index.d.ts

@@ -143,6 +143,9 @@ declare namespace _ai_sdk_provider_utils {
         Resolvable,
         ResponseHandler,
         Schema,
+        StreamingToolCallDelta,
+        StreamingToolCallTracker,
+        StreamingToolCallTrackerOptions,
         SystemModelMessage,
         TextPart,
         Tool,
@@ -3868,6 +3871,107 @@ declare type LanguageModelV2CallOptions = {
     providerOptions?: SharedV2ProviderOptions;
 };
 
+declare type LanguageModelV2CallOptions_2 = {
+    /**
+     A language mode prompt is a standardized prompt type.
+
+     Note: This is **not** the user-facing prompt. The AI SDK methods will map the
+     user-facing prompt types such as chat or instruction prompts to this format.
+     That approach allows us to evolve the user  facing prompts without breaking
+     the language model interface.
+     */
+    prompt: LanguageModelV2Prompt_2;
+    /**
+     Maximum number of tokens to generate.
+     */
+    maxOutputTokens?: number;
+    /**
+     Temperature setting. The range depends on the provider and model.
+     */
+    temperature?: 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[];
+    /**
+     Nucleus sampling.
+     */
+    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.
+     */
+    presencePenalty?: number;
+    /**
+     Frequency penalty setting. It affects the likelihood of the model
+     to repeatedly use the same words or phrases.
+     */
+    frequencyPenalty?: number;
+    /**
+     Response format. The output can either be text or JSON. Default is text.
+
+     If JSON is selected, a schema can optionally be provided to guide the LLM.
+     */
+    responseFormat?: {
+        type: 'text';
+    } | {
+        type: 'json';
+        /**
+         * JSON schema that the generated output should conform to.
+         */
+        schema?: JSONSchema7;
+        /**
+         * Name of output that should be generated. Used by some providers for additional LLM guidance.
+         */
+        name?: string;
+        /**
+         * Description of the output that should be generated. Used by some providers for additional LLM guidance.
+         */
+        description?: string;
+    };
+    /**
+     The seed (integer) to use for random sampling. If set and supported
+     by the model, calls will generate deterministic results.
+     */
+    seed?: number;
+    /**
+     The tools that are available for the model.
+     */
+    tools?: Array<LanguageModelV2FunctionTool_2 | LanguageModelV2ProviderDefinedTool_2>;
+    /**
+     Specifies how the tool should be selected. Defaults to 'auto'.
+     */
+    toolChoice?: LanguageModelV2ToolChoice_2;
+    /**
+     Include raw chunks in the stream. Only applicable for streaming calls.
+     */
+    includeRawChunks?: boolean;
+    /**
+     Abort signal for cancelling the operation.
+     */
+    abortSignal?: AbortSignal;
+    /**
+     Additional HTTP headers to be sent with the request.
+     Only applicable for HTTP-based providers.
+     */
+    headers?: Record<string, string | undefined>;
+    /**
+     * Additional provider-specific options. They are passed through
+     * to the provider from the AI SDK and enable provider-specific
+     * functionality that can be fully encapsulated in the provider.
+     */
+    providerOptions?: SharedV2ProviderOptions_2;
+};
+
 /**
  Warning from the model provider for this call. The call will proceed, but e.g.
  some settings might not be supported, which can lead to suboptimal results.
@@ -3885,6 +3989,23 @@ declare type LanguageModelV2CallWarning = {
     message: string;
 };
 
+/**
+ Warning from the model provider for this call. The call will proceed, but e.g.
+ some settings might not be supported, which can lead to suboptimal results.
+ */
+declare type LanguageModelV2CallWarning_2 = {
+    type: 'unsupported-setting';
+    setting: Omit<keyof LanguageModelV2CallOptions_2, 'prompt'>;
+    details?: string;
+} | {
+    type: 'unsupported-tool';
+    tool: LanguageModelV2FunctionTool_2 | LanguageModelV2ProviderDefinedTool_2;
+    details?: string;
+} | {
+    type: 'other';
+    message: string;
+};
+
 declare type LanguageModelV2Content = LanguageModelV2Text | LanguageModelV2Reasoning | LanguageModelV2File | LanguageModelV2Source | LanguageModelV2ToolCall | LanguageModelV2ToolResult;
 
 /**
@@ -3921,6 +4042,30 @@ declare type LanguageModelV2File = {
     data: string | Uint8Array;
 };
 
+/**
+ A file that has been generated by the model.
+ Generated files as base64 encoded strings or binary data.
+ The files should be returned without any unnecessary conversion.
+ */
+declare type LanguageModelV2File_2 = {
+    type: 'file';
+    /**
+     The IANA media type of the file, e.g. `image/png` or `audio/mp3`.
+
+     @see https://www.iana.org/assignments/media-types/media-types.xhtml
+     */
+    mediaType: string;
+    /**
+     Generated file data as base64 encoded strings or binary data.
+
+     The file data should be returned without any unnecessary conversion.
+     If the API returns base64 encoded strings, the file data should be returned
+     as base64 encoded strings. If the API returns binary data, the file data should
+     be returned as binary data.
+     */
+    data: string | Uint8Array;
+};
+
 /**
  File content part of a prompt. It contains a file.
  */
@@ -4000,6 +4145,20 @@ declare interface LanguageModelV2FilePart_2 {
  */
 declare type LanguageModelV2FinishReason = 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other' | 'unknown';
 
+/**
+ Reason why a language model finished generating a response.
+
+ Can be one of the following:
+ - `stop`: model generated stop sequence
+ - `length`: model generated maximum number of tokens
+ - `content-filter`: content filter violation stopped the model
+ - `tool-calls`: model triggered tool calls
+ - `error`: model stopped because of an error
+ - `other`: model stopped for other reasons
+ - `unknown`: the model has not transmitted a finish reason
+ */
+declare type LanguageModelV2FinishReason_2 = 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other' | 'unknown';
+
 /**
  A tool has a name, a description, and a set of parameters.
 
@@ -4031,6 +4190,37 @@ declare type LanguageModelV2FunctionTool = {
     providerOptions?: SharedV2ProviderOptions;
 };
 
+/**
+ A tool has a name, a description, and a set of parameters.
+
+ Note: this is **not** the user-facing tool definition. The AI SDK methods will
+ map the user-facing tool definitions to this format.
+ */
+declare type LanguageModelV2FunctionTool_2 = {
+    /**
+     The type of the tool (always 'function').
+     */
+    type: 'function';
+    /**
+     The name of the tool. Unique within this model call.
+     */
+    name: string;
+    /**
+     A description of the tool. The language model uses this to understand the
+     tool's purpose and to provide better completion suggestions.
+     */
+    description?: string;
+    /**
+     The parameters that the tool expects. The language model uses this to
+     understand the tool's input requirements and to provide matching suggestions.
+     */
+    inputSchema: JSONSchema7;
+    /**
+     The provider-specific options for the tool.
+     */
+    providerOptions?: SharedV2ProviderOptions_2;
+};
+
 declare type LanguageModelV2Message = ({
     role: 'system';
     content: string;
@@ -4195,6 +4385,28 @@ declare type LanguageModelV2ProviderDefinedTool = {
     args: Record<string, unknown>;
 };
 
+/**
+ The configuration of a tool that is defined by the provider.
+ */
+declare type LanguageModelV2ProviderDefinedTool_2 = {
+    /**
+     The type of the tool (always 'provider-defined').
+     */
+    type: 'provider-defined';
+    /**
+     The ID of the tool. Should follow the format `<provider-name>.<unique-tool-name>`.
+     */
+    id: `${string}.${string}`;
+    /**
+     The name of the tool that the user must use in the tool set.
+     */
+    name: string;
+    /**
+     The arguments for configuring the tool. Must match the expected arguments defined by the provider for this tool.
+     */
+    args: Record<string, unknown>;
+};
+
 /**
  Reasoning that the model has generated.
  */
@@ -4256,6 +4468,21 @@ declare interface LanguageModelV2ResponseMetadata {
     modelId?: string;
 }
 
+declare interface LanguageModelV2ResponseMetadata_2 {
+    /**
+     ID for the generated response, if the provider sends one.
+     */
+    id?: string;
+    /**
+     Timestamp for the start of the generated response, if the provider sends one.
+     */
+    timestamp?: Date;
+    /**
+     The ID of the response model that was used to generate the response, if the provider sends one.
+     */
+    modelId?: string;
+}
+
 /**
  A source that has been used as input to generate the response.
  */
@@ -4309,6 +4536,59 @@ declare type LanguageModelV2Source = {
     providerMetadata?: SharedV2ProviderMetadata;
 };
 
+/**
+ A source that has been used as input to generate the response.
+ */
+declare type LanguageModelV2Source_2 = {
+    type: 'source';
+    /**
+     * The type of source - URL sources reference web content.
+     */
+    sourceType: 'url';
+    /**
+     * The ID of the source.
+     */
+    id: string;
+    /**
+     * The URL of the source.
+     */
+    url: string;
+    /**
+     * The title of the source.
+     */
+    title?: string;
+    /**
+     * Additional provider metadata for the source.
+     */
+    providerMetadata?: SharedV2ProviderMetadata_2;
+} | {
+    type: 'source';
+    /**
+     * The type of source - document sources reference files/documents.
+     */
+    sourceType: 'document';
+    /**
+     * The ID of the source.
+     */
+    id: string;
+    /**
+     * IANA media type of the document (e.g., 'application/pdf').
+     */
+    mediaType: string;
+    /**
+     * The title of the document.
+     */
+    title: string;
+    /**
+     * Optional filename of the document.
+     */
+    filename?: string;
+    /**
+     * Additional provider metadata for the source.
+     */
+    providerMetadata?: SharedV2ProviderMetadata_2;
+};
+
 declare type LanguageModelV2StreamPart = {
     type: 'text-start';
     providerMetadata?: SharedV2ProviderMetadata;
@@ -4368,6 +4648,65 @@ declare type LanguageModelV2StreamPart = {
     error: unknown;
 };
 
+declare type LanguageModelV2StreamPart_2 = {
+    type: 'text-start';
+    providerMetadata?: SharedV2ProviderMetadata_2;
+    id: string;
+} | {
+    type: 'text-delta';
+    id: string;
+    providerMetadata?: SharedV2ProviderMetadata_2;
+    delta: string;
+} | {
+    type: 'text-end';
+    providerMetadata?: SharedV2ProviderMetadata_2;
+    id: string;
+} | {
+    type: 'reasoning-start';
+    providerMetadata?: SharedV2ProviderMetadata_2;
+    id: string;
+} | {
+    type: 'reasoning-delta';
+    id: string;
+    providerMetadata?: SharedV2ProviderMetadata_2;
+    delta: string;
+} | {
+    type: 'reasoning-end';
+    id: string;
+    providerMetadata?: SharedV2ProviderMetadata_2;
+} | {
+    type: 'tool-input-start';
+    id: string;
+    toolName: string;
+    providerMetadata?: SharedV2ProviderMetadata_2;
+    providerExecuted?: boolean;
+} | {
+    type: 'tool-input-delta';
+    id: string;
+    delta: string;
+    providerMetadata?: SharedV2ProviderMetadata_2;
+} | {
+    type: 'tool-input-end';
+    id: string;
+    providerMetadata?: SharedV2ProviderMetadata_2;
+} | LanguageModelV2ToolCall_2 | LanguageModelV2ToolResult_2 | LanguageModelV2File_2 | LanguageModelV2Source_2 | {
+    type: 'stream-start';
+    warnings: Array<LanguageModelV2CallWarning_2>;
+} | ({
+    type: 'response-metadata';
+} & LanguageModelV2ResponseMetadata_2) | {
+    type: 'finish';
+    usage: LanguageModelV2Usage_2;
+    finishReason: LanguageModelV2FinishReason_2;
+    providerMetadata?: SharedV2ProviderMetadata_2;
+} | {
+    type: 'raw';
+    rawValue: unknown;
+} | {
+    type: 'error';
+    error: unknown;
+};
+
 /**
  Text that the model has generated.
  */
@@ -4443,6 +4782,35 @@ declare type LanguageModelV2ToolCall = {
     providerMetadata?: SharedV2ProviderMetadata;
 };
 
+/**
+ * Tool calls that the model has generated.
+ */
+declare type LanguageModelV2ToolCall_2 = {
+    type: 'tool-call';
+    /**
+     * The identifier of the tool call. It must be unique across all tool calls.
+     */
+    toolCallId: string;
+    /**
+     * The name of the tool that should be called.
+     */
+    toolName: string;
+    /**
+     * Stringified JSON object with the tool call arguments. Must match the
+     * parameters schema of the tool.
+     */
+    input: string;
+    /**
+     * Whether the tool call will be executed by the provider.
+     * If this flag is not set or is false, the tool call will be executed by the client.
+     */
+    providerExecuted?: boolean;
+    /**
+     * Additional provider-specific metadata for the tool call.
+     */
+    providerMetadata?: SharedV2ProviderMetadata_2;
+};
+
 /**
  Tool call content part of a prompt. It contains a tool call (usually generated by the AI model).
  */
@@ -4514,6 +4882,17 @@ declare type LanguageModelV2ToolChoice = {
     toolName: string;
 };
 
+declare type LanguageModelV2ToolChoice_2 = {
+    type: 'auto';
+} | {
+    type: 'none';
+} | {
+    type: 'required';
+} | {
+    type: 'tool';
+    toolName: string;
+};
+
 /**
  Result of a tool call that has been executed by the provider.
  */
@@ -4547,6 +4926,39 @@ declare type LanguageModelV2ToolResult = {
     providerMetadata?: SharedV2ProviderMetadata;
 };
 
+/**
+ Result of a tool call that has been executed by the provider.
+ */
+declare type LanguageModelV2ToolResult_2 = {
+    type: 'tool-result';
+    /**
+     * The ID of the tool call that this result is associated with.
+     */
+    toolCallId: string;
+    /**
+     * Name of the tool that generated this result.
+     */
+    toolName: string;
+    /**
+     * Result of the tool call. This is a JSON-serializable object.
+     */
+    result: unknown;
+    /**
+     * Optional flag if the result is an error or an error message.
+     */
+    isError?: boolean;
+    /**
+     * Whether the tool result was generated by the provider.
+     * If this flag is set to true, the tool result was generated by the provider.
+     * If this flag is not set or is false, the tool result was generated by the client.
+     */
+    providerExecuted?: boolean;
+    /**
+     * Additional provider-specific metadata for the tool result.
+     */
+    providerMetadata?: SharedV2ProviderMetadata_2;
+};
+
 declare type LanguageModelV2ToolResultOutput = {
     type: 'text';
     value: string;
@@ -4696,6 +5108,37 @@ declare type LanguageModelV2Usage = {
     cachedInputTokens?: number | undefined;
 };
 
+/**
+ Usage information for a language model call.
+
+ If your API return additional usage information, you can add it to the
+ provider metadata under your provider's key.
+ */
+declare type LanguageModelV2Usage_2 = {
+    /**
+     The number of input (prompt) tokens used.
+     */
+    inputTokens: number | undefined;
+    /**
+     The number of output (completion) tokens used.
+     */
+    outputTokens: number | undefined;
+    /**
+     The total number of tokens as reported by the provider.
+     This number might be different from the sum of `inputTokens` and `outputTokens`
+     and e.g. include reasoning tokens or other overhead.
+     */
+    totalTokens: number | undefined;
+    /**
+     The number of reasoning tokens used.
+     */
+    reasoningTokens?: number | undefined;
+    /**
+     The number of cached input tokens.
+     */
+    cachedInputTokens?: number | undefined;
+};
+
 /**
  Check if the message is an assistant message with completed tool calls.
  The last step of the message must have at least one tool invocation and
@@ -5965,6 +6408,29 @@ declare type SharedV2Headers = Record<string, string>;
  */
 declare type SharedV2ProviderMetadata = Record<string, Record<string, JSONValue_2>>;
 
+/**
+ * Additional provider-specific metadata.
+ * Metadata are additional outputs from the provider.
+ * They are passed through to the provider from the AI SDK
+ * and enable provider-specific functionality
+ * that can be fully encapsulated in the provider.
+ *
+ * This enables us to quickly ship provider-specific functionality
+ * without affecting the core AI SDK.
+ *
+ * The outer record is keyed by the provider name, and the inner
+ * record is keyed by the provider-specific metadata key.
+ *
+ * ```ts
+ * {
+ *   "anthropic": {
+ *     "cacheControl": { "type": "ephemeral" }
+ *   }
+ * }
+ * ```
+ */
+declare type SharedV2ProviderMetadata_2 = Record<string, Record<string, JSONValue_3>>;
+
 /**
  * Additional provider-specific options.
  * Options are additional input to the provider.
@@ -6874,6 +7340,76 @@ export declare type StopCondition<TOOLS extends ToolSet> = (options: {
     steps: Array<StepResult<TOOLS>>;
 }) => PromiseLike<boolean> | boolean;
 
+/**
+ * Minimal interface for a streaming tool call delta from an OpenAI-compatible API.
+ */
+declare interface StreamingToolCallDelta {
+    index?: number | null;
+    id?: string | null;
+    type?: string | null;
+    function?: {
+        name?: string | null;
+        arguments?: string | null;
+    } | null;
+}
+
+/**
+ * Tracks streaming tool call state across multiple deltas from an
+ * OpenAI-compatible chat completion stream.
+ */
+declare class StreamingToolCallTracker<DELTA extends StreamingToolCallDelta = StreamingToolCallDelta> {
+    private toolCalls;
+    private toolCallsById;
+    private toolCallsByIndex;
+    private usedToolCallIds;
+    private nextGeneratedIdSuffixes;
+    private readonly controller;
+    private readonly _generateId;
+    private readonly typeValidation;
+    private readonly extractMetadata?;
+    private readonly buildToolCallProviderMetadata?;
+    constructor(controller: StreamingToolCallTrackerController, options?: StreamingToolCallTrackerOptions<DELTA>);
+    processDelta(toolCallDelta: DELTA): void;
+    flush(): void;
+    private resolveToolCall;
+    private filterToolCallsByName;
+    private resolveMatchingToolCall;
+    private processNewToolCall;
+    private associateWireId;
+    private associateIndex;
+    private createToolCallId;
+    private getNonBlankString;
+    private processExistingToolCall;
+    private finishToolCall;
+}
+
+declare type StreamingToolCallTrackerController = Pick<TransformStreamDefaultController<LanguageModelV2StreamPart_2>, 'enqueue'>;
+
+declare interface StreamingToolCallTrackerOptions<DELTA extends StreamingToolCallDelta = StreamingToolCallDelta> {
+    /**
+     * ID generator function for tool call IDs.
+     * Blank or repeated outputs are converted to usable unique IDs.
+     * Defaults to the standard generateId.
+     */
+    generateId?: () => string;
+    /**
+     * How to validate the `type` field on new tool call deltas.
+     * - `'none'`: no validation (default)
+     * - `'if-present'`: throw if type is present and not `'function'`
+     * - `'required'`: throw if type is not exactly `'function'`
+     */
+    typeValidation?: 'none' | 'if-present' | 'required';
+    /**
+     * Extract provider-specific metadata from a tool call delta.
+     * Called once when a new tool call is detected.
+     */
+    extractMetadata?: (delta: DELTA) => SharedV2ProviderMetadata_2 | undefined;
+    /**
+     * Build the `providerMetadata` object for a `tool-call` event.
+     */
+    buildToolCallProviderMetadata?: (metadata: SharedV2ProviderMetadata_2 | undefined) => SharedV2ProviderMetadata_2 | undefined;
+}
+
 /**
  Generate a structured, typed object for a given prompt and schema using a language model.