Struct EventStream 

pub struct EventStream { /* private fields */ }

An async stream of StreamResponse events from an SSE endpoint.

Created by crate::A2aClient::stream_message or crate::A2aClient::subscribe_to_task. Call EventStream::next in a loop to consume events.

When dropped, the background body-reader task is aborted to prevent resource leaks.

Implementations

impl EventStream

pub fn from_event_channel( rx: Receiver<Result<StreamResponse, ClientError>>, ) -> EventStream

Creates an EventStream from a channel of already-decoded events.

This is the constructor an out-of-tree crate::transport::Transport needs. Transport::send_streaming_request must return an EventStream, and every other way to build one is pub(crate) — so before this existed, a custom transport could implement the unary half of the trait and not the streaming half. A binding crate cannot be written against half a trait, so this is the piece that makes the extension point whole.

Feed rx from a background task that decodes the transport’s own frames into StreamResponse values. Sending Err delivers that error to the consumer and is the right way to report a decode failure mid-stream — silently ending the stream would be indistinguishable, to the consumer, from the task finishing normally.

The returned stream aborts the bridging task when dropped, exactly as the built-in transports’ streams do.

Example

let (tx, rx) = tokio::sync::mpsc::channel(64);
tokio::spawn(async move {
    while let Some(frame) = my_transport_stream.next().await {
        if tx.send(frame.map(into_stream_response)).await.is_err() {
            break; // consumer dropped the stream
        }
    }
});
Ok(EventStream::from_event_channel(rx))

pub const fn status_code(&self) -> u16

Returns the HTTP status code from the response that established this stream.

The transport layer validates the HTTP status during stream establishment and returns an error for non-2xx responses, so this is typically 200.

pub async fn next(&mut self) -> Option<Result<StreamResponse, ClientError>>

Returns the next event from the stream.

Returns None when the stream ends normally (either the HTTP body closed or a final: true event was received).

Returns Some(Err(...)) on transport or protocol errors.

Trait Implementations

impl Debug for EventStream

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

Formats the value using the given formatter.

impl Drop for EventStream

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.