Struct ConversationState 

pub struct ConversationState {
    pub session: Session,
    pub context_head: ContextHeadPersistence,
    pub api_messages: Vec<SharedMessage>,
    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

context_head: ContextHeadPersistence

api_messages: Vec<SharedMessage>

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) -> Self

Create a new conversation with a fresh session.

pub fn from_resumed(session: Session) -> Self

Create from a resumed session.

pub async fn save(&mut self)

Save the current conversation state to disk.

pub async fn persist_context_head( &mut self, session_id: &str, messages: Vec<SharedMessage>, ) -> Result<()>

Persist a runtime-requested head using host metadata and latest usage. The caller completes the receipt with this exact result and continues consuming the runtime’s typed terminal error on failure.

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

Clear the current session and start fresh.

pub fn snapshot(&self, consecutive_auto_turns: u32) -> ConversationSnapshot

Serializable mirror for clients (SessionEventWire::Conversation). consecutive_auto_turns is actor/App-side state, not conversation state, so the caller supplies it.

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).