Action Nodes

Non-LLM programmatic nodes for deterministic workflow operations. Action nodes complement LLM agents by handling data transformation, API integrations, control flow, and automation logic.

Overview

Action nodes are visually distinct from LLM agent nodes — they use unique colors and icons to make workflows easy to scan. Each node type handles a specific category of operation, from HTTP requests to database queries to conditional branching.

All action nodes share a set of standard properties for error handling, tracing, execution control, and I/O mapping. They support {{variable}} interpolation in string fields and automatically receive predecessor node outputs.

Available Nodes

---

Standard Properties

Every action node inherits these shared properties:

Identity

Error Handling

Tracing

Execution Control

Input/Output Mapping

---

Node Reference

Trigger Node 🎯

Workflow entry point. Every workflow starts with a Trigger node. See the dedicated Triggers Guide for full details.

HTTP Node 🌐

Makes HTTP requests to external APIs with full auth, header, body, and response handling.

Configuration:

Example:

{
  "type": "http",
  "name": "Fetch User Data",
  "method": "GET",
  "url": "https://api.example.com/users/{{userId}}",
  "auth": {
    "type": "bearer",
    "bearer": { "token": "{{API_TOKEN}}" }
  },
  "headers": { "Accept": "application/json" },
  "body": { "type": "none" },
  "response": { "type": "json", "jsonPath": "$.data" },
  "errorHandling": { "mode": "retry", "retryCount": 3, "retryDelay": 1000 },
  "mapping": { "outputKey": "userData" }
}

Set Node 📝

Defines and manipulates workflow state variables. Supports literal values, expressions, and secrets.

Configuration:

Variable types: string, number, boolean, json, expression

Variables marked isSecret: true are masked in logs and UI.

Transform Node ⚙️

Transforms data using expressions or built-in operations.

Transform types:

Built-in operations: pick, omit, rename, flatten, sort, unique

Type coercion targets: string, number, boolean, array, object

Switch Node 🔀

Conditional branching with multiple output ports. Each condition maps to a separate output port on the node.

Configuration:

Condition operators: eq, neq, gt, lt, gte, lte, contains, startsWith, endsWith, matches, in, empty, exists

Example:

{
  "type": "switch",
  "evaluationMode": "first_match",
  "conditions": [
    { "id": "ok", "name": "Success", "field": "status", "operator": "eq", "value": "success", "outputPort": "success" },
    { "id": "err", "name": "Error", "field": "status", "operator": "eq", "value": "error", "outputPort": "error" }
  ],
  "defaultBranch": "unknown"
}

Loop Node 🔄

Iterates over arrays, repeats a fixed number of times, or loops while a condition holds.

Loop types:

Parallel execution: Enable parallel.enabled with optional batchSize and delayBetween for concurrent iteration.

Result aggregation: When results.collect is true, iteration results are gathered into an array under results.aggregationKey.

Merge Node 🔗

Combines multiple parallel branches back into a single flow. Has multiple input ports.

Merge modes:

Combine strategies: array, object, first, last

Optional timeout with continue or error behavior.

Wait Node ⏱️

Pauses workflow execution.

Wait types:

Code Node 💻

Executes custom JavaScript in a sandboxed boa_engine runtime. Graph state is injected as the global input object.

Configuration:

Sandbox defaults:

Database Node 🗄️

Performs database operations with connection pooling and parameterized queries.

Supported databases:

Connection strings are treated as secrets and masked in logs.

Email Node 📧

Send emails via SMTP or monitor incoming emails via IMAP.

Send mode (SMTP):

• TLS/SSL support
• Authentication
• To/CC/BCC recipients
• HTML or plain text body
• {{variable}} interpolation in subject and body
• File attachments from state

Monitor mode (IMAP):

• Folder selection (default: INBOX)
• Filters: sender, subject, date range, unread only
• Mark as read after processing

Notification Node 🔔

Sends notifications to messaging platforms.

Channels: Slack, Discord, Microsoft Teams, custom webhook

Message formats: plain text, markdown, platform-specific blocks (Block Kit, Embeds, Adaptive Cards)

RSS Node 📡

Monitors RSS/Atom feeds for new entries.

• Configurable poll interval
• Keyword, author, category, and date filters
• Seen-item tracking to avoid duplicates
• Optional full content or summary only

File Node 📁

File operations on local or cloud storage.

Operations: read, write, delete, list

Cloud providers: Amazon S3, Google Cloud Storage, Azure Blob Storage

File formats: JSON, CSV, XML, text, binary (with CSV parsing options for delimiter, headers, quoting)

---

Variable Interpolation

All string fields in action nodes support {{variable}} syntax for dynamic values:

https://api.example.com/users/{{userId}}
Bearer {{API_TOKEN}}
Hello {{user.name}}, your order {{orderId}} is ready.

Variables are resolved from the workflow state at execution time. Dot notation (user.name) accesses nested values.

Multi-Port Nodes

Two node types have dynamic port counts:

• Switch — one output port per condition, plus an optional default port
• Merge — multiple input ports, one per incoming branch

These ports are visually represented on the node and connect to different downstream/upstream nodes.

---

Code Generation

Action nodes compile to production Rust code alongside LLM agents. Dependencies are auto-detected and added to the generated Cargo.toml.

All generated code uses adk-graph FunctionNode closures with GraphError::NodeExecutionFailed for error handling.

Example generated code (HTTP node):

let http_node = FunctionNode::new("fetch_data", |ctx| async move {
    let client = reqwest::Client::new();
    let resp = client.get("https://api.example.com/data")
        .bearer_auth(&ctx.get("API_TOKEN").unwrap_or_default())
        .send().await
        .map_err(|e| GraphError::NodeExecutionFailed {
            node: "fetch_data".into(),
            message: e.to_string(),
        })?;
    let body: serde_json::Value = resp.json().await?;
    Ok(NodeOutput::new().with_update("apiData", body))
});

Example generated code (Code node):

let code_node = FunctionNode::new("process", |ctx| async move {
    let mut js_ctx = boa_engine::Context::default();
    // Graph state injected as global `input` object
    // User code executed in thread-isolated sandbox
    Ok(NodeOutput::new().with_update("result", output))
});

---

Previous: ← Studio | Next: Triggers →