Struct OperatorDelegateMiddleware 

pub struct OperatorDelegateMiddleware;

When ctx.operator.operator.is_some() (the session has an Operator backend), bypass inner.spawn, call operator.execute(ctx, prompt), and box the result up as a WorkerHandle. In other words: the path that hands “this spawn” to whatever external Operator backend the engine has registered.

Independent of OperatorKind (Operator is a generic abstraction)

An earlier implementation gated on kind == MainAi | Composite, which tied the Operator abstraction to an “AI driver” assumption — a design weakness. The Operator trait is a generic external processing backend (LLM, human, external resource, side-effectful operation — anything), and is orthogonal to the kind axis.

The current implementation decides solely on operator.is_some():

• Automate session + operator backend registered → delegate (pure external-execution delegation).
• MainAi session + operator backend registered → delegate.
• Any kind + operator None → pass through (normal inner.spawn).

kind still matters as a firing condition for SpawnHooks over in MainAIMiddleware, but this middleware ignores it.

Split of responsibilities with OperatorSpawner

The two axes exist for different reasons:

• This middleware — the Blueprint-global (session) axis. Delegate every agent to the same Operator backend. The operator_backend_id is set at session-attach time; ctx.agent is ignored and every spawn in that session is routed through the operator (e.g. a MainAI-wide driver, or a human-wide console). The Blueprint doesn’t have to talk about kind — it just declares the capability hint "operator_delegate" (keeping the Blueprint clean).

• OperatorSpawner — the AgentSpec axis. Each AgentDef bakes its own Operator backend. kind = Operator AgentDefs pick a backend via spec.operator_ref; the compiler bakes an Arc<dyn Operator> into routes[agent_name]. Agents loaded via the agent.md loader come in through this path (their default is kind = Operator).

Exclusivity

When both are effective — this middleware’s hint is declared, the session has an operator backend, and the Blueprint has a kind = Operator AgentDef — this middleware sits at the outer end of the stack and completely bypasses inner.spawn. The OperatorSpawner is never reached, so a double fire cannot occur by construction; the AgentSpec axis is inert. Consistent use means picking one axis per use case.

Implementations

impl OperatorDelegateMiddleware

pub fn new() -> Self

Stateless constructor.

Trait Implementations

impl Default for OperatorDelegateMiddleware

fn default() -> Self

Returns the “default value” for a type.

impl SpawnerLayer for OperatorDelegateMiddleware

fn wrap(&self, inner: Arc<dyn SpawnerAdapter>) -> Arc<dyn SpawnerAdapter>

Wraps inner in this layer’s behaviour, returning a new SpawnerAdapter that delegates to inner (directly or via wrap_join) while adding this layer’s cross-cutting effect.