Struct Context 

pub struct Context { /* private fields */ }

Manages the conversation state sent to an LLM provider.

A Context bundles together three things:

1. Messages – the conversation history as a Vec<ChatMessage>
2. Tools – the tools available to the model as a Vec<ToolDefinition>
3. Configuration – optional ReasoningEffort and prompt cache key

Pass a Context to StreamingModelProvider::stream_response to generate a response.

Construction

use llm::{Context, ChatMessage, ContentBlock, ToolDefinition, types::IsoString};

let context = Context::new(
    vec![
        ChatMessage::System {
            content: "You are a helpful assistant.".into(),
            timestamp: IsoString::now(),
        },
        ChatMessage::User {
            content: vec![ContentBlock::text("What is Rust?")],
            timestamp: IsoString::now(),
        },
    ],
    vec![], // no tools
);

Managing messages

• add_message – Append a single message.
• push_assistant_turn – Append an assistant response together with its tool call results in one step.
• clear_conversation – Remove all non-system messages.

Conversation compaction

Long conversations can be compacted to stay within context limits:

• messages_for_summary – Get non-system messages to feed to a summarizer.
• with_compacted_summary – Create a new Context where conversation messages are replaced by a ChatMessage::Summary. The system prompt, tools, and configuration are preserved.

Token estimation

estimated_token_count provides a rough pre-flight estimate using a ~4 bytes/token heuristic. This is intentionally approximate – use it to detect obvious overflow before calling the provider, not for precise accounting.

Encrypted reasoning

filter_encrypted_reasoning creates a copy where encrypted reasoning content is kept only for messages from a matching model. This is necessary because encrypted reasoning tokens are model-specific and cannot be replayed to a different model.

Implementations

impl Context

pub fn new(messages: Vec<ChatMessage>, tools: Vec<ToolDefinition>) -> Self

pub fn prompt_cache_key(&self) -> Option<&str>

pub fn set_prompt_cache_key(&mut self, key: Option<String>)

pub fn reasoning_effort(&self) -> Option<ReasoningEffort>

pub fn set_reasoning_effort(&mut self, effort: Option<ReasoningEffort>)

pub fn model_settings(&self) -> &ModelSettings

pub fn set_model_settings(&mut self, settings: ModelSettings)

pub fn add_message(&mut self, message: ChatMessage)

pub fn set_tools(&mut self, tools: Vec<ToolDefinition>)

pub fn set_system_content(&mut self, content: String)

pub fn messages(&self) -> &Vec<ChatMessage>

pub fn tools(&self) -> &Vec<ToolDefinition>

pub fn message_count(&self) -> usize

Returns the number of messages in the context

pub fn estimated_token_count(&self) -> u32

Estimate total token count using the ~4 bytes/token heuristic. Includes messages and tool definitions. Used for pre-flight overflow detection.

pub fn push_assistant_turn( &mut self, content: &str, reasoning: AssistantReasoning, completed_tools: Vec<Result<ToolCallResult, ToolCallError>>, )

Build an assistant turn and its tool call results and append them to messages.

pub fn filter_encrypted_reasoning(&self, model: Option<&LlmModel>) -> Self

Return a copy with encrypted reasoning projected onto model.

Encrypted content is opaque to every model but the one that produced it, so it survives only when its source model matches. Passing None — the model is not in the catalog, so nothing can be claimed to match — drops all of it.

pub fn clear_conversation(&mut self)

Clear all non-system messages, retaining only system prompts.

pub fn replace_conversation(&mut self, messages: Vec<ChatMessage>)

Replace all non-system messages while preserving the system prompt and runtime state.

pub fn messages_for_summary(&self) -> Vec<&ChatMessage>

Get all non-system messages for summarization

pub fn with_compacted_summary(&self, summary: &str) -> Context

Create a new context with all messages replaced by a summary. Preserves the system prompt and tools.

Trait Implementations

impl Clone for Context

fn clone(&self) -> Context

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Context

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Context

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Context

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

where __S: Serializer,

Serialize this value into the given Serde serializer.