Struct Compactor 

pub struct Compactor { /* private fields */ }

Compactor - applies compaction strategies to segments

Implementations

impl Compactor

pub fn new(strategy: CompactionStrategy) -> Self

Create a new compactor with the given strategy

pub fn truncate(target_tokens: usize) -> Self

Create a truncation compactor

pub fn sliding_window(target_tokens: usize, window_size: usize) -> Self

Create a sliding window compactor

pub fn strategy(&self) -> &CompactionStrategy

Get the strategy

pub fn compact_truncate( &self, segments: &mut Vec<ContextSegment>, current_tokens: usize, ) -> Result<usize, CompactionError>

Compact segments using truncation strategy

Removes oldest segments (lowest priority first) until target is reached.

pub fn compact_sliding_window( &self, segments: &mut Vec<ContextSegment>, ) -> Result<usize, CompactionError>

Compact using sliding window strategy

Keeps only the most recent N messages in the history.

pub fn summarize(target_tokens: usize, summary_max_tokens: usize) -> Self

Create a summarize compactor

pub fn compact_summarize( &self, segments: &mut Vec<ContextSegment>, current_tokens: usize, ) -> Result<usize, CompactionError>

Compact using summarization strategy

This performs extractive summarization by:

1. Identifying compactible segments (History, ToolResults)
2. Extracting key sentences from each segment
3. Truncating to fit within the summary token budget

Note: For true abstractive summarization (using an LLM), integrate with an external summarization service. This implementation provides a local extractive approach that doesn’t require external API calls.

pub fn compact_extract_key_points( &self, _segments: &mut Vec<ContextSegment>, _current_tokens: usize, ) -> Result<usize, CompactionError>

Compact using key points extraction strategy (not yet implemented)

Future Implementation

This strategy would:

1. Identify key decision points, outcomes, and learnings
2. Extract structured bullet points from conversation
3. Preserve causal chains and reasoning

Requires integration with an LLM for semantic understanding.

pub fn compact_importance_weighted( &self, _segments: &mut Vec<ContextSegment>, _current_tokens: usize, ) -> Result<usize, CompactionError>

Compact using importance-weighted strategy (not yet implemented)

Future Implementation

This strategy would:

1. Score each segment based on semantic importance
2. Use embedding similarity to current task
3. Weight by recency, reference count, and explicit importance markers
4. Remove lowest-scored segments until target is reached

Requires embedding model integration for semantic scoring.

pub fn compact_hybrid( &self, _segments: &mut Vec<ContextSegment>, _current_tokens: usize, ) -> Result<usize, CompactionError>

Compact using hybrid strategy (not yet implemented)

Future Implementation

This strategy would combine multiple approaches:

1. First pass: Remove lowest-importance segments (truncate)
2. Second pass: Summarize remaining compressible content
3. Third pass: Apply sliding window to history if needed

Requires all component strategies to be implemented.