Struct DistributedReasonerV2 

pub struct DistributedReasonerV2 { /* private fields */ }

Enhanced distributed reasoner with real session management, result caching, and cycle-safe peer tracking.

Design

Each call to start_session creates a DistributedInferenceSession that tracks which peers have been queried and which have replied. Results stream in via record_remote_result. A short-lived LRU-style cache keyed on the goal string avoids redundant network round-trips for recently seen goals.

Implementations

impl DistributedReasonerV2

pub fn new(config: DistributedReasonerConfig) -> Self

Construct a new DistributedReasonerV2 with the provided config.

pub fn start_session(&mut self, goal: &str) -> String

Create a new inference session for goal and return its session_id.

The timeout is taken from DistributedReasonerConfig::timeout.

pub fn start_session_with_id(&mut self, goal: &str, session_id: &str)

Create a new inference session with a caller-supplied session_id.

Unlike start_session the UUID is provided by the caller so it can be correlated with an outgoing InferenceRequest. If a session with the same ID already exists it is silently replaced.

pub fn add_session_peer( &mut self, session_id: &str, peer_id: &str, ) -> Result<(), ReasoningError>

Register peer_id as a query target for the given session.

Returns ReasoningError::SessionNotFound when session_id is unknown, ReasoningError::PeerAlreadyRegistered when the peer was already added, and ReasoningError::SessionExpired when the session has timed out.

pub fn record_remote_result( &mut self, session_id: &str, result: RemoteResult, ) -> Result<(), ReasoningError>

Record a RemoteResult for an in-progress session.

The peer is automatically moved from pending_peers to completed_peers if it was registered. Unknown peers are accepted anyway (unsolicited partial results are common in gossip networks).

pub fn mark_peer_responded( &mut self, session_id: &str, peer_id: &str, ) -> Result<(), ReasoningError>

Mark peer_id as having responded (without attaching a result).

Useful for signalling that a peer replied with “no solution”.

pub fn is_session_complete(&self, session_id: &str) -> bool

Returns true when the session has received responses from all registered peers or has exceeded its timeout.

pub fn get_session_results( &mut self, session_id: &str, ) -> Option<Vec<RemoteResult>>

Return all remote results collected for session_id, or None when the session is unknown.

Also consults the goal cache so that repeated queries benefit from previously gathered results.

pub fn cleanup_expired_sessions(&mut self) -> usize

Remove all sessions that have exceeded their timeout.

Returns the number of sessions that were cleaned up.

pub fn evict_stale_cache(&mut self) -> usize

Evict goal-cache entries whose TTL has elapsed.

Called automatically by cleanup_expired_sessions but also available for manual invocation.

pub fn session_stats(&self) -> SessionStats

Produce a snapshot of aggregate statistics over all live sessions.

pub fn session_count(&self) -> usize

Number of currently tracked sessions (active + recently completed).

pub fn gc_sessions(&mut self, max_age_secs: u64) -> usize

Garbage-collect sessions older than max_age_secs.

A session is considered “old” when the wall-clock time since it was started exceeds max_age_secs, regardless of whether it completed normally. Returns the number of sessions that were removed.

pub fn session_metrics(&self) -> SessionMetrics

Return a SessionMetrics snapshot for monitoring purposes.

• active_sessions — sessions that have not yet completed.
• completed_sessions — sessions where all peers replied or timed-out.
• expired_sessions — sessions that exceeded their per-session timeout.
• avg_peers_per_session — mean number of peers registered per session.
• avg_latency_ms — mean latency_ms across all RemoteResults.