Struct Reasoner 

pub struct Reasoner { /* private fields */ }

Implementations

impl Reasoner

pub fn new(cache_size: Option<usize>) -> Self

pub async fn process_thought( &self, request: ReasoningRequest, ) -> ReasoningResponse

pub async fn get_best_reasoning_path( &self, strategy_type: Option<&str>, ) -> Vec<ThoughtNode>

pub async fn get_stats(&self, strategy_types: Vec<&str>) -> ReasoningStats

pub fn get_cache_stats(&self) -> EmbeddingCacheSnapshot

Get embedding cache statistics from BaseStrategy

This is an enhancement over the reference TypeScript implementation, providing observability into the local Stella 400M embedding cache performance.

Returns cache hit rate, memory usage, and eviction counts for performance monitoring and capacity planning.

pub async fn clear(&self)

Clears all reasoning state.

Behavior

This method clears the shared StateManager, which stores:

• All thought nodes and their relationships
• Path histories and scores
• Global reasoning state

Strategy State Lifetime

Strategy-specific state (beams, MCTS trees, policy metrics, caches) is not cleared by this method because:

1. Each process_thought() call creates a fresh strategy instance
2. Strategy state is captured by spawned async tasks
3. Old strategy instances are garbage collected when tasks complete
4. There are no shared strategy instances to clear

This design ensures:

• Clean separation between persistent state (StateManager) and compute (Strategies)
• Automatic cleanup via Rust’s ownership system
• No risk of clearing active in-flight strategy operations

Examples

let reasoner = Reasoner::new(Some(1000));

// Process 100 thoughts
for i in 0..100 {
    reasoner.process_thought(request).await;
}

// Clear all reasoning state
reasoner.clear().await;

// StateManager is now empty
// Old strategy instances will be GC'd when async tasks finish