Templating & Expressions

Flow nodes read two things at run time: inputs (a dict of upstream nodes’ outputs, keyed by input port name) and parameters (the run’s parameters, plus — inside a for_each body — the current item/index). Different node types expose two different ways to reference them in config.

`llm_call` and `action_call` templating

llm_call’s prompt/system_prompt and action_call’s string parameters values are plain Python str.format() templates, rendered against inputs/parameters:

- id: summarize
  type: llm_call
  config:
    prompt: "Summarize this ticket: {inputs[in][body]}"

- id: notify
  type: action_call
  config:
    action_id: "664f1c2e5a2ac9f0d39326"
    parameters:
      to: "{inputs[in][email]}"
      greeting: "Hello, {parameters[first_name]}!"

Nested dict/list access uses [key] chains — no dots (e.g. {inputs[in][user][email]}, not {inputs.in.user.email}).
action_call renders every string value in parameters this way, recursively through nested dicts/lists; non-string values (numbers, booleans) pass through unchanged.
If a referenced key is missing, the node fails with a clear error naming the field and the missing key — e.g. llm_call 'prompt' references 'foo', which is missing from inputs/parameters on this run — rather than silently rendering an empty string.

`if`, `for_each`, and `rest_call` query values: Python expressions

if.config.left, for_each.config.items, and any rest_call.config.query value that mentions inputs or parameters are evaluated as a Python expression (via eval), with inputs and parameters as the only names in scope:

- id: check_amount
  type: if
  config:
    left: "inputs['in']['amount'] > parameters['threshold']"
    operator: is_true

- id: process_items
  type: for_each
  config:
    items: "inputs['in']['orders']"

- id: search
  type: rest_call
  config:
    url: "https://api.example.com/search"
    query:
      q: "inputs['in']['query']"        # evaluated (mentions `inputs`)
      limit: "20"                        # sent as a literal string — no reference

This is a genuine eval() against untrusted-shaped input — the subprocess sandbox each node runs in is the isolation boundary, not the expression syntax itself. Only reference inputs/parameters; there is no other trust model layered on top.

`python` node: full function body

The python node doesn’t template strings at all — it runs a complete Python module. Your handler(inputs, parameters) function receives both dicts directly and returns the node’s output:

- id: transform
  type: python
  config:
    code: |
      def handler(inputs, parameters):
          order = inputs.get("in", {})
          return {"total": order["amount"] * 1.1}

Passing data across a branch

When an if node’s upstream input is a dict, its fields are merged through to the chosen branch alongside branch and value, so a node downstream of true (or false) still sees the original payload, not just the condition’s result:

// if node output on the "true" branch, given upstream input {"ticket": {...}}
{ "ticket": { "...": "..." }, "branch": "true", "value": true }

Reference

Node type	Field(s)	Syntax
`llm_call`	`prompt`, `system_prompt`	`str.format()` — `{inputs[...]}`, `{parameters[...]}`
`action_call`	`parameters` (string values, recursively)	`str.format()` — `{inputs[...]}`, `{parameters[...]}`
`if`	`left`	Python expression (`eval`) with `inputs`/`parameters` in scope
`for_each`	`items`	Python expression (`eval`) with `inputs`/`parameters` in scope
`rest_call`	`query` values	Python expression (`eval`) when the string mentions `inputs`/`parameters`; otherwise sent as a literal
`python`	`code`	Full Python module; `handler(inputs, parameters)` receives both dicts as-is

Get Started

Reference

Deployment

Tutorial

Templating & Expressions

`llm_call` and `action_call` templating

`if`, `for_each`, and `rest_call` query values: Python expressions

`python` node: full function body

Passing data across a branch

Reference

​llm_call and action_call templating

​if, for_each, and rest_call query values: Python expressions

​python node: full function body

​Passing data across a branch

​Reference

`llm_call` and `action_call` templating

`if`, `for_each`, and `rest_call` query values: Python expressions

`python` node: full function body

Passing data across a branch

Reference