Enum AutoFunctionStreamChunk 

#[non_exhaustive]
pub enum AutoFunctionStreamChunk {
    Delta(Content),
    ExecutingFunctions {
        response: InteractionResponse,
        pending_calls: Vec<PendingFunctionCall>,
    },
    FunctionResults(Vec<FunctionExecutionResult>),
    Complete(InteractionResponse),
    MaxLoopsReached(InteractionResponse),
    Unknown {
        chunk_type: String,
        data: Value,
    },
}

A chunk from streaming with automatic function calling.

This enum represents the different events that can occur during a streaming interaction with automatic function execution. The stream yields deltas as content arrives, signals when functions are being executed, and completes when the model returns a response without function calls.

Forward Compatibility

This enum uses #[non_exhaustive] to allow adding new event types in future versions without breaking existing code. Always include a wildcard arm in match statements. Unknown variants are preserved with their data for debugging.

Serialization

This enum implements Serialize and Deserialize for logging, persistence, and replay of streaming events.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Delta(Content)

Incremental content from the model (text, thoughts, etc.)

ExecutingFunctions

Function calls detected, about to execute.

This event is yielded when the model requests function calls and before the functions are executed. The pending_calls field contains the function calls that are about to be executed.

Note: In streaming mode, function calls arrive incrementally via Delta chunks. The pending_calls list is built from accumulated deltas and will always be populated, even though response.function_calls() may be empty.

Fields

response: InteractionResponse

The response from the API (may have empty function_calls() in streaming mode)

pending_calls: Vec<PendingFunctionCall>

The function calls that are about to be executed (always populated)

FunctionResults(Vec<FunctionExecutionResult>)

Function execution completed with results.

This event is yielded after all functions in a batch have been executed, before sending results back to the model for the next iteration.

Complete(InteractionResponse)

Final complete response (no more function calls).

This is the last event in the stream, yielded when the model returns a response that doesn’t request any function calls.

MaxLoopsReached(InteractionResponse)

Maximum function call loops reached.

This event is yielded when the auto-function loop has reached the maximum number of iterations (set via with_max_function_call_loops()) without the model returning a response without function calls.

The response contains the last response from the model, which likely still contains pending function calls. Use AutoFunctionResultAccumulator to collect all function execution results from prior FunctionResults chunks.

This allows debugging why the model is stuck in a loop while preserving all partial results.

Unknown

Unknown event type (for forward compatibility).

This variant is used when deserializing JSON that contains an unrecognized chunk_type. This allows the library to gracefully handle new event types added by the API in future versions without failing deserialization.

The chunk_type field contains the unrecognized type string, and data contains the full JSON data for inspection or debugging.

Fields

chunk_type: String

The unrecognized chunk type from the API

data: Value

The raw JSON data, preserved for debugging and roundtrip serialization

Implementations

impl AutoFunctionStreamChunk

pub const fn is_unknown(&self) -> bool

Check if this is an unknown chunk type.

pub const fn is_delta(&self) -> bool

Check if this chunk is a Delta variant.

pub const fn is_complete(&self) -> bool

Check if this chunk is a Complete variant.

pub fn unknown_chunk_type(&self) -> Option<&str>

Returns the chunk type name if this is an unknown chunk type.

Returns None for known chunk types.

pub fn unknown_data(&self) -> Option<&Value>

Returns the raw JSON data if this is an unknown chunk type.

Returns None for known chunk types.

Trait Implementations

impl Clone for AutoFunctionStreamChunk

fn clone(&self) -> AutoFunctionStreamChunk

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AutoFunctionStreamChunk

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AutoFunctionStreamChunk

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AutoFunctionStreamChunk

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.