Struct RuntimeSnapshot 

pub struct RuntimeSnapshot {
    pub nexo_config: Arc<AgentConfig>,
    pub effective_policies: Arc<DashMap<Option<usize>, Arc<EffectiveBindingPolicy>>>,
    pub tool_cache: Arc<ToolRegistryCache>,
    pub llm_client: Option<Arc<dyn LlmClient>>,
    pub version: u64,
    pub context_optimization: ResolvedContextOptimization,
}

Immutable snapshot of everything hot-reload can swap on an agent.

Held behind Arc<ArcSwap<RuntimeSnapshot>> by AgentRuntime; the intake hot path calls .load() per event (lock-free). Fields that never change across reloads (the mpsc senders, the tokio JoinSet, the shutdown token) stay on AgentRuntime itself.

Fields

nexo_config: Arc<AgentConfig>

The AgentConfig this snapshot was built from. Downstream consumers (delegation ACL, heartbeat interval lookups) read agent-level fields from here instead of holding a separate Arc<AgentConfig>.

effective_policies: Arc<DashMap<Option<usize>, Arc<EffectiveBindingPolicy>>>

Pre-resolved per-binding capability policies, keyed by binding_index (Some(n) for real bindings, None for the legacy agent-level fallback). Built at snapshot construction so the intake path is an Arc lookup, not a resolve.

tool_cache: Arc<ToolRegistryCache>

Per-binding filtered tool registry cache. Keyed by (agent_id, binding_index); entries built lazily the first time a binding sees traffic. Fresh per snapshot so a reload that changes allowed_tools does not serve a stale filtered clone.

llm_client: Option<Arc<dyn LlmClient>>

LLM client for this agent. None in early-boot snapshots built before the LlmRegistry is wired in (tests, scaffolding). Production snapshots constructed via the reload coordinator always populate this; consumers that fall back read the behavior-owned llm field.

version: u64

Monotonic version per agent. The intake path tags log lines with this so operators can correlate “session X used version Y” when debugging a reload.

context_optimization: ResolvedContextOptimization

Phase F follow-up — the four context-optimization enables, already resolved against llm.context_optimization and the agent’s per-agent override. Captured at snapshot-build time so the agent loop reads the current enables on every turn (a reload that swaps the snapshot is observed on the next snapshot_ref.load()). The boot-time wiring on LlmAgentBehavior (compactor / token_counter / workspace_cache instances) stays put — these flags only gate whether the agent loop uses those instances on a given turn.

Implementations

impl RuntimeSnapshot

pub fn bare(nexo_config: Arc<AgentConfig>, version: u64) -> Self

pub fn build( nexo_config: Arc<AgentConfig>, llm_registry: &LlmRegistry, llm_cfg: &LlmConfig, version: u64, ) -> Result<Self>

pub fn policy_for( &self, binding_index: Option<usize>, ) -> Option<Arc<EffectiveBindingPolicy>>

Convenience: look up the pre-resolved policy for a binding index. Returns None only when the policy map is missing the slot (never happens for a snapshot built via build — the legacy path seeds None and each real binding seeds Some(n)).

pub fn tools_for( &self, agent_id: &str, binding_index: Option<usize>, base: &ToolRegistry, allowed_tools: &[String], ) -> Arc<ToolRegistry>

Fetch or build the filtered tool registry for a binding. Thin delegation to the per-snapshot ToolRegistryCache; the base registry stays external to the snapshot because it is owned by the AgentRuntime and typically shared across reloads (plugin hot-reload is Phase 19).

pub fn tools_for_with_dispatch( &self, agent_id: &str, binding_index: Option<usize>, base: &ToolRegistry, allowed_tools: &[String], dispatch_policy: &DispatchPolicy, is_admin: bool, ) -> Arc<ToolRegistry>

PT-2 — dispatch-aware variant. Same lazy cache, but the filtered registry also has apply_dispatch_capability applied so dispatch tools the binding’s DispatchPolicy disallows are not registered.

Trait Implementations

impl Clone for RuntimeSnapshot

fn clone(&self) -> RuntimeSnapshot

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RuntimeSnapshot

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.