Struct Conversation 

pub struct Conversation {
    pub messages: Vec<Message>,
    pub stream_buffer: Option<String>,
    pub tool_call_buffer: Option<ToolCallBuffer>,
    pub turn_tracker: TurnTracker,
    pub cold_summaries: Vec<String>,
}

Fields

messages: Vec<Message>

stream_buffer: Option<String>

tool_call_buffer: Option<ToolCallBuffer>

turn_tracker: TurnTracker

cold_summaries: Vec<String>

Cold zone: FIFO queue of compressed history summaries (max 3). Each entry is an LLM-generated summary of older turns.

Implementations

impl Conversation

pub fn new() -> Self

pub fn load(path: &Path) -> Self

Load conversation history from disk. Never fails — returns empty on any error.

pub fn save(&self, path: &Path)

Save conversation history to disk atomically (write to temp, then rename).

pub fn history_path() -> PathBuf

Path to history file.

pub fn add_user_message(&mut self, content: &str)

pub fn cancel_current_turn(&mut self)

Cancel the current active turn: save all conversation content up to the moment of cancel. The user cancelled because they want to redirect the model, not because they want to lose context — the LLM needs to see what it already did so it can adjust.

If the model issued tool calls that never got results, we append (cancelled) ToolResult entries for them so the API doesn’t reject the message sequence with “messages illegal”.

pub fn cancel_current_turn_including_user(&mut self)

Cancel the current active turn AND remove the user message. Used on Error exits where leaving an orphan user message (no assistant reply) would cause weak models to return 0 tokens on the next turn — two consecutive User messages with no intervening Assistant confuses OpenAI-compatible APIs.

pub fn push_delta(&mut self, delta: &str)

pub fn clear_stream_buffer(&mut self)

Clear the stream buffer without finalizing (used when text output is actually a malformed tool call that will be re-processed).

pub fn finalize_stream(&mut self)

pub fn add_assistant_tool_calls( &mut self, text: Option<&str>, tool_calls: Vec<ToolCall>, reasoning: Option<&str>, )

pub fn add_assistant_tool_calls_with_thinking( &mut self, text: Option<&str>, tool_calls: Vec<ToolCall>, reasoning: Option<&str>, thinking_blocks: Vec<ThinkingBlock>, )

Like add_assistant_tool_calls but additionally stores Anthropic extended-thinking content blocks (text + signature pairs). The blocks must be echoed verbatim on subsequent requests when the upstream is Anthropic-style and thinking is enabled — otherwise the next request gets 400 The content[].thinking in the thinking mode must be passed back to the API. Other provider paths (OpenAI / Ollama) ignore this field via .. destructuring, so leaving it populated is harmless across cross-provider switches.

pub fn add_tool_result(&mut self, result: ToolResult)

pub fn finalize_stream_with_tool_call( &mut self, tool_call: ToolCall, reasoning: Option<&str>, )

pub fn finalize_stream_with_tool_calls( &mut self, tool_calls: &[ToolCall], reasoning: Option<&str>, )

Finalize the current stream buffer with multiple tool calls at once (multi-tool support). reasoning carries thinking-model reasoning_content accumulated during the stream; it’s stored on the message so the send-side policy can echo it back when the provider demands (see ReasoningPolicy).

pub fn finalize_stream_with_tool_calls_and_thinking( &mut self, tool_calls: &[ToolCall], reasoning: Option<&str>, thinking_blocks: Vec<ThinkingBlock>, )

Variant that additionally records Anthropic extended-thinking blocks for echo-back. See add_assistant_tool_calls_with_thinking.

pub fn to_provider_messages(&self, system_prompt: &str) -> Vec<Message>

pub fn to_provider_messages_windowed( &self, system_prompt: &str, window: usize, ) -> Vec<Message>

Like to_provider_messages but only sends the last window messages. Ensures the window starts at a valid boundary — never in the middle of a tool_call/tool_result pair (which causes API “messages illegal” errors).

pub fn apply_compression(&mut self, remove_count: usize, summary: String)

Apply compression: store summary in cold zone, remove old messages. remove_count = number of messages from the front to remove. (Changed from turn-based to message-based to support single-user-message sessions where turn_tracker has only 1-2 turns but 30+ messages.)

── CRITICAL INVARIANT ── After compression:

• All surviving turns must have: start_idx < new_messages.len()
• All surviving turns must have: end_idx() <= new_messages.len()
• All surviving turns must have: msg_count > 0 These invariants prevent underflow in on_user_message(msg_idx).

Trait Implementations

impl Debug for Conversation

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

Formats the value using the given formatter.

impl Default for Conversation

fn default() -> Self

Returns the “default value” for a type.