Enum EngineError 

pub enum EngineError {
    MapOverNotAList {
        node: String,
        over: String,
    },
    UnsupportedMapBody {
        node: String,
        detail: String,
    },
    NoBranchCaseMatched {
        node: String,
    },
    BranchDecisionUnmatched {
        node: String,
        reply: String,
        cases: Vec<String>,
    },
    UnsupportedNode {
        node: String,
        kind: &'static str,
    },
    UnknownAgent {
        node: String,
        agent_hash: String,
    },
    UnknownTool {
        node: String,
        tool: String,
    },
    MalformedGraph {
        detail: String,
    },
    ToolFailed {
        node: String,
        message: String,
    },
    GraphEncode(Error),
    Runtime(RuntimeError),
}

Why a graph drive could not continue.

Variants

MapOverNotAList

A map node’s over reference did not resolve to a JSON array against the routed value (it was missing, or resolved to a non-array value). A map can only fan out over a list, so the engine refuses deterministically rather than guessing. Returned before the map’s NodeEntered is recorded, so nothing lands in the log past the refusal, and it reproduces on replay: the same recorded routed value re-resolves to the same non-list.

Fields

node: String

The id of the map node.

over: String

The over reference that failed to resolve to a list.

UnsupportedMapBody

A map node’s body is a form that is not executable: an embedded subgraph (per-item sub-walks need their own log per iteration to keep node ids unambiguous, which is not implemented yet), or a node body that names a node whose kind cannot be a per-item worker (only agent and tool bodies run). Returned before the map’s NodeEntered is recorded, so nothing lands in the log past the refusal. The document layer still validates these as legal graphs; only the engine declines to run them.

Fields

node: String

The id of the map node.

detail: String

What about the body is not supported.

NoBranchCaseMatched

An expression branch reached with no case whose condition evaluated true. The author declared the cases exhaustively or the graph cannot proceed; the engine refuses deterministically rather than guessing a route. Returned before the branch’s NodeEntered is recorded, so nothing lands in the log past the refusal, and the refusal reproduces on replay (the same routed value re-evaluates to the same no-match).

Fields

node: String

The id of the branch node.

BranchDecisionUnmatched

A model-decision branch’s agent produced a reply that is not one of the branch’s case names. Unlike the other refusals this arrives after the branch’s NodeEntered and the decision agent’s own events are recorded (the model had to run to produce the reply); it still reproduces on replay, because the reply is decoded from the recorded model completion.

Fields

node: String

The id of the branch node.

reply: String

The agent’s reply, trimmed, that named no case.

cases: Vec<String>

The branch’s case names, in author order.

UnsupportedNode

A node whose kind the engine does not execute was reached on the walk. Today the sole such kind is fold: its execution semantics are not implemented, so the engine refuses it with this typed error rather than guessing a loop. Returned before the node’s NodeEntered is recorded, so nothing lands in the log past the refusal, and it reproduces on replay (the same document re-walks to the same refusal). The document layer still validates a fold as a legal graph; only the engine declines to run it.

Fields

node: String

The id of the node whose kind is not executable here.

kind: &'static str

The node’s kind name ("fold").

UnknownAgent

An agent node referenced an agent hash the resolver could not supply.

Fields

node: String

The id of the agent node.

agent_hash: String

The unresolved agent definition hash.

UnknownTool

A tool node named a tool the resolver could not supply.

Fields

node: String

The id of the tool node.

tool: String

The unresolved tool name.

MalformedGraph

The graph’s edges do not form a well-formed DAG (a cycle, or an edge referencing a node that is not in the document). The document validator rejects both at submit; the engine re-checks defensively so a walk is never attempted over a malformed topology.

Fields

detail: String

What was wrong with the topology.

ToolFailed

A tool node’s call failed after exhausting its retry policy. The full failure is already recorded in the log’s ToolCallCompleted; this carries the message so the caller sees why the graph stopped.

Fields

node: String

The id of the tool node that failed.

message: String

The recorded failure message.

GraphEncode(Error)

The graph document could not be serialized to compute its hash. A graph is plain data, so this does not arise in practice; it exists to keep the hashing edge honest rather than panicking on a serde_json error.

Runtime(RuntimeError)

A RunCtx operation surfaced a runtime error (replay divergence, a dangling write needing reconciliation, a live provider failure, a store failure). Passed through unchanged.

Trait Implementations

impl Debug for EngineError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for EngineError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for EngineError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<RuntimeError> for EngineError

fn from(source: RuntimeError) -> Self

Converts to this type from the input type.