Struct AgentTurn 

pub struct AgentTurn {
    pub id: Uuid,
    pub timestamp: DateTime<Utc>,
    pub user: UserMessage,
    pub steps: Vec<AgentStep>,
    pub stats: TurnStats,
}

Single user-initiated interaction cycle within a session.

A turn begins with user input and contains all agent steps taken in response until the next user input or session end. Autonomous agents may execute multiple steps per turn.

Fields

id: Uuid

Unique turn identifier (ID of the user event that initiated this turn).

timestamp: DateTime<Utc>

When the turn started (user input timestamp).

user: UserMessage

User input that triggered this turn.

steps: Vec<AgentStep>

Agent’s response steps in chronological order. Single step for simple Q&A, multiple steps for autonomous operation.

stats: TurnStats

Aggregated turn statistics.

Implementations

impl AgentTurn

pub fn cumulative_input_tokens(&self, fallback: u32) -> u32

Calculate cumulative input tokens at the end of this turn Falls back to fallback if no usage data found

pub fn cumulative_total_tokens(&self, fallback: u32) -> u32

Calculate cumulative total tokens (input + output) at the end of this turn Falls back to fallback if no usage data found

pub fn is_active(&self) -> bool

Check if this turn is currently active

A turn is active if any of the recent steps are in progress. Looking at multiple steps provides stability during step transitions (e.g., when a step completes but the next one hasn’t started yet).

Trait Implementations

impl Clone for AgentTurn

fn clone(&self) -> AgentTurn

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AgentTurn

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AgentTurn

fn deserialize<__D>( __deserializer: __D, ) -> Result<AgentTurn, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AgentTurn

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

where __S: Serializer,

Serialize this value into the given Serde serializer.