Struct HostBackends 

pub struct HostBackends {

    pub native_async_store: Option<Arc<dyn NativeAsyncStore>>,
    pub harness_store: Arc<dyn RuntimeHarnessStore>,
    pub agent_store: Arc<dyn RuntimeAgentStore>,
    pub session_store: Arc<dyn RuntimeSessionStore>,
    pub event_log: Arc<dyn EventLog>,
    pub compaction_checkpoint_store: Arc<dyn CompactionCheckpointStore>,
    pub provider_store: Arc<dyn RuntimeProviderStore>,
    pub event_sink: Arc<dyn EventSink>,
    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 tool_context_extensions_factory: Option<ToolContextExtensionsFactory>,
    pub subagent_delegate_factory: Option<SubagentDelegateFactory>,
    pub tool_augmentor: Option<Arc<dyn HostToolAugmentor>>,
}

Non-filesystem backend bundle supplied to an execution host.

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 HostComposition.

Fields

native_async_store: Option<Arc<dyn NativeAsyncStore>>

Optional shared fenced journal for native asynchronous tool execution.

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.

event_log: Arc<dyn EventLog>

Coherent canonical event log. This is the sole conversation write path.

compaction_checkpoint_store: Arc<dyn CompactionCheckpointStore>

Durable replacement context used to reconstruct compacted model input.

provider_store: Arc<dyn RuntimeProviderStore>

Model/provider resolution and default-model configuration.

event_sink: Arc<dyn EventSink>

Optional, non-blocking live observation sink notified after commit.

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.

tool_context_extensions_factory: Option<ToolContextExtensionsFactory>

Optional higher-level typed services supplied to tool contexts.

subagent_delegate_factory: Option<SubagentDelegateFactory>

Optional neutral subagent delegate supplied by a higher-level host.

tool_augmentor: Option<Arc<dyn HostToolAugmentor>>

Optional higher-level tool augmentation policy.

Implementations

impl HostBackends

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_event_log(self, log: Arc<dyn EventLog>) -> Self

Replace the coherent canonical event log.

pub fn with_native_async_store(self, store: Arc<dyn NativeAsyncStore>) -> Self

pub fn with_compaction_checkpoint_store( self, store: Arc<dyn CompactionCheckpointStore>, ) -> Self

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

pub fn with_event_sink(self, sink: Arc<dyn EventSink>) -> Self

Install a non-blocking post-commit observation sink.

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_tool_context_extensions_factory( self, factory: ToolContextExtensionsFactory, ) -> Self

Inject type-erased tool services supplied by a higher-level host.

pub fn with_subagent_delegate_factory( self, factory: SubagentDelegateFactory, ) -> Self

Inject a neutral subagent delegate supplied by a higher-level host.

pub fn with_tool_augmentor(self, augmentor: Arc<dyn HostToolAugmentor>) -> Self

Inject higher-level turn-dependent tools.

Trait Implementations

impl Clone for HostBackends

fn clone(&self) -> HostBackends

Returns a duplicate of the value.

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

Performs copy-assignment from source.