Struct ConversationState 

pub struct ConversationState {
    pub session: Session,
    pub api_messages: Vec<Value>,
    pub total_input_tokens: u64,
    pub total_output_tokens: u64,
    pub total_cache_read_tokens: u64,
    pub total_cache_creation_tokens: u64,
    pub session_cost: f64,
    pub abort_context: Option<String>,
    pub queued_message: Option<String>,
    pub pending_events: Vec<String>,
}

Conversation state tracked by the engine.

Fields

session: Session

api_messages: Vec<Value>

total_input_tokens: u64

total_output_tokens: u64

total_cache_read_tokens: u64

total_cache_creation_tokens: u64

session_cost: f64

abort_context: Option<String>

queued_message: Option<String>

Message queued to send after current stream completes.

pending_events: Vec<String>

Events buffered during streaming — drained on stream completion.

Implementations

impl ConversationState

pub fn new(session: Session) -> ConversationState

Create a new conversation with a fresh session.

pub fn from_resumed(session: Session) -> ConversationState

Create from a resumed session.

pub async fn save(&mut self)

Save the current conversation state to disk.

pub async fn clear(&mut self, runtime: &Runtime)

Clear the current session and start fresh.

pub fn add_usage( &mut self, input_tokens: u64, output_tokens: u64, cache_read: u64, cache_creation: u64, cache_creation_5m: Option<u64>, cache_creation_1h: Option<u64>, model: &str, )

Add usage from a model turn.

cache_creation_5m / cache_creation_1h are the cache-write TTL split. When either is present the cost uses the split rates (5m: 1.25×, 1h: 2.0×); when both are None the aggregate cache_creation is billed at the 5m rate (fail-cheap fallback).

pub fn estimate_tokens(&self) -> usize

Estimate current token count (for compaction decisions).