Enum StreamChunk 

#[non_exhaustive]
pub enum StreamChunk {
    Start {
        interaction: InteractionResponse,
    },
    StatusUpdate {
        interaction_id: String,
        status: InteractionStatus,
    },
    ContentStart {
        index: usize,
        content_type: Option<String>,
    },
    Delta(Content),
    ContentStop {
        index: usize,
    },
    Complete(InteractionResponse),
    Error {
        message: String,
        code: Option<String>,
    },
    Unknown {
        chunk_type: String,
        data: Value,
    },
}

A chunk from the streaming API

During streaming, the API sends different types of events:

• Start: Initial interaction event (first event, contains ID)
• StatusUpdate: Status changes during processing
• ContentStart: Content generation begins for an output
• Delta: Incremental content updates (text, thought, function_call, etc.)
• ContentStop: Content generation ends for an output
• Complete: The final complete interaction response
• Error: Error occurred during streaming

All variants implement Serialize and Deserialize for logging, persistence, and replay of streaming events.

Forward Compatibility

This enum uses #[non_exhaustive] to allow adding new chunk types in future versions without breaking existing code. Always include a wildcard arm in match statements. Unknown chunk types deserialize to the Unknown variant with their data preserved.

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.

Start

Interaction started (first event, contains ID).

Sent when the interaction is accepted by the API. Provides early access to the interaction ID before any content is generated.

Fields

interaction: InteractionResponse

The full interaction response at start time

StatusUpdate

Status update for in-progress interaction.

Sent when the interaction status changes during processing. Useful for tracking progress of background/agent interactions.

Fields

interaction_id: String

The interaction ID

status: InteractionStatus

The updated status

ContentStart

Content generation started for an output.

Sent when a new content block begins generation. The index indicates which output position this content will occupy.

Fields

index: usize

Position index for this content block

content_type: Option<String>

The content type being started (e.g., “text”, “thought”)

Delta(Content)

Incremental content update

ContentStop

Content generation stopped for an output.

Sent when a content block finishes generation.

Fields

index: usize

Position index for the completed content block

Complete(InteractionResponse)

Complete interaction response (final event)

Error

Error occurred during streaming.

Indicates a terminal error condition. The stream will end after this event.

Fields

message: String

Human-readable error message

code: Option<String>

Error code from the API (if provided)

Unknown

Unknown chunk 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 chunk 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 StreamChunk

pub const fn is_unknown(&self) -> bool

Check if this is an unknown chunk type.

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.

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

Returns the interaction ID if this event contains one.

Available for Start, StatusUpdate, and Complete variants.

Example

if let Some(id) = chunk.interaction_id() {
    println!("Interaction ID: {}", id);
}

pub const fn is_terminal(&self) -> bool

Returns true if this is a terminal event.

Terminal events indicate the stream has ended (either successfully or with an error). After receiving a terminal event, no more events will be sent.

Terminal events are:

• Complete: Successful completion
• Error: Error occurred

Example

if chunk.is_terminal() {
    println!("Stream has ended");
}

pub fn status(&self) -> Option<&InteractionStatus>

Returns the status if this event contains one.

Available for StatusUpdate and Complete variants.

Example

if let Some(status) = chunk.status() {
    println!("Status: {:?}", status);
}

Trait Implementations

impl Clone for StreamChunk

fn clone(&self) -> StreamChunk

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StreamChunk

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StreamChunk

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for StreamChunk

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

where S: Serializer,

Serialize this value into the given Serde serializer.