Struct OperatorSpawnerFactory 

pub struct OperatorSpawnerFactory { /* private fields */ }

Factory for AgentKind::Operator. Looks up the Arc<dyn Operator> pre-registered under spec.operator_ref and wraps it in an OperatorSpawner. Also resolves AgentDef.profile.worker_binding into a WorkerBinding at compile time and fails loud (CompileError::InvalidSpec) when the resolved operator’s Operator::requires_worker_binding is true and no binding was declared.

Spec shape:

{ "operator_ref": "main_ai" }     // Operator id pre-registered with the factory

Split of responsibilities with OperatorDelegateMiddleware

The two axes exist for different reasons:

• This factory (OperatorSpawnerFactory → OperatorSpawner) — the AgentSpec axis. Bakes a separate Operator backend into each AgentDef. A kind = Operator AgentDef names its backend through spec.operator_ref; at compile() time the Arc<dyn Operator> is baked into routes[agent_name]. Because the agent.md loader (agent_md_loader) defaults kind to Operator, agents that flow in through external agent.md files land here.

• OperatorDelegateMiddleware — the Blueprint-global (session) axis. Delegates every agent to the same Operator backend. At session-attach time you call engine.register_operator(id, op) plus attach_with_ids(.., operator_backend_id = Some(id)) to bind it session-wide, and declare spawner_hints.layers = ["operator_delegate"] to opt in. ctx.agent is ignored; the operator handles every spawn in that session (a MainAI-wide driver, a human-wide console, that sort of thing).

Exclusivity (a double fire is structurally impossible)

When both are effective — the hint is declared, the session has an operator backend, and the Blueprint has a kind = Operator AgentDef — OperatorDelegateMiddleware sits at the outer end of the stack and completely bypasses inner.spawn. The OperatorSpawner is never reached, so under those conditions this factory’s routes entry is inert. This is not a double fire — the session axis is overriding the agent axis. Consistent usage means picking one axis per use case.

Who answers spec.operator_ref — resolver first, registry second

spec.operator_ref names a Blueprint-declared seat (Blueprint.operators[]), and a seat’s holder is per-Run, mutable state. Two ways to answer it:

• A OperatorSlotResolver installed via Self::set_slot_resolver — the host hands back an indirection that resolves the seat’s current holder on every dispatch (mlua-swarm-server’s AssigneeRouter). What this factory bakes into routes[agent_name] is then “the seat”, not “the session that held it when the Blueprint compiled” — model §4.3 A10. This is the wiring mse serve uses.
• This factory’s own id → Arc<dyn Operator> map (no resolver installed) — the direct binding used by hosts with no Run store to resolve holders against: mse bp doctor’s lint stubs, in-process embeddings, tests.

The two never mix within one build: an installed resolver that cannot serve a seat fails the compile rather than falling through to the map, because falling through is exactly how a dispatch ends up at a backend the caller never named.

Interior mutability is provided by Arc<RwLock>s. Even after the factory has been stored as Arc<dyn SpawnerFactory> in SpawnerRegistry, a caller holding an Arc clone can still add Operator backends dynamically via register_operator(&self, id, op) or install the resolver. build() performs a read() lookup each time.

Implementations

impl OperatorSpawnerFactory

pub fn new() -> Self

Start with no registered Operator backends and no slot resolver.

pub fn set_slot_resolver( &self, resolver: Arc<dyn OperatorSlotResolver>, ) -> &Self

Install the OperatorSlotResolver every kind = Operator agent’s spec.operator_ref is answered through from now on (see the struct doc). Installing replaces any previous resolver.

Takes &self on purpose: the host builds its factory before it has a RunStore to resolve holders against (the router builder resolves the store), and the same Arc is already inside a SpawnerRegistry by then.

pub fn resolve_operator( &self, slot: &str, agent: &str, ) -> Result<Arc<dyn Operator>, CompileError>

The Arc<dyn Operator> a kind = Operator agent declaring operator_ref = slot dispatches through — the single lookup SpawnerFactory::build performs, exposed so a host can assert what its wiring resolves to without standing up a compile.

agent only shapes the error message (CompileError::InvalidSpec is keyed by agent name).

pub fn register_operator( &self, id: impl Into<String>, op: Arc<dyn Operator>, ) -> &Self

Register an Operator backend dynamically through &self. Overwrites are allowed — later wins. Callers can still reach this after the factory has been stored as Arc<dyn SpawnerFactory> in SpawnerRegistry, as long as they hold an Arc clone; interior mutability is provided by the inner RwLock.

pub fn unregister_operator(&self, id: &str) -> &Self

Dynamically unregister an id (used to clean up when a WebSocket disconnects, for example). A missing id is a no-op.

Trait Implementations

impl Default for OperatorSpawnerFactory

fn default() -> Self

Returns the “default value” for a type.

impl SpawnerFactory for OperatorSpawnerFactory

fn build( &self, agent_def: &AgentDef, _hint: Option<&Value>, ) -> Result<Arc<dyn SpawnerAdapter>, CompileError>

No build hint is read here: an Operator agent’s whole input is its declared seat (spec.operator_ref) plus its profile. The hint slot used to carry a launch-scoped session pin, which was the compile baking a destination — see the struct doc.

impl SpawnerFactoryKind for OperatorSpawnerFactory

const KIND: AgentKind = AgentKind::Operator

The AgentKind this factory handles — used as the HashMap key by SpawnerRegistry::register.

type Worker = OperatorWorker

The concrete Worker type produced by this AgentKind — this binds the type chain all the way from AgentKind down to Worker. Every factory declares it so the AgentKind → Worker mapping is explicit across all four layers. It is the source of truth for preserving the concrete type right up until SpawnerAdapter::spawn erases it into Box<dyn Worker>.