@mastra/core 1.9.0 → 1.10.0

package/dist/docs/references/reference-streaming-ChunkType.md

@@ -6,11 +6,19 @@ The `ChunkType` type defines the mastra format of stream chunks that can be emit
 
 All chunks include these base properties:
 
-**type:** (`string`): The specific chunk type identifier
+**type** (`string`): The specific chunk type identifier
 
-**runId:** (`string`): Unique identifier for this execution run
+**runId** (`string`): Unique identifier for this execution run
 
-**from:** (`ChunkFrom`): enumAGENT:'AGENT'Chunk from agent executionUSER:'USER'Chunk from user inputSYSTEM:'SYSTEM'Chunk from system processesWORKFLOW:'WORKFLOW'Chunk from workflow execution
+**from** (`ChunkFrom`): Source of the chunk
+
+**from.AGENT** (`'AGENT'`): Chunk from agent execution
+
+**from.USER** (`'USER'`): Chunk from user input
+
+**from.SYSTEM** (`'SYSTEM'`): Chunk from system processes
+
+**from.WORKFLOW** (`'WORKFLOW'`): Chunk from workflow execution
 
 ## Text Chunks
 
@@ -18,25 +26,39 @@ All chunks include these base properties:
 
 Signals the beginning of text generation.
 
-**type:** (`"text-start"`): Chunk type identifier
+**type** (`"text-start"`): Chunk type identifier
+
+**payload** (`TextStartPayload`): Text start information
+
+**payload.id** (`string`): Unique identifier for this text generation
 
-**payload:** (`TextStartPayload`): TextStartPayloadid:stringUnique identifier for this text generationproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ### text-delta
 
 Incremental text content during generation.
 
-**type:** (`"text-delta"`): Chunk type identifier
+**type** (`"text-delta"`): Chunk type identifier
 
-**payload:** (`TextDeltaPayload`): TextDeltaPayloadid:stringUnique identifier for this text generationtext:stringThe incremental text contentproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload** (`TextDeltaPayload`): Incremental text content
+
+**payload.id** (`string`): Unique identifier for this text generation
+
+**payload.text** (`string`): The incremental text content
+
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ### text-end
 
 Signals the end of text generation.
 
-**type:** (`"text-end"`): Chunk type identifier
+**type** (`"text-end"`): Chunk type identifier
 
-**payload:** (`TextEndPayload`): TextEndPayloadid:stringUnique identifier for this text generationproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload** (`TextEndPayload`): Text end information
+
+**payload.id** (`string`): Unique identifier for this text generation
+
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ## Reasoning Chunks
 
@@ -44,33 +66,57 @@ Signals the end of text generation.
 
 Signals the beginning of reasoning generation (for models that support reasoning).
 
-**type:** (`"reasoning-start"`): Chunk type identifier
+**type** (`"reasoning-start"`): Chunk type identifier
+
+**payload** (`ReasoningStartPayload`): Reasoning start information
 
-**payload:** (`ReasoningStartPayload`): ReasoningStartPayloadid:stringUnique identifier for this reasoning generationsignature?:stringReasoning signature if availableproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload.id** (`string`): Unique identifier for this reasoning generation
+
+**payload.signature** (`string`): Reasoning signature if available
+
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ### reasoning-delta
 
 Incremental reasoning text during generation.
 
-**type:** (`"reasoning-delta"`): Chunk type identifier
+**type** (`"reasoning-delta"`): Chunk type identifier
+
+**payload** (`ReasoningDeltaPayload`): Incremental reasoning content
 
-**payload:** (`ReasoningDeltaPayload`): ReasoningDeltaPayloadid:stringUnique identifier for this reasoning generationtext:stringThe incremental reasoning textproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload.id** (`string`): Unique identifier for this reasoning generation
+
+**payload.text** (`string`): The incremental reasoning text
+
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ### reasoning-end
 
 Signals the end of reasoning generation.
 
