Struct Sim 

pub struct Sim { /* private fields */ }

A deterministic, model-free driver for a compiled conversation.

Implementations

impl Sim

pub fn new(convo: &CompiledConversation, mode: Enforcement) -> Self

Build a simulator over convo in the given enforcement mode.

pub fn set(&self, key: impl Into<String>, value: impl Serialize) -> &Self

Set a state value directly (information a recognizer can’t supply, or a scripted shortcut). Does not advance a turn.

pub async fn user(&mut self, utterance: &str) -> &mut Self

The fake user speaks: run the conversation’s extractors over the utterance to fill slots (respecting validators), then advance a turn.

pub fn turn(&mut self) -> &mut Self

Advance a turn with no new user input (e.g. waiting on a tool/resolver).

pub fn tool_ok(&mut self, tool: &str) -> &mut Self

A tool succeeds now; records it and advances a turn (processing any digression resume).

pub fn tool_failed(&mut self, tool: &str) -> &mut Self

A tool fails or times out. Counts toward the active stage’s escalate_after_tool_failures; does not advance a turn.

pub fn interrupt(&mut self) -> &mut Self

The user barges in on the model. Counts toward the active stage’s escalate_after_interruptions; does not advance a turn.

pub fn schedule_tool( &mut self, tool: impl Into<String>, after: u32, ) -> &mut Self

Schedule a tool to succeed after turns — models tool latency.

pub fn with_decisions(self, bank: BTreeMap<String, Decision>) -> Self

Answer scripted decisions as these questions would be: a pick from options_from and a writes key behave as in a live session. Without the bank, an answer is recorded but writes nothing.

pub fn decide(&mut self, answers: &BTreeMap<String, Value>) -> &mut Self

The caller just spoke, and a decision model answered: true/false for a boolean, an option’s key for a choice ("none_of_these" for none), a number for a score, null for unsure. Earlier answers no longer count, as at a new caller turn in a live session. The flow takes the answers in at once, as before a tool is admitted: a digression they trigger opens now.

pub async fn apply(&mut self, step: &SimStep) -> Result<(), String>

Apply one scripted step: drive the conversation, or check an expectation. Err carries why an expectation did not hold. This is what Scenario::run does for each step, exposed so another driver (an interactive session, a binding) shares the exact semantics.

pub fn active(&self) -> Vec<String>

Active step ids in the currently-driving layer.

pub fn active_overlay(&self) -> Option<&str>

The active digression, if one is suspending the main flow.

pub fn postures(&self) -> Vec<String>

The instructions (stage postures) projected to the model this turn.

On the turn a digression completes, these are its closing stage’s — the safety hand-off’s “hand off to a human now”, say — which is what a live session would send. Assert on these to test that a digression is heard, not merely that it fired.

pub fn is_terminated(&self) -> bool

Whether the conversation has ended because a Resume::Terminate digression ran (as opposed to the main flow finishing).

pub fn allowed(&self, tool: &str) -> bool

Whether tool is admitted right now.

pub fn denied(&self) -> BTreeMap<String, String>

Currently-blocked tools, mapped to the reason.

pub fn is_complete(&self) -> bool

Whether the conversation is complete.

pub fn slot<T: DeserializeOwned>(&self, key: &str) -> Option<T>

Read a slot value.

pub fn explain(&self) -> FlowExplanation

The active layer’s control-plane explanation.

pub fn state(&self) -> &State

The simulation state (for custom assertions / slot evidence).