Struct MessageStream 

pub struct MessageStream { /* private fields */ }

Stream of messages from Claude AI

MessageStream provides real-time access to Claude’s responses as they are generated, enabling streaming user interfaces and progressive content display. It implements the Stream trait for easy integration with async Rust applications.

Examples

let client = Client::new(Config::default());
let mut stream = client.query("Write a story").stream().await?;

// Process messages as they arrive
while let Some(result) = stream.next().await {
    match result {
        Ok(Message::Assistant { content, .. }) => {
            print!("{}", content); // Print content incrementally
        }
        Ok(Message::Result { stats, .. }) => {
            println!("\nCompleted with {} tokens", stats.total_tokens);
        }
        Err(e) => eprintln!("Stream error: {}", e),
        _ => {} // Handle other message types
    }
}

Stream Behavior

• Messages arrive in real-time as Claude generates the response
• Assistant messages may be split across multiple stream items
• The stream ends with a Result message containing statistics
• Errors are propagated through the stream rather than terminating it

Error Handling

Errors can occur at any point in the stream. Common error scenarios:

• Network interruptions
• Invalid JSON parsing (for JSON formats)
• Process termination
• Timeout exceeded

Implementations

impl MessageStream

pub fn new(receiver: Receiver<Result<Message>>, _format: StreamFormat) -> Self

Create a new MessageStream from a channel receiver

This is typically called internally by the Client. The format parameter is reserved for future use but currently not utilized.

pub async fn from_line_stream( line_receiver: Receiver<Result<String>>, format: StreamFormat, ) -> Self

Create a MessageStream from a line receiver and format

This function takes a receiver of raw output lines from the Claude CLI and converts them into a stream of parsed Messages based on the format.

pub async fn collect_full_response(self) -> Result<String>

Collects all messages from the stream and returns the full response as a single string.

Trait Implementations

impl Stream for MessageStream

type Item = Result<Message, Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.