Struct EngineDispatcher 

pub struct EngineDispatcher { /* private fields */ }

Bridges mlua_flow_ir::AsyncDispatcher to the engine’s start_task + dispatch_attempt_with pair. Holds one Operator session token and one spawner, and spins up a fresh task per Step.ref, using it as the agent name.

Constructed via with_spawner; each dispatch goes through engine.dispatch_attempt_with(token, tid, spawner, run_id), carrying the spawner per request. Nothing is stashed on engine-global state, so multiple dispatchers can drive different Blueprints against the same Engine in parallel without racing.

Optionally carries a RunContext (via Self::with_run, issue #13 run_id propagation): when present, every dispatched step’s run_id is exposed to the worker through Ctx.meta.runtime["run_id"], and a StepEntry is appended to RunRecord.step_entries once the step’s outcome is known (dispatch is synchronous end-to-end here, so there is no need for a separate event/notification mechanism — the entry is written with its final status in one call).

Implementations

impl EngineDispatcher

pub fn with_spawner( engine: Engine, op_token: CapToken, spawner: Arc<dyn SpawnerAdapter>, ) -> Self

Build a dispatcher with no run-level tracing (run_ctx = None) — the pre-existing behavior. Use Self::with_run to opt into RunRecord.step_entries tracing / ctx.meta.runtime["run_id"].

pub fn with_run(self, run_ctx: RunContext) -> Self

Attach a RunContext (builder style) so every dispatched step is traced into RunRecord.step_entries and exposes its run_id via Ctx.meta.runtime.

Trait Implementations

impl AsyncDispatcher for EngineDispatcher

fn dispatch<'life0, 'life1, 'async_trait>( &'life0 self, ref_: &'life1 str, input: Value, ) -> Pin<Box<dyn Future<Output = Result<Value, EvalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,