Enum StreamEvent

pub enum StreamEvent {
    MessageStart {
        message: MessageStart,
    },
    ContentBlockStart {
        index: u32,
        content_block: ContentBlockStart,
    },
    ContentBlockDelta {
        index: u32,
        delta: ContentBlockDelta,
    },
    ContentBlockStop {
        index: u32,
    },
    MessageDelta {
        delta: MessageDelta,
        usage: Usage,
    },
    MessageStop,
    Ping,
}

Streaming events from the Anthropic API.

When using streaming mode, the API returns a series of events that incrementally build up the complete response.

Variants

MessageStart

Indicates the start of a message

Fields

message: MessageStart

ContentBlockStart

Indicates the start of a content block

Fields

index: u32

content_block: ContentBlockStart

ContentBlockDelta

Contains a delta (incremental update) to a content block

Fields

index: u32

delta: ContentBlockDelta

ContentBlockStop

Indicates the end of a content block

Fields

index: u32

MessageDelta

Contains final message information like stop reason

Fields

delta: MessageDelta

usage: Usage

MessageStop

Indicates the end of the message

Ping

A keepalive event that can be ignored

Implementations

impl StreamEvent

pub async fn create_stream( request: MessagesRequest, ) -> Result<Receiver<Self>, CannotCloneRequestError>

Creates a new streaming message request and returns a channel of events.

This method sends a request to the Messages API in streaming mode and returns a channel that will receive the streaming events.

Example

let credentials = Credentials::from_env();
let mut request = MessagesRequest {
    model: "claude-3-7-sonnet-20250219".to_string(),
    messages: vec![Message {
        role: MessageRole::User,
        content: MessageContent::Text("Hello!".to_string()),
    }],
    max_tokens: 100,
    credentials: Some(credentials),
    metadata: None,
    stop_sequences: None,
    stream: Some(true),
    system: None,
    temperature: None,
    tool_choice: None,
    tools: None,
    top_k: None,
    top_p: None,
};

let mut stream = StreamEvent::create_stream(request).await?;

while let Some(event) = stream.recv().await {
    // Process streaming events
    println!("{:?}", event);
}

Trait Implementations

impl Clone for StreamEvent

fn clone(&self) -> StreamEvent

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StreamEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StreamEvent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for StreamEvent

fn eq(&self, other: &StreamEvent) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for StreamEvent

impl StructuralPartialEq for StreamEvent