Enum TurnEvent 

#[non_exhaustive]
pub enum TurnEvent {
    Phase(TurnPhase),
    Step(Box<Step>),
    StepSaid {
        step: Box<Step>,
        text: String,
    },
    Block(Box<ResponseBlock>),
    Completed(Box<AssistantTurn>),
    Failed {
        code: String,
    },
}

One thing a client learns while a turn is being handled.

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.

Phase(TurnPhase)

The turn moved to a new phase. Progress, never an outcome.

Step(Box<Step>)

One decision of the turn’s understanding, as it was made. What was understood, never what happened: it goes out before the commit, like a phase marker.

StepSaid

A step said in the turn’s language, when NarrationConfig::steps asks for it.

Fields

step: Box<Step>

The step.

text: String

The progress line a model wrote for it.

Block(Box<ResponseBlock>)

One finished block, published atomically.

Completed(Box<AssistantTurn>)

The turn is done; this is exactly what was persisted.

Failed

The turn failed, with a stable code and no free text.

Fields

code: String

Stable code from the error family.

Implementations

impl TurnEvent

pub fn block(&self) -> Option<&ResponseBlock>

The block this event carries, if any.

pub const fn is_terminal(&self) -> bool

Returns true for the two events that end a stream.

Trait Implementations

impl Clone for TurnEvent

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TurnEvent

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

Formats the value using the given formatter.

impl PartialEq for TurnEvent

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for TurnEvent