Struct ContextManager 

pub struct ContextManager { /* private fields */ }

Context manager: maintains full conversation history and automatically triggers compression when tokens exceed the limit.

Typical usage

use echo_core::error::Result;
use echo_core::llm::types::Message;
use echo_state::compression::compressor::SlidingWindowCompressor;
use echo_state::compression::{ContextCompressor, ContextManager};

let mut ctx = ContextManager::builder(4096)
    .compressor(SlidingWindowCompressor::new(20))
    .build();

ctx.push(Message::system("You are an assistant".to_string()));
ctx.push(Message::user("Hello".to_string()));

// Call prepare() before each LLM call to auto-compress over-limit messages
let result = ctx.prepare(None).await?;
let messages = result.messages;

Hybrid pipeline example

use echo_core::error::Result;
use echo_core::llm::LlmClient;
use echo_state::compression::compressor::{
    HybridCompressor, SlidingWindowCompressor, SummaryCompressor,
};
use echo_state::compression::{ContextCompressor, ContextManager};
use std::sync::Arc;

let compressor = HybridCompressor::builder()
    .stage(SlidingWindowCompressor::new(30))
    .stage(SummaryCompressor::new(llm, 8))
    .build();

let mut ctx = ContextManager::builder(8192)
    .compressor(compressor)
    .build();

Implementations

impl ContextManager

pub fn builder(token_limit: usize) -> ContextManagerBuilder

pub fn push(&mut self, message: Message)

Append a message to the context buffer.

When the message count exceeds the max_messages hard cap, automatically applies sliding window degradation: preserves system messages and recent messages, discards the earliest conversation messages in the middle. This is the last line of defense; even if no compressor is configured or compression fails, OOM will not occur.

pub fn push_many(&mut self, messages: impl IntoIterator<Item = Message>)

Batch-append messages

pub fn messages(&self) -> &[Message]

Return all messages currently in the buffer (no compression)

pub fn set_messages(&mut self, messages: Vec<Message>)

Replace the internal message buffer (used to restore conversation from persistent storage)

Messages should include the system prompt as the first entry (if needed).

pub fn token_estimate(&self) -> usize

Estimate the token count of the current context

Uses the configured Tokenizer implementation (default HeuristicTokenizer, distinguishes ASCII/CJK).

pub fn tokenizer(&self) -> &dyn Tokenizer

获取当前 Tokenizer

pub fn set_tokenizer(&mut self, tokenizer: Arc<dyn Tokenizer>)

Dynamically replace the Tokenizer

pub fn clear(&mut self)

Clear the context buffer (preserves configured compressor and protection markers)

pub fn add_protected_marker(&mut self, marker: String)

Register a content marker that protects messages from compression.

Any message whose content contains this marker string will be excluded from compression passes. This is used by the skill system to protect activated skill instructions from being evicted during context compaction.

Example

let mut ctx = ContextManager::builder(4096).build();
ctx.add_protected_marker("<skill_content".to_string());

pub fn set_compressor(&mut self, compressor: impl ContextCompressor + 'static)

Dynamically replace the compressor without affecting the existing message buffer

pub fn remove_compressor(&mut self)

Remove the compressor, reverting to unlimited mode

pub fn has_compressor(&self) -> bool

Whether a compressor is configured

pub async fn force_compress( &mut self, fallback_window: usize, ) -> Result<ForceCompressStats, ReactError>

Force-compress the context, regardless of whether the current token count exceeds the limit.

• If a compressor is configured, use it;
• Otherwise, temporarily use SlidingWindowCompressor::new(fallback_window).

Protected messages are excluded from compression and preserved.

pub async fn force_compress_with( &mut self, compressor: &dyn ContextCompressor, ) -> Result<ForceCompressStats, ReactError>

Force-compress using a specific compressor, without affecting the currently installed compressor config.

Suitable for temporary strategy overrides like /compress sliding 10.

pub fn update_system(&mut self, new_system_prompt: String)

Update the system message content

Typically called when add_skill() injects extra system prompts: finds the first message with role == “system” and replaces its content; if no system message exists, inserts one at the head of the queue.

pub async fn prepare( &mut self, current_query: Option<&str>, ) -> Result<PrepareResult, ReactError>

Prepare the list of messages to send to the LLM.

When the estimated token count exceeds token_limit and a compressor is configured, automatically trigger compression and update the internal buffer. The compressed messages replace the original buffer.

Protected messages (containing registered markers, e.g. <skill_content>) are excluded from compression and re-inserted after system messages.

current_query is a reserved field; pass None.

Returns a PrepareResult containing the prepared messages and optional compression stats (populated only when auto-compression was triggered).