Struct ManagedRuntime 

pub struct ManagedRuntime { /* private fields */ }

Unified container orchestrating AgentRuntime, ComponentRegistry, and a root ShutdownToken.

Construct via AgentConfigBuilder::build_managed or ManagedRuntime::new.

Lifecycle

  new()  →  init_all  →  start_all  →  serve  →  signal_shutdown  →  stop_all

Hot-reload

ManagedRuntime::reload walks the drain-aware replace protocol: old instance drains in-flight references, new instance is constructed and started, then swapped in atomically.

Implementations

impl ManagedRuntime

pub fn new( runtime: AgentRuntime, registry: ComponentRegistry, shutdown: ShutdownToken, ) -> Self

Construct a new managed runtime from its constituent parts.

The caller is responsible for ensuring that the extensions backing runtime and the registry are consistent (i.e. the registry’s initialized components have already been applied to the extensions).

pub fn runtime(&self) -> &AgentRuntime

Borrow the underlying AgentRuntime.

pub fn registry(&self) -> &ComponentRegistry

Borrow the ComponentRegistry.

pub fn shutdown_token(&self) -> ShutdownToken

Clone the root ShutdownToken.

pub fn extensions(&self) -> Arc<Extensions>

Clone the Extensions facade from the underlying runtime.

pub fn component<T: Component>( &self, name: &str, ) -> Result<Arc<T>, ManagedError>

Look up an initialized component by name, downcasting to a concrete Arc<T>.

Errors

• ManagedError::ComponentNotFound if the name is not registered or not yet initialized.
• ManagedError::Registry on type mismatch.

pub async fn serve(&self) -> Result<(), ManagedError>

Serve until the root shutdown token fires.

Components are stopped in reverse dependency order after the shutdown signal is received.

Errors

Returns the first error from component stop.

pub async fn health(&self) -> HashMap<String, HealthStatus>

Aggregate health of every initialized component.

pub async fn is_healthy(&self) -> bool

Returns true if every component reports healthy.

pub async fn overall_health(&self) -> HealthStatus

Aggregate all component health into a single HealthStatus using worst-case semantics.

Returns Unhealthy if any component is unhealthy, Degraded if any is degraded, Healthy otherwise (including empty).

pub async fn is_ready(&self) -> bool

Returns true if every component is at least operational (healthy or degraded). This is the readiness gate suitable for load-balancer probes.

pub async fn healthz_json(&self) -> Value

Build a JSON /healthz response body containing the overall status and per-component breakdown.

pub async fn reload<T: Component>( &self, name: &str, new_instance: T, ) -> Result<Arc<T>, ManagedError>

Hot-reload a running component by replacing it with a new instance of the same type.

The drain-aware protocol:

1. Calls pre_replace_hook on the old instance.
2. Starts the new instance. If this fails, the old instance remains in place.
3. Atomically swaps the instance in the registry. Existing Arc<T> clones held by other tasks keep the old instance alive until dropped (natural drain).
4. Calls post_replace_hook on the old instance (best-effort).

Returns the old Arc<T> so the caller can await explicit cleanup or hold it for drain purposes.

Errors

• ManagedError::ComponentNotFound if the name is not registered.
• ManagedError::Reload if the component is not running, or if any phase of the replace protocol fails.

pub async fn reload_raw( &self, name: &str, new_instance: Box<dyn AnyComponent>, ) -> Result<Arc<dyn AnyComponent>, ManagedError>

Low-level hot-reload using a type-erased replacement.

This is the untyped counterpart of ManagedRuntime::reload: the caller supplies a fully constructed Box<dyn AnyComponent> instead of a typed T. Useful when the replacement was built through a factory or configuration-driven path.

Errors

See ManagedRuntime::reload.

Trait Implementations

impl Debug for ManagedRuntime

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

Formats the value using the given formatter.