Enum Node 

pub enum Node {
    Agent(AgentNode),
    Tool(ToolNode),
    Gate(GateNode),
    Branch(BranchNode),
    Map(MapNode),
    Fold(FoldNode),
}

One node in a graph: exactly one of the six kinds the runtime knows how to execute.

Adjacently tagged like the event enum: each node serializes as {"kind": "...", "payload": {...}}. The tag (kind) and content (payload) live in separate keys, which never collides with a payload field and does not force payloads to be JSON objects. deny_unknown_fields on the enum rejects any key other than kind and payload.

The stable node id lives inside each payload (every payload struct carries an id), reachable generically through Node::id. Keeping the id in the payload is what lets the outer shape stay exactly the two-key adjacent tagging the event log uses, with no third common field to special-case.

Variants

Agent(AgentNode)

A full agent loop (model, prompt, tools, budget). The whole v0.1 product becomes one node kind. It references its agent definition BY CONTENT HASH, never an embedded definition, so this crate stays a leaf that does not depend on the agent-definition schema.

Tool(ToolNode)

A single direct tool invocation, no model in the loop.

Gate(GateNode)

Human approval: suspends the graph run and renders in the approval inbox.

Branch(BranchNode)

Routes on a typed output. The cases (conditions and their names) are recorded as DATA here; this crate never evaluates them.

Map(MapNode)

Fan-out: spawn a sub-run per element of a typed list, join on completion, with a concurrency cap.

Fold(FoldNode)

Bounded iteration: run a body repeatedly, accumulating across passes, until a stop predicate holds or an iteration bound is reached, then join the passes into one value. Models an adversarial refine loop (draft, score, review, revise) as one node. Execution is not implemented: the fold exists in the format, the validator, the projection, and the canvas; the engine records a typed refusal for it.

Implementations

impl Node

pub fn id(&self) -> &str

The node’s stable id, whatever its kind.

pub fn kind_name(&self) -> &'static str

The kind name ("agent", "tool", …), for error messages.

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

The node’s optional display name, whatever its kind. See the module docs’ “The optional node display name” section.

pub fn input_schema(&self) -> Option<&Value>

The JSON Schema this node declares for the payload it CONSUMES, if any. Absent means the node does not declare an input type, and an edge into it passes the type-compatibility check unchecked.

pub fn output_schema(&self) -> Option<&Value>

The JSON Schema this node declares for the payload it PRODUCES, if any. Absent means the node does not declare an output type, and an edge out of it passes the type-compatibility check unchecked.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Node

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Node

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 Node

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Node

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 Node