Struct RuntimeBackends 

pub struct RuntimeBackends {
    pub harness_store: Arc<dyn RuntimeHarnessStore>,
    pub agent_store: Arc<dyn RuntimeAgentStore>,
    pub session_store: Arc<dyn RuntimeSessionStore>,
    pub message_store: Arc<dyn RuntimeMessageStore>,
    pub provider_store: Arc<dyn RuntimeProviderStore>,
    pub event_bus: Arc<dyn EventBus>,
    pub storage_store: Arc<dyn SessionStorageStore>,
    pub connection_resolver: Option<Arc<dyn UserConnectionResolver>>,
    pub session_task_registry: Option<Arc<dyn SessionTaskRegistry>>,
    pub schedule_store_factory: Option<ScheduleStoreFactory>,
    pub platform_store_factory: Option<PlatformStoreFactory>,
}

Non-filesystem backend bundle supplied to the embedded runtime.

Use this when you want the public runtime orchestration but your own store implementations instead of the built-in in-memory ones. Session filesystem selection is always resolved from PlatformDefinition.

Fields

harness_store: Arc<dyn RuntimeHarnessStore>

Harness definitions available to the runtime.

agent_store: Arc<dyn RuntimeAgentStore>

Agent definitions available to the runtime.

session_store: Arc<dyn RuntimeSessionStore>

Session records and mutable session metadata.

message_store: Arc<dyn RuntimeMessageStore>

Conversation message persistence and retrieval.

provider_store: Arc<dyn RuntimeProviderStore>

Model/provider resolution and default-model configuration.

event_bus: Arc<dyn EventBus>

Event sink (emit + optional collection).

storage_store: Arc<dyn SessionStorageStore>

Session key/value + secret storage backend.

connection_resolver: Option<Arc<dyn UserConnectionResolver>>

Optional resolver for user connection tokens (e.g. GitHub, Daytona).

When set, the runtime exposes it through ToolContext.connection_resolver so connection-aware capabilities can resolve tokens lazily at tool time. None (the default) leaves the resolver unset, matching prior behavior. There is no in-memory default because a connection resolver implies a real credential source the embedder must supply.

session_task_registry: Option<Arc<dyn SessionTaskRegistry>>

Optional session-task registry injected into the act path so background tools, subagents, and monitors persist their lifecycle. None (the default) leaves RuntimeHostAdapter::session_task_registry returning None, matching prior in-memory behavior.

schedule_store_factory: Option<ScheduleStoreFactory>

Optional per-org schedule store factory. None (the default) leaves RuntimeHostAdapter::schedule_store returning None.

platform_store_factory: Option<PlatformStoreFactory>

Optional per-(org, session) platform store factory. None (the default) leaves RuntimeHostAdapter::platform_store returning None.

Implementations

impl RuntimeBackends

pub fn in_memory() -> Self

Backend bundle with in-memory implementations for every store.

Suitable for tests, examples, and the default runtime configuration. Use the chainable with_* setters to override individual stores.

pub fn with_harness_store(self, store: Arc<dyn RuntimeHarnessStore>) -> Self

pub fn with_agent_store(self, store: Arc<dyn RuntimeAgentStore>) -> Self

pub fn with_session_store(self, store: Arc<dyn RuntimeSessionStore>) -> Self

pub fn with_message_store(self, store: Arc<dyn RuntimeMessageStore>) -> Self

pub fn with_provider_store(self, store: Arc<dyn RuntimeProviderStore>) -> Self

pub fn with_event_bus(self, bus: Arc<dyn EventBus>) -> Self

pub fn with_storage_store(self, store: Arc<dyn SessionStorageStore>) -> Self

pub fn with_connection_resolver( self, resolver: Arc<dyn UserConnectionResolver>, ) -> Self

Supply a resolver for user connection tokens (e.g. GitHub, Daytona).

The runtime forwards it into ToolContext so connection-aware capabilities resolve tokens lazily at tool execution time.

pub fn with_session_task_registry( self, registry: Arc<dyn SessionTaskRegistry>, ) -> Self

Inject a session-task registry so background tools / subagents / monitors persist their lifecycle through the act path. Additive: leaving this unset keeps the prior behavior (the adapter returns None).

pub fn with_schedule_store_factory(self, factory: ScheduleStoreFactory) -> Self

Inject a per-org schedule store factory. The closure is invoked with the internal org id each time the act path needs a schedule store.

pub fn with_platform_store_factory(self, factory: PlatformStoreFactory) -> Self

Inject a per-(org, session) platform store factory. The closure is invoked with the internal org id and the calling session id.

Trait Implementations

impl Clone for RuntimeBackends

fn clone(&self) -> RuntimeBackends

Returns a duplicate of the value.

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

Performs copy-assignment from source.