Struct MobBootstrapSpec 

pub struct MobBootstrapSpec {
    pub definition: MobDefinition,
    pub storage: MobStorage,
    pub session_service: Arc<dyn MobSessionService>,
    pub binary_blob_store: Option<Arc<dyn BinaryBlobStore>>,
    pub options: MobBootstrapOptions,
    pub runtime_adapter: Option<Arc<MeerkatMachine>>,
    /* private fields */
}

Specification for bootstrapping a mob runtime from a definition, storage, and session service.

Fields

definition: MobDefinition

storage: MobStorage

session_service: Arc<dyn MobSessionService>

binary_blob_store: Option<Arc<dyn BinaryBlobStore>>

options: MobBootstrapOptions

runtime_adapter: Option<Arc<MeerkatMachine>>

Explicit runtime adapter — bypasses session_service.runtime_adapter().

Used by persistent() to supply the adapter directly so the session service’s runtime_store can stay None (keeping the checkpointer enabled). See meerkat-session#checkpointer-enabled-flag.

Implementations

impl MobBootstrapSpec

pub fn new( definition: MobDefinition, storage: MobStorage, session_service: Arc<dyn MobSessionService>, ) -> Self

pub fn with_options(self, options: MobBootstrapOptions) -> Self

pub fn with_agent_mob_tools( self, mob_tools_slot: Arc<RwLock<Option<Arc<dyn MobToolsFactory>>>>, ) -> Self

Install the agent-facing mob tool surface (spawn/delegate + the schedule mob-target authority) for externally-constructed specs.

The stock persistent()/ephemeral constructors do this internally; specs built via MobBootstrapSpec::new (both gateway binaries roll their own session services) previously skipped it, which left agent_mob_mcp_state() None — members still got mob tools through meerkat-mob’s INTERNAL default state, but mobkit’s schedule host had no mob authority: spawn_schedule_host fell back to the Noop mob host, so agent-authored schedules could neither rewrite to mob-member targets at authoring nor deliver identity/mob targets at fire time (“scheduled identity targets are not supported by this session host”, the HomeCore 0.7.26 last-link failure).

Call AFTER any session-service wrapping (with_session_runtime_adapter) so the installed tools hold the final wrapped service, and AFTER with_workgraph_service so child mobs inherit the workgraph authority. mob_tools_slot is the agent factory builder’s default_mob_tools slot.

pub fn with_workgraph_service(self, service: Option<WorkGraphService>) -> Self

Thread a realm-scoped WorkGraph service into the mob runtime.

MobRuntime::bootstrap forwards it to MobBuilder::with_workgraph_service, which turns on apply-time attention overlay injection for every mob-executor turn. Call BEFORE with_agent_mob_tools — the agent mob state snapshots the service at install time so agent-spawned child mobs inherit it.

pub fn with_workgraph_admission_slot(self, slot: WorkGraphAdmissionSlot) -> Self

Register a tool-plane admission slot (returned by workgraph_wiring::install_workgraph_tools / attach_workgraph_tools*) to be filled at bootstrap with the runtime-wide WorkGraphAdmission. Every builder whose members can call workgraph_attention_reassign must have its slot registered here, or those members bypass the duplicate-binding admission guard the RPC surfaces enforce.

pub fn with_workgraph_admission_sidecar(self, state_dir: &Path) -> Self

Serialize admissions cross-process through the sidecar lock database under state_dir (see workgraph_admission_sidecar_path). Call for SQLite-backed workgraph stores — the store file is shareable by a gateway and a library-mode runtime on one state dir, and each process’s in-process gate cannot see the other. Memory-backed runtimes must not set this.

pub fn with_default_external_tools_provider( self, provider: ExternalToolsProvider, ) -> Self

Install a mob-wide external-tools provider (e.g. MCP-backed callback tools). Unlike the per-spawn SpawnMemberSpec.external_tools overlay — which member revival silently drops — this provider is consulted on every spawn AND every revival, so the tools are durable for the member’s whole lifecycle. The profile’s tools.mcp allowlist gates what each member sees; an empty allowlist means the full surface.

pub fn with_session_runtime_adapter(self, adapter: Arc<MeerkatMachine>) -> Self

Expose a runtime adapter through the session-service facade.

Custom embedders that construct their own MobSessionService still need MobKit’s session-service surface to report the same runtime authority that MobBuilder::with_runtime_adapter(...) receives. This keeps autonomous-host comms, runtime inspection, and control paths pointed at one machine without forcing embedders through the stock factory helpers.

pub fn with_after_create_hook(self, hook: AfterCreateHook) -> Self

Wrap the session service with an after-create hook that fires after each successful create_session. The hook is best-effort: errors are not propagated. Uses AfterCreateMobSessionService which wraps the inner service without a pre-build hook, so any pre-build mutations from inner wrappers are fully reflected in the context.

pub fn ephemeral( definition: MobDefinition, storage: MobStorage, store_path: PathBuf, max_sessions: usize, session_store: Option<Arc<dyn AgentSessionStore>>, ) -> Self

Build an ephemeral session service with a correctly wired AgentFactory.

If session_store is provided, it is set on the FactoryAgentBuilder so that agents use the given store instead of falling back to JSONL.

pub fn ephemeral_with_hook( definition: MobDefinition, storage: MobStorage, store_path: PathBuf, max_sessions: usize, session_store: Option<Arc<dyn AgentSessionStore>>, hook: impl Fn(&mut CreateSessionRequest) -> Pin<Box<dyn Future<Output = Result<(), SessionError>> + Send + '_>> + Send + Sync + 'static, ) -> Self

Like ephemeral, but with a pre-build hook that is called before each agent is constructed. Use this to inject external tools, augment system prompts, or set per-agent labels.

pub fn persistent( definition: MobDefinition, storage: MobStorage, store_path: PathBuf, max_sessions: usize, session_store: Arc<dyn SessionStore>, ) -> Self

Build a persistent session service with a correctly wired AgentFactory.

The session_store is used in two places:

1. As the persistence backend for PersistentSessionService (checkpoint/restore).
2. Adapted via StoreAdapter and set on FactoryAgentBuilder.default_session_store so that agents use it directly instead of falling back to JSONL.

pub fn persistent_with_hook( definition: MobDefinition, storage: MobStorage, store_path: PathBuf, max_sessions: usize, session_store: Arc<dyn SessionStore>, hook: impl Fn(&mut CreateSessionRequest) -> Pin<Box<dyn Future<Output = Result<(), SessionError>> + Send + '_>> + Send + Sync + 'static, ) -> Self

Like persistent, but with a pre-build hook that is called before each agent is constructed. Use this to inject external tools, augment system prompts, or set per-agent labels.