Struct StrategyCompactor 

pub struct StrategyCompactor { /* private fields */ }

A reusable Compactor that bundles a trigger closure with a CompactionStrategy (often a CompactionPipeline) and an optional CompactionBackend. Use this when your trigger logic is a simple predicate over the transcript; implement Compactor directly when you need richer state (token meters, atomics, etc.).

Example

use agentkit_compaction::{
    CompactionPipeline, CompactionReason, DropReasoningStrategy,
    KeepRecentStrategy, StrategyCompactor,
};
use agentkit_core::ItemKind;

let compactor = StrategyCompactor::new(
    |transcript: &[_], _point| {
        (transcript.len() > 32).then_some(CompactionReason::TranscriptTooLong)
    },
    CompactionPipeline::new()
        .with_strategy(DropReasoningStrategy::new())
        .with_strategy(
            KeepRecentStrategy::new(24)
                .preserve_kind(ItemKind::System)
                .preserve_kind(ItemKind::Context),
        ),
);

Implementations

impl StrategyCompactor

pub fn new<T, S>(trigger: T, strategy: S) -> Self

where T: Fn(&[Item], MutationPoint) -> Option<CompactionReason> + Send + Sync + 'static, S: CompactionStrategy + 'static,

Create a new compactor from a trigger closure and a strategy.

The trigger receives the current transcript and MutationPoint and returns Some(reason) to fire compaction.

pub fn builder() -> StrategyCompactorBuilder

Start a builder for StrategyCompactor.

pub fn with_backend(self, backend: impl CompactionBackend + 'static) -> Self

Attach a CompactionBackend for strategies that require summarisation (e.g. SummarizeOlderStrategy).

pub fn with_shared_backend(self, backend: Arc<dyn CompactionBackend>) -> Self

Reuse an existing Arc<dyn CompactionBackend> (e.g. one already shared elsewhere) without re-wrapping.

pub fn with_metadata(self, metadata: MetadataMap) -> Self

Set metadata forwarded to every strategy invocation.

Trait Implementations

impl Compactor for StrategyCompactor

fn should_compact( &self, transcript: &[Item], point: MutationPoint, ) -> Option<CompactionReason>

Decide whether to compact based on the current transcript and mutation point. Returning None is a no-op.

fn compact<'life0, 'life1, 'async_trait>( &'life0 self, transcript: &'life1 [Item], reason: CompactionReason, cancellation: Option<TurnCancellation>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Item>, CompactionError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Produce the replacement transcript. Called only after should_compact returns Some. Implementations should respect cancellation.