-**type:** (`"reasoning-end"`): Chunk type identifier
+**type** (`"reasoning-end"`): Chunk type identifier
+
+**payload** (`ReasoningEndPayload`): Reasoning end information
 
-**payload:** (`ReasoningEndPayload`): ReasoningEndPayloadid:stringUnique identifier for this reasoning generationsignature?:stringFinal reasoning signature if availableproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload.id** (`string`): Unique identifier for this reasoning generation
+
+**payload.signature** (`string`): Final reasoning signature if available
+
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ### reasoning-signature
 
 Contains the reasoning signature from models that support advanced reasoning (like OpenAI's o1 series). The signature represents metadata about the model's internal reasoning process, such as effort level or reasoning approach, but not the actual reasoning content itself.
 
-**type:** (`"reasoning-signature"`): Chunk type identifier
+**type** (`"reasoning-signature"`): Chunk type identifier
+
+**payload** (`ReasoningSignaturePayload`): Metadata about the model's reasoning process characteristics
 
-**payload:** (`ReasoningSignaturePayload`): ReasoningSignaturePayloadid:stringUnique identifier for the reasoning sessionsignature:stringSignature describing the reasoning approach or effort level (e.g., reasoning effort settings)providerMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload.id** (`string`): Unique identifier for the reasoning session
+
+**payload.signature** (`string`): Signature describing the reasoning approach or effort level (e.g., reasoning effort settings)
+
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ## Tool Chunks
 
@@ -78,49 +124,111 @@ Contains the reasoning signature from models that support advanced reasoning (li
 
 A tool is being called.
 
-**type:** (`"tool-call"`): Chunk type identifier
+**type** (`"tool-call"`): Chunk type identifier
+
+**payload** (`ToolCallPayload`): Tool call information
 
-**payload:** (`ToolCallPayload`): ToolCallPayloadtoolCallId:stringUnique identifier for this tool calltoolName:stringName of the tool being calledargs?:Record\<string, any>Arguments passed to the toolproviderExecuted?:booleanWhether the provider executed the tooloutput?:anyTool output if availableproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload.toolCallId** (`string`): Unique identifier for this tool call
+
+**payload.toolName** (`string`): Name of the tool being called
+
+**payload.args** (`Record<string, any>`): Arguments passed to the tool
+
+**payload.providerExecuted** (`boolean`): Whether the provider executed the tool
+
+**payload.output** (`any`): Tool output if available
+
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ### tool-result
 
 Result from a tool execution.
 
-**type:** (`"tool-result"`): Chunk type identifier
+**type** (`"tool-result"`): Chunk type identifier
+
+**payload** (`ToolResultPayload`): Tool execution result
+
+**payload.toolCallId** (`string`): Unique identifier for the tool call
+
+**payload.toolName** (`string`): Name of the executed tool
+
+**payload.result** (`any`): The result of the tool execution
+
+**payload.isError** (`boolean`): Whether the result is an error
+
+**payload.providerExecuted** (`boolean`): Whether the provider executed the tool
+
+**payload.args** (`Record<string, any>`): Arguments that were passed to the tool
 
-**payload:** (`ToolResultPayload`): ToolResultPayloadtoolCallId:stringUnique identifier for the tool calltoolName:stringName of the executed toolresult:anyThe result of the tool executionisError?:booleanWhether the result is an errorproviderExecuted?:booleanWhether the provider executed the toolargs?:Record\<string, any>Arguments that were passed to the toolproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ### tool-call-input-streaming-start
 
 Signals the start of streaming tool call arguments.
 
-**type:** (`"tool-call-input-streaming-start"`): Chunk type identifier
+**type** (`"tool-call-input-streaming-start"`): Chunk type identifier
 
-**payload:** (`ToolCallInputStreamingStartPayload`): ToolCallInputStreamingStartPayloadtoolCallId:stringUnique identifier for this tool calltoolName:stringName of the tool being calledproviderExecuted?:booleanWhether the provider executed the tooldynamic?:booleanWhether the tool call is dynamicproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload** (`ToolCallInputStreamingStartPayload`): Tool call input streaming start information
+
+**payload.toolCallId** (`string`): Unique identifier for this tool call
+
+**payload.toolName** (`string`): Name of the tool being called
+
+**payload.providerExecuted** (`boolean`): Whether the provider executed the tool
+
+**payload.dynamic** (`boolean`): Whether the tool call is dynamic
+
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ### tool-call-delta
 
 Incremental tool call arguments during streaming.
 
-**type:** (`"tool-call-delta"`): Chunk type identifier
+**type** (`"tool-call-delta"`): Chunk type identifier
+
+**payload** (`ToolCallDeltaPayload`): Incremental tool call arguments
 
-**payload:** (`ToolCallDeltaPayload`): ToolCallDeltaPayloadargsTextDelta:stringIncremental text delta for tool argumentstoolCallId:stringUnique identifier for this tool calltoolName?:stringName of the tool being calledproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload.argsTextDelta** (`string`): Incremental text delta for tool arguments
+
+**payload.toolCallId** (`string`): Unique identifier for this tool call
+
+**payload.toolName** (`string`): Name of the tool being called
+
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ### tool-call-input-streaming-end
 
 Signals the end of streaming tool call arguments.
 
-**type:** (`"tool-call-input-streaming-end"`): Chunk type identifier
+**type** (`"tool-call-input-streaming-end"`): Chunk type identifier
 
-**payload:** (`ToolCallInputStreamingEndPayload`): ToolCallInputStreamingEndPayloadtoolCallId:stringUnique identifier for this tool callproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload** (`ToolCallInputStreamingEndPayload`): Tool call input streaming end information
+
+**payload.toolCallId** (`string`): Unique identifier for this tool call
+
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ### tool-error
 
 An error occurred during tool execution.
 
-**type:** (`"tool-error"`): Chunk type identifier
+**type** (`"tool-error"`): Chunk type identifier
+
+**payload** (`ToolErrorPayload`): Tool error information
 
-**payload:** (`ToolErrorPayload`): ToolErrorPayloadid?:stringOptional identifiertoolCallId:stringUnique identifier for the tool calltoolName:stringName of the tool that failedargs?:Record\<string, any>Arguments that were passed to the toolerror:unknownThe error that occurredproviderExecuted?:booleanWhether the provider executed the toolproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload.id** (`string`): Optional identifier
+
+**payload.toolCallId** (`string`): Unique identifier for the tool call
+
+**payload.toolName** (`string`): Name of the tool that failed
+
+**payload.args** (`Record<string, any>`): Arguments that were passed to the tool
+
+**payload.error** (`unknown`): The error that occurred
+
+**payload.providerExecuted** (`boolean`): Whether the provider executed the tool
+
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ## Source and File Chunks
 
@@ -128,17 +236,39 @@ An error occurred during tool execution.
 
 Contains source information for content.
 
-**type:** (`"source"`): Chunk type identifier
+**type** (`"source"`): Chunk type identifier
+
+**payload** (`SourcePayload`): Source information
+
+**payload.id** (`string`): Unique identifier
+
+**payload.sourceType** (`'url' | 'document'`): Type of source
+
+**payload.title** (`string`): Title of the source
+
+**payload.mimeType** (`string`): MIME type of the source
+
+**payload.filename** (`string`): Filename if applicable
 
-**payload:** (`SourcePayload`): SourcePayloadid:stringUnique identifiersourceType:'url' | 'document'Type of sourcetitle:stringTitle of the sourcemimeType?:stringMIME type of the sourcefilename?:stringFilename if applicableurl?:stringURL if applicableproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload.url** (`string`): URL if applicable
+
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ### file
 
 Contains file data.
 
-**type:** (`"file"`): Chunk type identifier
+**type** (`"file"`): Chunk type identifier
+
+**payload** (`FilePayload`): File data
+
+**payload.data** (`string | Uint8Array`): The file data
 
-**payload:** (`FilePayload`): FilePayloaddata:string | Uint8ArrayThe file database64?:stringBase64 encoded data if applicablemimeType:stringMIME type of the fileproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload.base64** (`string`): Base64 encoded data if applicable
+
+**payload.mimeType** (`string`): MIME type of the file
+
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ## Control Chunks
 
@@ -146,57 +276,97 @@ Contains file data.
 
 Signals the start of streaming.
 
-**type:** (`"start"`): Chunk type identifier
+**type** (`"start"`): Chunk type identifier
+
+**payload** (`StartPayload`): Start information
 
-**payload:** (`StartPayload`): StartPayload\[key: string]:anyAdditional start data
+**payload.\[key: string]** (`any`): Additional start data
 
 ### step-start
 
 Signals the start of a processing step.
 
-**type:** (`"step-start"`): Chunk type identifier
+**type** (`"step-start"`): Chunk type identifier
 
-**payload:** (`StepStartPayload`): StepStartPayloadmessageId?:stringOptional message identifierrequest:objectRequest information including body and other datawarnings?:LanguageModelV2CallWarning\[]Any warnings from the language model call
+**payload** (`StepStartPayload`): Step start information
+
+**payload.messageId** (`string`): Optional message identifier
+
+**payload.request** (`object`): Request information including body and other data
+
+**payload.warnings** (`LanguageModelV2CallWarning[]`): Any warnings from the language model call
 
 ### step-finish
 
 Signals the completion of a processing step.
 
-**type:** (`"step-finish"`): Chunk type identifier
+**type** (`"step-finish"`): Chunk type identifier
+
+**payload** (`StepFinishPayload`): Step completion information
+
+**payload.id** (`string`): Optional identifier
+
+**payload.messageId** (`string`): Optional message identifier
 
-**payload:** (`StepFinishPayload`): StepFinishPayloadid?:stringOptional identifiermessageId?:stringOptional message identifierstepResult:objectStep execution result with reason, warnings, and continuation infooutput:objectOutput information including usage statisticsmetadata:objectExecution metadata including request and provider infototalUsage?:LanguageModelV2UsageTotal usage statisticsresponse?:LanguageModelV2ResponseMetadataResponse metadataproviderMetadata?:SharedV2ProviderMetadataProvider-specific metadata
+**payload.stepResult** (`object`): Step execution result with reason, warnings, and continuation info
+
+**payload.output** (`object`): Output information including usage statistics
+
+**payload.metadata** (`object`): Execution metadata including request and provider info
+
+**payload.totalUsage** (`LanguageModelV2Usage`): Total usage statistics
+
+**payload.response** (`LanguageModelV2ResponseMetadata`): Response metadata
+
+**payload.providerMetadata** (`SharedV2ProviderMetadata`): Provider-specific metadata
 
 ### raw
 
 Contains raw data from the provider.
 
-**type:** (`"raw"`): Chunk type identifier
+**type** (`"raw"`): Chunk type identifier
+
+**payload** (`RawPayload`): Raw provider data
 
-**payload:** (`RawPayload`): RawPayload\[key: string]:anyRaw data from the provider
+**payload.\[key: string]** (`any`): Raw data from the provider
 
 ### finish
 
 Stream has completed successfully.
 
-**type:** (`"finish"`): Chunk type identifier
+**type** (`"finish"`): Chunk type identifier
 
-**payload:** (`FinishPayload`): FinishPayloadstepResult:objectStep execution resultoutput:objectOutput information including usagemetadata:objectExecution metadatamessages:objectMessage historyresponse:objectResponse metadata and messages from the model provider
+**payload** (`FinishPayload`): Completion information
+
+**payload.stepResult** (`object`): Step execution result
+
+**payload.output** (`object`): Output information including usage
+
+**payload.metadata** (`object`): Execution metadata
+
+**payload.messages** (`object`): Message history
+
+**payload.response** (`object`): Response metadata and messages from the model provider
 
 ### error
 
 An error occurred during streaming.
 
-**type:** (`"error"`): Chunk type identifier
+**type** (`"error"`): Chunk type identifier
+
+**payload** (`ErrorPayload`): Error information
 
-**payload:** (`ErrorPayload`): ErrorPayloaderror:unknownThe error that occurred
+**payload.error** (`unknown`): The error that occurred
 
 ### abort
 
 Stream was aborted.
 
-**type:** (`"abort"`): Chunk type identifier
+**type** (`"abort"`): Chunk type identifier
 
-**payload:** (`AbortPayload`): AbortPayload\[key: string]:anyAdditional abort data
+**payload** (`AbortPayload`): Abort information
+
+**payload.\[key: string]** (`any`): Additional abort data
 
 ## Object and Output Chunks
 
@@ -204,25 +374,29 @@ Stream was aborted.
 
 Emitted when using output generation with defined schemas. Contains partial or complete structured data that conforms to the specified Zod or JSON schema. This chunk is typically skipped in some execution contexts and used for streaming structured object generation.
 
-**type:** (`"object"`): Chunk type identifier
+**type** (`"object"`): Chunk type identifier
 
-**object:** (`Partial<OUTPUT>`): Partial or complete structured data matching the defined schema. The type is determined by the OUTPUT schema parameter.
+**object** (`Partial<OUTPUT>`): Partial or complete structured data matching the defined schema. The type is determined by the OUTPUT schema parameter.
 
 ### tool-output
 
 Contains output from agent or workflow execution, particularly used for tracking usage statistics and completion events. Often wraps other chunk types (like finish chunks) to provide nested execution context.
 
-**type:** (`"tool-output"`): Chunk type identifier
+**type** (`"tool-output"`): Chunk type identifier
+
+**payload** (`ToolOutputPayload`): Wrapped execution output with metadata
 
-**payload:** (`ToolOutputPayload`): ToolOutputPayloadoutput:ChunkTypeNested chunk data, often containing finish events with usage statistics
+**payload.output** (`ChunkType`): Nested chunk data, often containing finish events with usage statistics
 
 ### step-output
 
 Contains output from workflow step execution, used primarily for usage tracking and step completion events. Similar to tool-output but specifically for individual workflow steps.
 
-**type:** (`"step-output"`): Chunk type identifier
+**type** (`"step-output"`): Chunk type identifier
+
+**payload** (`StepOutputPayload`): Workflow step execution output with metadata
 
-**payload:** (`StepOutputPayload`): StepOutputPayloadoutput:ChunkTypeNested chunk data from step execution, typically containing finish events or other step results
+**payload.output** (`ChunkType`): Nested chunk data from step execution, typically containing finish events or other step results
 
 ## Metadata and Special Chunks
 
@@ -230,25 +404,43 @@ Contains output from workflow step execution, used primarily for usage tracking
 
 Contains metadata about the LLM provider's response. Emitted by some providers after text generation to provide additional context like model ID, timestamps, and response headers. This chunk is used internally for state tracking and doesn't affect message assembly.
 
-**type:** (`"response-metadata"`): Chunk type identifier
+**type** (`"response-metadata"`): Chunk type identifier
 
-**payload:** (`ResponseMetadataPayload`): ResponseMetadataPayloadsignature?:stringResponse signature if available\[key: string]:anyAdditional provider-specific metadata fields (e.g., id, modelId, timestamp, headers)
+**payload** (`ResponseMetadataPayload`): Provider response metadata for tracking and debugging
+
+**payload.signature** (`string`): Response signature if available
+
+**payload.\[key: string]** (`any`): Additional provider-specific metadata fields (e.g., id, modelId, timestamp, headers)
 
 ### watch
 
 Contains monitoring and observability data from agent execution. Can include workflow state information, execution progress, or other runtime details depending on the context where `stream()` is used.
 
-**type:** (`"watch"`): Chunk type identifier
+**type** (`"watch"`): Chunk type identifier
+
+**payload** (`WatchPayload`): Monitoring data for observability and debugging of agent execution
 
-**payload:** (`WatchPayload`): WatchPayloadworkflowState?:objectCurrent workflow execution state (when used in workflows)eventTimestamp?:numberTimestamp when the event occurred\[key: string]:anyAdditional monitoring and execution data
+**payload.workflowState** (`object`): Current workflow execution state (when used in workflows)
+
+**payload.eventTimestamp** (`number`): Timestamp when the event occurred
+
+**payload.\[key: string]** (`any`): Additional monitoring and execution data
 
 ### tripwire
 
 Emitted when the stream is forcibly terminated due to content being blocked by a processor. This acts as a safety mechanism to prevent harmful or inappropriate content from being streamed. The payload includes information about why the content was blocked and whether a retry was requested.
 
-**type:** (`"tripwire"`): Chunk type identifier
+**type** (`"tripwire"`): Chunk type identifier
+
+**payload** (`TripwirePayload`): Information about why the stream was terminated by safety mechanisms
+
+**payload.reason** (`string`): Explanation of why the content was blocked (e.g., 'Output processor blocked content')
+
+**payload.retry** (`boolean`): Whether the processor requested a retry of the step
+
+**payload.metadata** (`unknown`): Additional metadata from the processor (e.g., scores, categories)
 
-**payload:** (`TripwirePayload`): TripwirePayloadreason:stringExplanation of why the content was blocked (e.g., 'Output processor blocked content')retry?:booleanWhether the processor requested a retry of the stepmetadata?:unknownAdditional metadata from the processor (e.g., scores, categories)processorId?:stringID of the processor that triggered the tripwire
+**payload.processorId** (`string`): ID of the processor that triggered the tripwire
 
 ## Usage Example
 

package/dist/docs/references/reference-streaming-agents-MastraModelOutput.md

@@ -13,45 +13,115 @@ For setup and basic usage, see the [.stream()](https://mastra.ai/reference/strea
 
 These properties provide real-time access to model outputs as they're generated:
 
-**fullStream:** (`ReadableStream<ChunkType<OUTPUT>>`): ReadableStreamChunkType:ChunkType\<OUTPUT>All possible chunk types that can be emitted during streaming
+**fullStream** (`ReadableStream<ChunkType<OUTPUT>>`): Complete stream of all chunk types including text, tool calls, reasoning, metadata, and control chunks. Provides granular access to every aspect of the model's response.
 
-**textStream:** (`ReadableStream<string>`): Stream of incremental text content only. Filters out all metadata, tool calls, and control chunks to provide just the text being generated.
+**fullStream.ChunkType** (`ChunkType<OUTPUT>`): All possible chunk types that can be emitted during streaming
 
-**objectStream:** (`ReadableStream<Partial<OUTPUT>>`): ReadableStreamPartialSchemaOutput:Partial\<OUTPUT>Partially completed object matching the defined schema
+**textStream** (`ReadableStream<string>`): Stream of incremental text content only. Filters out all metadata, tool calls, and control chunks to provide just the text being generated.
 
-**elementStream:** (`ReadableStream<OUTPUT extends (infer T)[] ? T : never>`): Stream of individual array elements when the output schema defines an array type. Each element is emitted as it's completed rather than waiting for the entire array.
+**objectStream** (`ReadableStream<Partial<OUTPUT>>`): Stream of progressive structured object updates when using output schemas. Emits partial objects as they're built up, allowing real-time visualization of structured data generation.
+
+**objectStream.PartialSchemaOutput** (`Partial<OUTPUT>`): Partially completed object matching the defined schema
+
+**elementStream** (`ReadableStream<OUTPUT extends (infer T)[] ? T : never>`): Stream of individual array elements when the output schema defines an array type. Each element is emitted as it's completed rather than waiting for the entire array.
 
 ## Promise-based Properties
 
 These properties resolve to final values after the stream completes:
 
-**text:** (`Promise<string>`): The complete concatenated text response from the model. Resolves when text generation is finished.
+**text** (`Promise<string>`): The complete concatenated text response from the model. Resolves when text generation is finished.
+
+**object** (`Promise<OUTPUT>`): The complete structured object response when using output schemas. Validated against the schema before resolving. Rejects if validation fails.
+
+**object.InferSchemaOutput** (`OUTPUT`): Fully typed object matching the exact schema definition
+
+**reasoning** (`Promise<string>`): Complete reasoning text for models that support reasoning (like OpenAI's o1 series). Returns empty string for models without reasoning capability.
+
+**reasoningText** (`Promise<string | undefined>`): Alternative access to reasoning content. May be undefined for models that don't support reasoning, while 'reasoning' returns empty string.
+
+**toolCalls** (`Promise<ToolCallChunk[]>`): Array of all tool call chunks made during execution. Each chunk contains tool metadata and execution details.
+
+**toolCalls.type** (`'tool-call'`): Chunk type identifier
+
+**toolCalls.runId** (`string`): Execution run identifier
+
+**toolCalls.from** (`ChunkFrom`): Source of the chunk (AGENT, WORKFLOW, etc.)
+
+**toolCalls.payload** (`ToolCallPayload`): Tool call data including toolCallId, toolName, args, and execution details
+
+**toolResults** (`Promise<ToolResultChunk[]>`): Array of all tool result chunks corresponding to the tool calls. Contains execution results and error information.
+
+**toolResults.type** (`'tool-result'`): Chunk type identifier
+
+**toolResults.runId** (`string`): Execution run identifier
+
+**toolResults.from** (`ChunkFrom`): Source of the chunk (AGENT, WORKFLOW, etc.)
+
+**toolResults.payload** (`ToolResultPayload`): Tool result data including toolCallId, toolName, result, and error status
+
+**usage** (`Promise<LanguageModelUsage>`): Token usage statistics including input tokens, output tokens, total tokens, and reasoning tokens (for reasoning models).
+
+**usage.inputTokens** (`number`): Tokens consumed by the input prompt
 
-**object:** (`Promise<OUTPUT>`): PromiseInferSchemaOutput:OUTPUTFully typed object matching the exact schema definition
+**usage.outputTokens** (`number`): Tokens generated in the response
 
-**reasoning:** (`Promise<string>`): Complete reasoning text for models that support reasoning (like OpenAI's o1 series). Returns empty string for models without reasoning capability.
+**usage.totalTokens** (`number`): Sum of input and output tokens
 
-**reasoningText:** (`Promise<string | undefined>`): Alternative access to reasoning content. May be undefined for models that don't support reasoning, while 'reasoning' returns empty string.
+**usage.reasoningTokens** (`number`): Hidden reasoning tokens (for reasoning models)
 
-**toolCalls:** (`Promise<ToolCallChunk[]>`): ToolCallChunktype:'tool-call'Chunk type identifierrunId:stringExecution run identifierfrom:ChunkFromSource of the chunk (AGENT, WORKFLOW, etc.)payload:ToolCallPayloadTool call data including toolCallId, toolName, args, and execution details
+**usage.cachedInputTokens** (`number`): Number of input tokens that were a cache hit
 
-**toolResults:** (`Promise<ToolResultChunk[]>`): ToolResultChunktype:'tool-result'Chunk type identifierrunId:stringExecution run identifierfrom:ChunkFromSource of the chunk (AGENT, WORKFLOW, etc.)payload:ToolResultPayloadTool result data including toolCallId, toolName, result, and error status
+**finishReason** (`Promise<string | undefined>`): Reason why generation stopped (e.g., 'stop', 'length', 'tool\_calls', 'content\_filter'). Undefined if the stream hasn't finished.
 
-**usage:** (`Promise<LanguageModelUsage>`): RecordinputTokens:numberTokens consumed by the input promptoutputTokens:numberTokens generated in the responsetotalTokens:numberSum of input and output tokensreasoningTokens?:numberHidden reasoning tokens (for reasoning models)cachedInputTokens?:numberNumber of input tokens that were a cache hit
+**finishReason.stop** (`'stop'`): Model finished naturally
 
-**finishReason:** (`Promise<string | undefined>`): enumstop:'stop'Model finished naturallylength:'length'Hit maximum token limittool\_calls:'tool\_calls'Model called toolscontent\_filter:'content\_filter'Content was filtered
+**finishReason.length** (`'length'`): Hit maximum token limit
 
-**response:** (`Promise<Response>`): Responseid?:stringResponse ID from the model providertimestamp?:DateResponse timestampmodelId?:stringModel identifier used for this responseheaders?:Record\<string, string>Response headers from the model providermessages?:ResponseMessage\[]Response messages in model formatuiMessages?:UIMessage\[]Response messages in UI format, includes any metadata added by output processors
+**finishReason.tool\_calls** (`'tool_calls'`): Model called tools
+
+**finishReason.content\_filter** (`'content_filter'`): Content was filtered
+
+**response** (`Promise<Response>`): Response metadata and messages from the model provider.
+
+**response.id** (`string`): Response ID from the model provider
+
+**response.timestamp** (`Date`): Response timestamp
+
+**response.modelId** (`string`): Model identifier used for this response
+
+**response.headers** (`Record<string, string>`): Response headers from the model provider
+
+**response.messages** (`ResponseMessage[]`): Response messages in model format
+
+**response.uiMessages** (`UIMessage[]`): Response messages in UI format, includes any metadata added by output processors
 
 ## Error Properties
 
-**error:** (`string | Error | { message: string; stack: string; } | undefined`): Error information if the stream encountered an error. Undefined if no errors occurred. Can be a string message, Error object, or serialized error with stack trace.
+**error** (`string | Error | { message: string; stack: string; } | undefined`): Error information if the stream encountered an error. Undefined if no errors occurred. Can be a string message, Error object, or serialized error with stack trace.
 
 ## Methods
 
-**getFullOutput:** (`() => Promise<FullOutput>`): FullOutputtext:stringComplete text responseobject?:OUTPUTStructured output if schema was providedtoolCalls:ToolCallChunk\[]All tool call chunks madetoolResults:ToolResultChunk\[]All tool result chunksusage:Record\<string, number>Token usage statisticsreasoning?:stringReasoning text if availablefinishReason?:stringWhy generation finishedresponse:ResponseResponse metadata and messages from the model provider
+**getFullOutput** (`() => Promise<FullOutput>`): Returns a comprehensive output object containing all results: text, structured object, tool calls, usage statistics, reasoning, and metadata. Convenient single method to access all stream results.
+
+**getFullOutput.text** (`string`): Complete text response
+
+**getFullOutput.object** (`OUTPUT`): Structured output if schema was provided
+
+**getFullOutput.toolCalls** (`ToolCallChunk[]`): All tool call chunks made
+
+**getFullOutput.toolResults** (`ToolResultChunk[]`): All tool result chunks
+
+**getFullOutput.usage** (`Record<string, number>`): Token usage statistics
+
+**getFullOutput.reasoning** (`string`): Reasoning text if available
+
+**getFullOutput.finishReason** (`string`): Why generation finished
+
+**getFullOutput.response** (`Response`): Response metadata and messages from the model provider
+
+**consumeStream** (`(options?: ConsumeStreamOptions) => Promise<void>`): Manually consume the entire stream without processing chunks. Useful when you only need the final promise-based results and want to trigger stream consumption.
 
-**consumeStream:** (`(options?: ConsumeStreamOptions) => Promise<void>`): ConsumeStreamOptionsonError?:(error: Error) => voidCallback for handling stream errors
+**consumeStream.onError** (`(error: Error) => void`): Callback for handling stream errors
 
 ## Usage Examples