Struct AutoFunctionStreamEvent 

#[non_exhaustive]
pub struct AutoFunctionStreamEvent {
    pub chunk: AutoFunctionStreamChunk,
    pub event_id: Option<String>,
}

Streaming event with position metadata for auto-function stream resumption.

This wrapper pairs an AutoFunctionStreamChunk with its event_id, enabling stream resumption after network interruptions or reconnects.

Stream Resumption

Save the event_id from each event. If the connection drops, you can resume the stream from the last received event by calling get_interaction_stream() with the saved event_id.

Note: The auto-function streaming loop is client-side. If interrupted during function execution, you may need to restart the full loop rather than resuming. However, the underlying API stream can be resumed.

Example

use futures_util::StreamExt;
use genai_rs::{Client, AutoFunctionStreamEvent, AutoFunctionStreamChunk};

let client = Client::new("your-api-key".to_string());

let mut stream = client
    .interaction()
    .with_model("gemini-3-flash-preview")
    .with_text("What's the weather in London?")
    .create_stream_with_auto_functions();

let mut last_event_id: Option<String> = None;

while let Some(event) = stream.next().await {
    let event = event?;

    // Save event_id for potential resume
    if let Some(id) = &event.event_id {
        last_event_id = Some(id.clone());
    }

    match &event.chunk {
        AutoFunctionStreamChunk::Delta(content) => {
            if let Some(text) = content.as_text() {
                print!("{}", text);
            }
        }
        AutoFunctionStreamChunk::Complete(_) => {
            println!("\n[Done]");
        }
        _ => {}
    }
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

chunk: AutoFunctionStreamChunk

The auto-function stream chunk content

event_id: Option<String>

Event ID for stream resumption.

Pass this to last_event_id when resuming a stream to continue from this position. This is the event_id from the underlying API stream.

May be None for client-generated events (like ExecutingFunctions and FunctionResults) that don’t come from the API stream.

Implementations

impl AutoFunctionStreamEvent

pub fn new(chunk: AutoFunctionStreamChunk, event_id: Option<String>) -> Self

Creates a new auto-function stream event.

pub const fn is_delta(&self) -> bool

Check if the inner chunk is a Delta variant.

pub const fn is_complete(&self) -> bool

Check if the inner chunk is a Complete variant.

pub const fn is_unknown(&self) -> bool

Check if the inner chunk is an Unknown variant.

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

Returns the unrecognized chunk type if this is an Unknown variant.

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

Returns the preserved JSON data if this is an Unknown variant.

Trait Implementations

impl Clone for AutoFunctionStreamEvent

fn clone(&self) -> AutoFunctionStreamEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AutoFunctionStreamEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AutoFunctionStreamEvent

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AutoFunctionStreamEvent

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

where S: Serializer,

Serialize this value into the given Serde serializer.