Struct TurnWire 

pub struct TurnWire {
    pub key: Option<String>,
    pub messages: Vec<Value>,
}

One turn, as a page carries it: the key the server named it by, and the messages it ran as.

The messages, not a drawing of them. How a run of tool calls groups inside a turn is a drawing decision, so it belongs to whoever draws; what crosses is the turn’s own boundary, and that stays here because the paging contract is built on it - more asks for turns, and a page above the window’s floor cuts on them rather than leaving a client to stitch half a turn to half.

Below that floor a page can carry a stretch inside a turn, which is what a running turn’s older rows are: a session whose life is one unended turn has no boundary to cut on, and its rows reach a late-attaching view only in runs. What a client is owed there is the pair: a page never opens on a tool result without the call that produced it.

Fields

key: Option<String>

None when nothing named the turn: the key comes from a Result frame, and a conversation read from a transcript carries none.

messages: Vec<Value>

The frames this turn ran as, which is the same shape the session record’s conversation carries.

Trait Implementations

impl Clone for TurnWire

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 TurnWire

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TurnWire

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TurnWire

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

where __S: Serializer,

Serialize this value into the given Serde serializer.