Enum WireStreamEvent 

#[non_exhaustive]
pub enum WireStreamEvent {
    MessageStart {
        protocol_version: u32,
        model: String,
        provider: ProviderKind,
    },
    TextDelta {
        text: String,
    },
    ToolCallStart {
        id: String,
        name: String,
    },
    ToolCallDelta {
        id: String,
        arguments: String,
    },
    ToolCallEnd {
        id: String,
        name: String,
        arguments: String,
    },
    ToolResult {
        id: String,
        result: String,
    },
    Usage {
        usage: Usage,
    },
    MessageStop {
        finish_reason: Option<String>,
    },
    TurnComplete {
        turn: ConversationTurn,
    },
    Error {
        error: WireError,
    },
}

A stream event in its serializable, over-the-wire form.

See the module documentation for the JSON shape and the compatibility guarantees attached to the "type" tags.

A well-formed stream starts with exactly one MessageStart and ends with exactly one terminal event — MessageStop on success, Error on failure (see is_terminal). A stream that simply stops is a truncated stream: the connection died. That distinction is the whole point of putting errors on the wire, and StreamAccumulator::finish enforces it.

This enum is #[non_exhaustive]: new event types are additive, so match with a catch-all arm.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

MessageStart

The stream has opened. Always the first event.

Fields

protocol_version: u32

Revision of the wire framing the sender speaks.

Defaults to WIRE_PROTOCOL_VERSION when absent, so payloads written before this field existed still parse.

model: String

Model identifier the request was routed to.

provider: ProviderKind

Provider serving the request.

TextDelta

An incremental piece of assistant text to append to the output so far.

Fields

text: String

Text to append.

ToolCallStart

A tool call has begun; its arguments arrive in later events.

Fields

id: String

Provider-assigned call identifier.

name: String

Name of the tool the model wants to run.

ToolCallDelta

A fragment of the JSON argument string for a tool call.

Fields

id: String

Identifier of the call these arguments belong to.

arguments: String

Partial JSON text to append to previously received fragments.

ToolCallEnd

A tool call has finished streaming, with its arguments assembled.

Fields

id: String

Provider-assigned call identifier.

name: String

Name of the tool the model wants to run.

arguments: String

Complete raw JSON argument string.

ToolResult

The result of executing a tool call.

Never emitted by stream_wire_events, which does not run tools. It exists so a proxy that executes tools itself can report them to its client using the same envelope.

Fields

id: String

Identifier of the call this result answers.

result: String

Serialized tool output.

Usage

Token usage for the generation.

Emitted once, just before the terminal event, when the provider reports usage. This is the event a server bills against and a client displays, so it deliberately carries the counts rather than a summary.

Fields

usage: Usage

Token counts as reported by the provider.

MessageStop

Generation finished cleanly. Terminal.

Fields

finish_reason: Option<String>

Why generation stopped, e.g. "stop", "length", or "tool_use".

TurnComplete

An assembled conversation turn, ready to be stored as history.

Never emitted by stream_wire_events; it is the wire form of StreamEvent::TurnComplete, so events from generate_stream_events can be forwarded without loss.

Fields

turn: ConversationTurn

The complete turn.

Error

Generation failed. Terminal.

Receiving this means the provider or the SDK rejected the request after the stream opened. A client that never receives a terminal event lost its connection instead — a different failure with a different remedy.

Fields

error: WireError

What went wrong.

Implementations

impl WireStreamEvent

pub fn message_start(model: impl Into<String>, provider: ProviderKind) -> Self

Build the opening event for a stream, stamped with WIRE_PROTOCOL_VERSION.

pub fn error(error: &Error) -> Self

Build a terminal error event from a crate Error.

pub fn tag(&self) -> &'static str

The "type" discriminant this event serializes with.

Useful as the SSE event: name, or for logging and metrics labels without serializing the whole payload.

pub fn is_terminal(&self) -> bool

Whether this event ends the stream: MessageStop or Error.

Trait Implementations

impl Clone for WireStreamEvent

fn clone(&self) -> WireStreamEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WireStreamEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for WireStreamEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<StreamEvent> for WireStreamEvent

fn from(event: StreamEvent) -> Self

Forward a high-level StreamEvent onto the wire without loss.

Every StreamEvent has an exact counterpart here, and TryFrom<WireStreamEvent> converts it back to the same value.

impl PartialEq for WireStreamEvent

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for WireStreamEvent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for WireStreamEvent

impl TryFrom<WireStreamEvent> for StreamEvent

type Error = UnrepresentableWireEvent

The type returned in the event of a conversion error.

fn try_from(event: WireStreamEvent) -> Result<Self, UnrepresentableWireEvent>

Performs the conversion.