Struct StreamSender 

pub struct StreamSender { /* private fields */ }

Sender half for streaming handlers.

Wraps a bounded tokio::sync::mpsc::Sender<String> and provides ergonomic methods for sending typed items and checking cancellation.

The associated CancellationToken is automatically cancelled when the StreamReceiver is dropped, enabling explicit cancellation checks via tokio::select! in addition to is_closed().

Example

async fn my_streaming_handler(args: MyArgs, tx: StreamSender) -> String {
    let token = tx.cancellation_token();
    loop {
        tokio::select! {
            _ = token.cancelled() => break,
            item = next_item() => { tx.send(item).await.ok(); }
        }
    }
    r#"{"done": true}"#.to_string()
}

Note on Clone: Cloning a StreamSender shares the same underlying channel and CancellationToken. Calling cancel() on any clone cancels all of them.

Implementations

impl StreamSender

pub fn channel() -> (Self, StreamReceiver)

Create a new stream channel with the default capacity (64).

Returns (sender, receiver) pair. The CancellationToken is automatically cancelled when the StreamReceiver is dropped.

pub fn with_capacity(capacity: usize) -> (Self, StreamReceiver)

Create a new stream channel with a custom capacity.

Returns (sender, receiver) pair.

pub fn cancellation_token(&self) -> CancellationToken

Get the cancellation token for this stream.

The token is automatically cancelled when the StreamReceiver is dropped, and can also be cancelled explicitly via cancel(). Use in tokio::select! for cooperative cancellation:

let token = tx.cancellation_token();
tokio::select! {
    _ = token.cancelled() => { /* stream cancelled */ }
    result = do_work() => { tx.send(result).await?; }
}

pub fn cancel(&self)

Explicitly cancel the stream.

This cancels the CancellationToken, signalling handlers that are using token.cancelled() in select!.

pub async fn send(&self, item: impl IntoStreamItem) -> Result<(), StreamError>

Send a stream item.

The item is converted to a JSON string via IntoStreamItem. Returns StreamError::Closed if the receiver has been dropped, or StreamError::Serialize if serialization fails.

pub fn is_closed(&self) -> bool

Check if the receiver has been dropped (stream cancelled).

Useful for cooperative cancellation in loops:

while !tx.is_closed() {
    tx.send(next_item()).await?;
}

Trait Implementations

impl Clone for StreamSender

fn clone(&self) -> StreamSender

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StreamSender

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

Formats the value using the given formatter.