Enum GraphNodeBody 

pub enum GraphNodeBody {
    Action {
        verb: Option<String>,
        action_name: String,
        mutating: bool,
        act_chain: Vec<String>,
        assertion_count: u32,
    },
    Assert {
        observe: String,
        assertions: Vec<AssertionSummary>,
    },
    Call {
        callee_flow_id: String,
        callee_ir_hash: String,
        input_keys: Vec<String>,
    },
    Human {
        mode: String,
        prompt_head: String,
        timeout_ms: u64,
    },
    If {
        cond: String,
        has_else: bool,
    },
    Foreach {
        items: String,
        as: String,
    },
    Let {
        binding_keys: Vec<String>,
    },
}

Kind-specific node payloads (discriminant = step kind, A.4-aligned).

Variants

Action

ActionStepIR (08 §3.1): verb/action, effect badge, act chain.

Fields

verb: Option<String>

Canonical verb, when the step used one (snake_case values).

action_name: String

First bound action name (the primary attempt’s).

mutating: bool

mutating (solid badge) vs readonly (hollow badge).

act_chain: Vec<String>

The act chain channel chips, in binding.attempts order (08 §3.4 — one attempt means no fallback, none is invented).

assertion_count: u32

Assertion count badge.

Assert

AssertStepIR: observation source + assertion summaries.

Fields

observe: String

"fresh" or the referenced fromStep step id.

assertions: Vec<AssertionSummary>

Per-assertion summary rows: assertId + verify chain chips.

Call

CallStepIR — the collapse node (08 §3.3): callee identity only; the callee graph loads lazily by calleeIrHash.

Fields

callee_flow_id: String

Callee flow id.

callee_ir_hash: String

Callee content hash (full sha256: form; renderers may abbreviate to the 8-hex prefix).

input_keys: Vec<String>

Input key names (values are authoring detail, not graph).

Human

HumanStepIR (08 §3.5): the pause-for-a-person node.

Fields

mode: String

Interaction mode.

prompt_head: String

First line of the prompt.

timeout_ms: u64

Response deadline; on_timeout: unknown is fixed vocabulary.

If

IfStepIR: condition summary; then/else children reference this node via parentId + region.

Fields

cond: String

Rendered condition expression summary.

has_else: bool

Whether an else region exists.

Foreach

ForeachStepIR — the aggregate node (08 §3.2): iterations are folded onto this single node, never fanned out.

Fields

items: String

Rendered items expression summary.

as: String

Iteration variable name.

Let

LetStepIR: binding key names (small node).

Fields

binding_keys: Vec<String>

Bound variable names.

Trait Implementations

impl Clone for GraphNodeBody

fn clone(&self) -> GraphNodeBody

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GraphNodeBody

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GraphNodeBody

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for GraphNodeBody

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for GraphNodeBody

fn eq(&self, other: &GraphNodeBody) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for GraphNodeBody

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for GraphNodeBody