What a node reads — the input, the context and the outputs of other nodes

The nodes of a flow read data by path: a root and then names separated by dots, such as input.plan or nodes.check.output.met. This page says what the roots hold, where paths are written and what a node does when its path finds nothing.

The three roots

• Each name after a dot goes one level down: input.customer.tier. A list is read by the position of an item, counted from 0: input.messages.0.content.

• A path has no spaces and no braces, and no empty name between two dots.

• <key> is the key of the node in the flow. The panel of a node in the builder shows the key under its title. A key is 1 to 64 lowercase Latin letters, digits, underscores and hyphens.

The input and the context

The input reaches the flow as the caller sent it: an object, empty if the caller sent nothing. AI Model takes the messages of its call from input.messages, and from nowhere else.

Slen trims the white space at the ends of a string of the context, and a string left empty becomes null. context.user_id names the customer the call is made for, and context.credit_type the credit type of their account that pays — default when it is left out. Send a request says what the context may hold.

Request passes the input on unchanged, so nodes.<key>.output.<name> of the entry node reads the same value as input.<name>.

What each node leaves

A node leaves its output when it finishes. A node the execution did not pass — it stands on another branch — leaves nothing, and a path into its output finds nothing.

The answer of AI Model — and the stored one a hit of Cache Lookup gives back — has this shape:

{
  "model": "gpt-4o-mini",
  "content": "Thanks for your order!",
  "finish_reason": "stop",
  "tool_calls": null,
  "usage": { "input_tokens": 412, "output_tokens": 96, "cached_input_tokens": 0 }
}

The output of a node is kept while the execution waits, so a node after a pause reads what the nodes before it left. The output is not stored with the trace, and the console does not show it. To see a value of an execution, write it into a note with Trace Note.

Where paths are written

• Condition tests the value at the path of its Field.

• Transform reads the value of each field it builds from a path.

• Trace Note fills {{ path }} in its message with the value at the path.

• Return Response can answer with the whole output of a node it names by its key.

• Http Request fills each {{ path }} of the path and the query of its address with the value at the path, and sends the value at the path of its body as the body — Http Request.

• Cache Lookup is the exception. Its Key fields are paths inside the input, written without input. in front: messages, not input.messages.

The paths of Condition and Transform are checked when the flow is published. A path starts with one of the three roots, and a path into nodes names a node of the flow that stands on a way leading to the node that reads it. A flow that breaks this is not published.

When a path finds nothing

A path that finds nothing does not fail the execution, except at Http Request. Each other node goes on in its own way and writes a warning event into the trace.

• Condition leaves through Not met. Only the operator exists asks whether there is a value at all.

• Transform puts the default of the field, or null, in place of the value.

• Trace Note leaves the placeholder in the note as it was typed.

• Http Request makes no call and leaves through Error. With nothing connected to that port, the execution ends failed — Http Request.

A value that is there and holds null is found: it is not the same as a value that is missing.

{ "type": "warning", "node_key": "check", "payload": { "reason": "unknown_path", "field": "context.plan" } }

Where to go next

• Send a request — the input and the context, from the side of the application.

• Ports and branching — how the port a node leaves through chooses the branch.

• How a flow is built — every node of the builder.

• AI Model — the answer of a model call and what it holds.