Workflow Definition Reference

A workflow definition is a JSON document describing a graph of steps and connections. It is passed as a JSON-encoded string in the definitionJson field when saving via the API.

Envelope

{
  "kind": "channelos.workflow",
  "schemaVersion": "1.0",
  "workflowId": "",
  "name": "my_workflow",
  "description": "Optional description",
  "graph": {
    "nodes": {},
    "edges": {}
  }
}

Graph structure

The graph contains two maps: nodes and edges. Keys are arbitrary unique IDs.

Node object

"my_step": {
  "id": "my_step",
  "label": "My step",
  "actionType": "integration.http_request",
  "config": {
    "url": "https://api.example.com/notify",
    "method": "POST"
  },
  "position": { "x": 260, "y": 40, "width": 160, "height": 68 }
}

Edge object

"e1": {
  "id": "e1",
  "source": { "nodeId": "start", "portId": "out" },
  "target": { "nodeId": "notify", "portId": "in" }
}

Data flow between steps

Every step receives a single JSON object called input. That object is the output of the previous step — or the workflow's start payload for the first step. Most steps pass their output forward unchanged; steps that explicitly produce new data replace the flowing payload.

Passthrough steps

These steps do not modify the payload. The next step receives exactly the same input as the passthrough step did:

• flow.start — passes the instance start payload forward
• logic.condition — routes but does not change input
• logic.switch — routes but does not change input
• logic.parallel — every branch receives the same input
• timing.delay / timing.cron — timer only; payload unchanged
• debug.log — logs only; payload unchanged

Steps that produce new data

The following steps replace the flowing payload with their own output. Everything after them sees the new shape.

Parallel branches and logic.join output

When branches converge at a logic.join, their outputs are merged into a single object. The key for each branch is taken from the label of the incoming edge. Give every edge from logic.parallel to the body a distinct label; the join output will mirror those labels:

// edge from parallel → fetch_employees  has label "employees"
// edge from parallel → fetch_rules      has label "rules"

// input to the node after join:
{
  "employees": { /* fetch_employees output */ },
  "rules":     { /* fetch_rules output */ }
}

If any incoming edge has no label, the branches are merged positionally as { "branches": [ branch0, branch1, ... ] }. Always label your parallel edges to get predictable named keys.

Foreach loop — item access

Inside a logic.foreach loop body, the current iteration item is always available at input.item. The original array container is also accessible as a sibling at its collection path:

// foreach config: { "collection": "recipients" }
// input.item     → current recipient object
// input.recipients → the full recipients array (still accessible)

// example in a send_message step inside the loop:
"to": "{{input.item.email}}"

Referencing earlier steps

Any step processed by the TypeScript runtime (data / integration / communication / task) records its output in the step store. You can reference those outputs from any later step using {{steps.stepId.field}}:

// step id "fetch_user" returned { "name": "Alice", "plan": "pro" }
"subject": "Hello {{steps.fetch_user.name}}"

// nested fields:
"body": "Plan: {{steps.fetch_user.plan}}"

Note: Engine-side steps (flow.*, logic.*, timing.*, signal.*) are not tracked in the step store and cannot be referenced via {{steps.*}}. To access the original workflow start payload at any point in the flow, use {{instance.input.field}}. To preserve other intermediate values across branches or after a join, use data.transform as a capture step.

Edge portId — when it matters

For most steps, source.portId is only used by the visual editor for layout and can be any string. It has routing significance for exactly two step types:

target.portId is always ignored at runtime.

Expressions

Runtime actions (data / integration / communication / task) support {{...}} expressions inside string config values. Engine actions (logic / flow / timing / signal) use direct input.field syntax without braces.

Expressions can appear inside any string config value: "body": "Order {{input.orderId}} confirmed"

Engine actions

These run in the deterministic C++ workflow engine. Expression syntax: input.field (no {{ }}).

flow.start

Entry point. Every workflow must have exactly one. No config.

{ "actionType": "flow.start", "config": {} }

flow.end

Terminal node. The instance completes when reached. No config.

{ "actionType": "flow.end", "config": {} }

flow.subprocess

Start a child workflow and wait for it to complete. The parent instance parks until the child reaches flow.end, then resumes with the child's final output. (Previously named flow.run.)

{
  "actionType": "flow.subprocess",
  "config": {
    "workflowId": "2",
    "version": "deployed",
    "inputJson": "{}"
  }
}

logic.condition

Branch on a boolean expression. Engine syntax — no {{ }} wrappers.

{
  "actionType": "logic.condition",
  "config": { "expression": "input.amount > 1000" }
}

Output ports: true, false

logic.switch

Route to one of N branches based on the value of an expression. Connect outgoing edges with portId equal to the expected case value. Use "else" port for the no-match case.

{
  "actionType": "logic.switch",
  "config": { "expression": "input.status" }
}

logic.parallel

Fork into multiple concurrent branches simultaneously. Connect outgoing edges with type: "fork". Pair with logic.join. No config.

{ "actionType": "logic.parallel", "config": {} }

logic.join

Wait for all parallel branches to arrive before continuing. Incoming edges use type: "join". No config.

{ "actionType": "logic.join", "config": {} }

logic.foreach

Iterate over an array. Runs the loop body once per item. The current item is always available as input.item; the full parent payload (including the source array) remains accessible at input.*.

{
  "actionType": "logic.foreach",
  "config": { "collection": "items" }
}

Inside the loop body: input.item is the current element (e.g. {{input.item.email}}). The source array is also still readable (e.g. {{input.items}} if collection is "items").

Output port: out — connect to the first node in the loop body. Pair with logic.foreach_join.

logic.foreach_join

Marks the end of the loop body. Triggers the next iteration, or exits when all items are done. No config.

{ "actionType": "logic.foreach_join", "config": {} }

Output: { "results": [...] } — array of each iteration body's final output. Output port: out.

timing.delay

Pause the workflow for a fixed duration in milliseconds. No threads are held; the instance is parked in the engine.

{
  "actionType": "timing.delay",
  "config": { "duration_ms": 3600000 }
}

Common values: 5000 (5s)  |  60000 (1m)  |  3600000 (1h)  |  86400000 (24h)

timing.cron

Schedule periodic execution. The instance parks until the next cron tick fires, then completes. The engine automatically restarts the workflow on the next tick. Must be placed as the first node after flow.start.

{
  "actionType": "timing.cron",
  "config": {
    "cron": "0 9 * * MON-FRI",
    "timezone": "Europe/Kyiv"
  }
}

signal.wait

Suspend the instance until a named external signal is received via POST /api/v1/runtime/signal. Signal payload becomes this step's output.

{
  "actionType": "signal.wait",
  "config": { "signal": "approved" }
}

If signal is omitted, the step ID is used as the signal name. Output port: out.

signal.ask

Send a prompt message, park the instance until a signal arrives, then validate the received value. Retries automatically with an error message until validation passes.

{
  "actionType": "signal.ask",
  "config": {
    "prompt": "Enter your date of birth (YYYY-MM-DD):",
    "errorPrompt": "Invalid date, please try again:",
    "validate": "date",
    "channel": "telegram",
    "to": "{{instance.input.chatId}}"
  }
}

Output: the validated value as { "value": <input> }.

signal.send_to_session

Send a named signal to the primary workflow instance associated with a session. Useful in sub-workflows to wake the parent after completing an operation.

{
  "actionType": "signal.send_to_session",
  "config": {
    "sessionId": "{{instance.input.sessionId}}",
    "signal": "operation_result"
  }
}

The current step input is passed as the signal payload. Output port: out.

Data transformation

These run in the TypeScript runtime. Config string fields support {{...}} expressions.

data.transform

Reshape the payload. Each value in the mapping object is resolved as an expression.

{
  "actionType": "data.transform",
  "config": {
    "mapping": {
      "fullName": "{{input.firstName}} {{input.lastName}}",
      "email": "{{input.email}}",
      "total": "{{steps.calc.total}}"
    }
  }
}

Output: the resolved mapping object.

data.compute

Evaluate a JavaScript expression in a sandboxed VM. Write raw JS — no {{ }}.

{
  "actionType": "data.compute",
  "config": { "expression": "input.qty * input.price * 1.2" }
}

Available: input, steps, Math, Date, JSON, Array, Object, standard type constructors. Output: computed value.

data.build_record

Assemble a new object from named key-value pairs.

{
  "actionType": "data.build_record",
  "config": {
    "fields": [
      { "key": "name", "value": "{{input.name}}" },
      { "key": "label", "value": "Order {{input.orderId}}" }
    ]
  }
}

data.render_template

Render a multi-line Handlebars template. The step's input is the template data context.

{
  "actionType": "data.render_template",
  "config": {
    "template": "Hello {{name}},\n\nYour balance is {{balance}} USD.",
    "outputKey": "text"
  }
}

Special helpers: {{today}} (YYYY-MM-DD), {{now}} (ISO datetime)

data.format_text

Render a single-line Mustache-style template. References input fields via {{field}}.

{
  "actionType": "data.format_text",
  "config": {
    "template": "Hello {{name}}, your report for {{today}} is ready.",
    "outputKey": "text"
  }
}

data.filter_list

Filter an array to items that satisfy a condition.

{
  "actionType": "data.filter_list",
  "config": {
    "source": "orders",
    "field": "status",
    "operator": "equals",
    "value": "pending",
    "caseSensitive": false
  }
}

Output: { "items": [...] }

data.sort_list

Sort an array by a field.

{
  "actionType": "data.sort_list",
  "config": {
    "source": "orders",
    "field": "createdAt",
    "direction": "desc",
    "type": "date"
  }
}

data.merge_records

Shallow-merge two or more objects. Later sources overwrite earlier on key conflicts.

{
  "actionType": "data.merge_records",
  "config": {
    "sources": ["input", "steps.defaults", "steps.patch.extra"]
  }
}

"input" = step input; "steps.stepId" = full step output; "steps.stepId.field" = nested field.

data.json_path

Extract a value using a JSONPath expression evaluated against the step's input.

{
  "actionType": "data.json_path",
  "config": {
    "expression": "$.data.items[0].id",
    "outputKey": "result"
  }
}

Single match returns value directly; multi-match returns array; no match returns null.

data.extract_columns

Extract specific columns from a 2-D array (e.g. Google Sheets values). Column letters are Excel-style: "A", "B", etc.

{
  "actionType": "data.extract_columns",
  "config": {
    "source": "values",
    "skipRows": 1,
    "columns": ["A", "C", "E"],
    "keepEmpty": false
  }
}

Output: { "items": [[...], [...], ...] } — each item is an array of cell values in column order.

data.summarize

Wrap a list into a summary document with metadata. Typically used after logic.foreach_join.

{
  "actionType": "data.summarize",
  "config": {
    "title": "Weekly Report",
    "source": "results",
    "includeDate": true
  }
}

Output: { "title", "generatedAt", "generatedDate", "totalCount", "items" }

data.array_to_map

Convert an array of objects into a keyed map.

{
  "actionType": "data.array_to_map",
  "config": {
    "source": "items",
    "keyField": "sku",
    "valueField": "price"
  }
}

Output: { "sku-001": 29.99, "sku-002": 49.99, ... }

data.file Files

Generate or fetch a binary artifact stored outside workflow state. Use artifactId in email attachments.

{
  "actionType": "data.file",
  "config": {
    "action": "generate",
    "name": "invoice.pdf",
    "mimeType": "application/pdf",
    "encoding": "base64",
    "data": "{{steps.render.pdfBase64}}"
  }
}

Output: { "artifactId", "name", "mimeType", "size", "expiresAt" }

data.excel Files

Generate an .xlsx file either by filling a namespace template or from scratch. Returns an artifactId for use with communication.send_file.

// Fill a template
{
  "actionType": "data.excel",
  "config": {
    "action": "from_template",
    "templatePath": "templates/report.xlsx",
    "sheet": "Data",
    "startRow": 2,
    "rows": "{{steps.sql_report.rows}}",
    "columns": ["name", "date", "amount"],
    "name": "report_{{input.date}}.xlsx"
  }
}

// Generate from scratch
{
  "actionType": "data.excel",
  "config": {
    "action": "generate",
    "headers": ["Name", "Date", "Amount"],
    "rows": "{{steps.sql_report.rows}}",
    "columns": ["name", "date", "amount"],
    "name": "report.xlsx"
  }
}

Output: { "artifactId": "..." }. Pass artifactId to communication.send_file to deliver the file.

data.parse_csv Files

Parse a CSV string into an array of objects (with header row) or an array of arrays (without header row).

{
  "actionType": "data.parse_csv",
  "config": {
    "source": "csvContent",
    "delimiter": ",",
    "hasHeader": true,
    "outputKey": "rows"
  }
}

Output: { "rows": [...] } or { [outputKey]: [...] }.

data.to_csv Files

Convert an array of objects or arrays into a CSV string.

{
  "actionType": "data.to_csv",
  "config": {
    "source": "rows",
    "columns": ["name", "email", "amount"],
    "delimiter": ",",
    "includeHeader": true,
    "outputKey": "csv"
  }
}

Output: { "csv": "..." } or { [outputKey]: "..." }.

data.db_query Storage

Run a SELECT query against a database and return matching rows.

{
  "actionType": "data.db_query",
  "config": {
    "connectionSecret": "db/prod",
    "driver": "postgres",
    "table": "orders",
    "where": [["status", "=", "pending"]],
    "limit": 100
  }
}

Output: { "rows": [...] }.

data.db_insert Storage

Insert a single row into a database table.

{
  "actionType": "data.db_insert",
  "config": {
    "connectionSecret": "db/prod",
    "driver": "postgres",
    "table": "orders",
    "fields": [["status", "pending"], ["created_at", "{{now}}"]]
  }
}

Output: { "lastInsertRowid": ... }.

data.db_update Storage

Update rows in a database table matching the given conditions.

{
  "actionType": "data.db_update",
  "config": {
    "connectionSecret": "db/prod",
    "driver": "postgres",
    "table": "orders",
    "fields": [["status", "shipped"]],
    "where": [["id", "=", "{{input.orderId}}"]]
  }
}

Output: { "changes": N } — number of affected rows.

data.db_delete Storage

Delete rows from a database table matching the given conditions.

{
  "actionType": "data.db_delete",
  "config": {
    "connectionSecret": "db/prod",
    "driver": "postgres",
    "table": "sessions",
    "where": [["expires_at", "<", "{{now}}"]]
  }
}

Output: { "changes": N } — number of deleted rows.

data.db_upsert Storage

Insert or update a row in a database table based on a conflict key.

{
  "actionType": "data.db_upsert",
  "config": {
    "connectionSecret": "db/prod",
    "driver": "sqlite",
    "table": "settings",
    "fields": [["key", "theme"], ["value", "dark"]],
    "conflictKey": "key"
  }
}

Output: { "lastInsertRowid": ..., "changes": N }.

data.db_bulk_insert Storage

Insert multiple rows into a database table in a single transaction. Optionally creates the table if it does not exist.

{
  "actionType": "data.db_bulk_insert",
  "config": {
    "connectionSecret": "db/prod",
    "driver": "sqlite",
    "table": "report_data",
    "rows": "{{steps.parse_csv.rows}}",
    "createTableIfNotExists": true,
    "onConflict": "ignore"
  }
}

Output: { "insertedRows": N }.

Communication

data.namespace_store Storage

Persistent key-value store scoped to the namespace. Lets workflow runs share state across executions — useful for deduplication, counters, cross-workflow flags, and rolling accumulators. Requires base plan or above.

// set
{ "actionType": "data.namespace_store", "config": { "operation": "set", "key": "last_run_id", "value": "{{input.id}}", "ttlSeconds": 86400 } }

// get
{ "actionType": "data.namespace_store", "config": { "operation": "get", "key": "last_run_id" } }

// increment (atomic counter)
{ "actionType": "data.namespace_store", "config": { "operation": "increment", "key": "msg_count", "delta": 1, "outputKey": "count" } }

Output: { "value": <result> } or { [outputKey]: <result> }. get returns null when missing or expired.

communication.send_message

Send a message via email, Telegram, or WhatsApp.

// Email (plain text)
{
  "actionType": "communication.send_message",
  "config": {
    "channel": "email",
    "to": "{{input.email}}",
    "subject": "Your order is confirmed",
    "body": "Hello {{input.name}}, your order is ready."
  }
}

// Email (HTML + plain text fallback)
{
  "actionType": "communication.send_message",
  "config": {
    "channel": "email",
    "to": "{{input.email}}",
    "subject": "Your order is confirmed",
    "body": "Hello {{input.name}}, your order is ready.",
    "htmlBody": "{{steps.render_html.output.html}}"
  }
}

// Telegram
{
  "actionType": "communication.send_message",
  "config": {
    "channel": "telegram",
    "to": "{{env.TELEGRAM_CHAT_ID}}",
    "text": "New order: {{input.orderId}}"
  }
}

// WhatsApp
{
  "actionType": "communication.send_message",
  "config": {
    "channel": "whatsapp",
    "to": "{{input.phone}}",
    "text": "Hello {{input.name}}, your booking is confirmed."
  }
}

When htmlBody is provided, a multipart/alternative email is sent — body is used as the plain-text fallback for clients that do not render HTML. Use data.render_template to generate htmlBody from a Handlebars template.

communication.ask_confirm Telegram

Send a message with Confirm and Cancel inline keyboard buttons, then park the workflow until the user taps one. Routes to confirmed or cancelled output ports accordingly.

{
  "actionType": "communication.ask_confirm",
  "config": {
    "prompt": "Are you sure you want to delete this record?",
    "confirmLabel": "Yes, delete",
    "cancelLabel": "No, keep it",
    "channel": "telegram"
  }
}

Output ports: confirmed and cancelled. Connect each to the desired branch.

communication.pick_from_list Telegram

Build a dynamic inline keyboard from an array in the step input, send it to the user, and park until one item is selected. The selected value is emitted on the output.

{
  "actionType": "communication.pick_from_list",
  "config": {
    "prompt": "Select an employee:",
    "itemsPath": "employees.items",
    "labelField": "name",
    "valueField": "id",
    "signal": "user_action",
    "channel": "telegram"
  }
}

Output: the selected item’s valueField value.

communication.send_file Telegram

Send an artifact file through a delivery channel. Typically used after data.excel or data.file to deliver a generated file to the user.

{
  "actionType": "communication.send_file",
  "config": {
    "channel": "telegram",
    "artifactId": "{{steps.generate_report.artifactId}}",
    "caption": "Your monthly report is attached.",
    "to": "{{instance.input.chatId}}"
  }
}

Output port: sent.

telegram.register_session Telegram

Transfer the Telegram session (chatId → instanceId mapping) to the current workflow instance. Use as the first step in sub-workflows launched via flow.run or flow.subprocess so that communication.send_message and reply routing work correctly.

{
  "actionType": "telegram.register_session",
  "config": {
    "chatId": "{{input.chatId}}"
  }
}

Integrations

integration.http_request

Make an outbound HTTP request. Step input is optionally sent as the JSON body. Supports static Bearer tokens and full OAuth 2.0 client credentials / refresh token flows with automatic token caching.

// Bearer auth
{
  "actionType": "integration.http_request",
  "config": {
    "method": "POST",
    "url": "https://api.example.com/orders",
    "sendBody": true,
    "authType": "bearer",
    "authBearerSecret": "my_api_key"
  }
}

// OAuth 2.0 — client credentials
{
  "actionType": "integration.http_request",
  "config": {
    "method": "GET",
    "url": "https://api.salesforce.com/services/data/v59.0/query",
    "authType": "oauth2",
    "authGrantType": "client_credentials",
    "authTokenUrl": "https://login.salesforce.com/services/oauth2/token",
    "authClientIdSecret": "sf/client_id",
    "authClientSecretSecret": "sf/client_secret",
    "authScope": "api",
    "authCacheKey": "salesforce_prod"
  }
}

Common fields

Bearer auth — authType: "bearer"

OAuth 2.0 — authType: "oauth2"

Output: { "status": 200, "body": { ... } }. Non-2xx responses fail the step (retryable on 5xx, 408, 429).

integration.google_sheets Google Sheets

Read from or write to a Google Sheets spreadsheet via a service account.

{
  "actionType": "integration.google_sheets",
  "config": {
    "credentialSecret": "gsheets_sa_key",
    "operation": "read",
    "spreadsheetId": "{{env.SHEET_ID}}",
    "range": "Sheet1!A1:D100"
  }
}

integration.script_runner

Execute a script file from the namespace script store. Input is passed via stdin as JSON; stdout is captured as output.

{
  "actionType": "integration.script_runner",
  "config": {
    "interpreter": "python",
    "scriptPath": "transform_data.py"
  }
}

Input is passed to the script via stdin as JSON; captured stdout becomes the step output.

integration.sql External SQL

Execute a raw SQL statement against a PostgreSQL, MySQL, or SQLite database. Supports SELECT queries, DML (INSERT/UPDATE/DELETE), and multi-statement DDL.

// Query (SELECT)
{
  "actionType": "integration.sql",
  "config": {
    "connectionSecret": "db/prod",
    "driver": "postgres",
    "operation": "query",
    "sql": "SELECT id, name, amount FROM orders WHERE status = $1",
    "params": ["pending"],
    "outputKey": "rows"
  }
}

// Execute (INSERT/UPDATE/DELETE)
{
  "actionType": "integration.sql",
  "config": {
    "connectionSecret": "db/prod",
    "driver": "postgres",
    "operation": "execute",
    "sql": "UPDATE orders SET status = $1 WHERE id = $2",
    "params": ["shipped", "{{input.orderId}}"]
  }
}

Output for query: { "rows": [...] }. For execute: { "changes": N }.

Finance Finance

Finance actions manage invoices and payments within the built-in billing system. All monetary values are in cents (minor units).

finance.create_invoice

Create a new invoice for a client.

{
  "actionType": "finance.create_invoice",
  "config": {
    "clientId": "{{input.clientId}}",
    "amount": "4900",
    "currency": "usd",
    "items": "[{\"description\":\"Base plan (monthly)\",\"amount\":4900}]",
    "dueDate": "2026-07-01"
  }
}

Output: { "invoiceId": N, "status": "pending" }

finance.charge

Initiate payment for an invoice. Returns a checkout URL (if external provider) or marks the payment as pending.

{
  "actionType": "finance.charge",
  "config": {
    "invoiceId": "{{steps.create_inv.invoiceId}}",
    "returnUrl": "https://portal.example.com/thank-you"
  }
}

Output: { "paymentId": N, "checkoutUrl": "https://..." }

finance.send_invoice

Send invoice notification via email or Telegram.

{
  "actionType": "finance.send_invoice",
  "config": {
    "invoiceId": "{{steps.create_inv.invoiceId}}",
    "channel": "email",
    "to": "{{input.email}}"
  }
}

Output: { "sent": true }

finance.check_payment_status

Get the current status of a payment.

{
  "actionType": "finance.check_payment_status",
  "config": {
    "paymentId": "{{steps.charge.paymentId}}"
  }
}

Output: { "status": "completed" | "pending" | "failed", "paidAt": "..." | null }

finance.refund

Refund a completed payment. Omit amount for a full refund.

{
  "actionType": "finance.refund",
  "config": {
    "paymentId": "{{steps.charge.paymentId}}",
    "amount": "2500"
  }
}

Output: { "refunded": true, "amount": 2500 }

Other

debug.log

Write a log entry and pass input through unchanged. Safe to insert anywhere for debugging.

{
  "actionType": "debug.log",
  "config": {
    "message": "Current amount: {{input.amount}}",
    "level": "info"
  }
}

level: debug | info (default) | warn | error

task.manual

Pause the workflow and wait for a human to complete the task. The instance stays in running state until an external caller invokes POST /api/v1/runtime/step/complete.

{ "actionType": "task.manual", "config": {} }

No configuration required. Complete the task via:

POST /api/v1/runtime/step/complete
{
  "instanceId": "42",
  "stepId": "review_task",
  "outputJson": "{\"approved\": true, \"comment\": \"Looks good\"}"
}

The outputJson becomes this step's output: {{steps.review_task.approved}} in subsequent steps. Output port: output.

Examples

Complete workflow definitions ready to copy and use. Pass the JSON as the definitionJson string value when saving.

{
  "kind": "channelos.workflow",
  "schemaVersion": "1.0",
  "workflowId": "",
  "name": "minimal_example",
  "graph": {
    "nodes": {
      "start": { "id": "start", "label": "Start", "actionType": "flow.start", "config": {} },
      "call": {
        "id": "call",
        "label": "Call API",
        "actionType": "integration.http_request",
        "config": {
          "method": "POST",
          "url": "https://httpbin.org/post",
          "sendBody": true
        }
      },
      "end": { "id": "end", "label": "End", "actionType": "flow.end", "config": {} }
    },
    "edges": {
      "e1": { "id": "e1", "source": { "nodeId": "start", "portId": "out" }, "target": { "nodeId": "call", "portId": "in" } },
      "e2": { "id": "e2", "source": { "nodeId": "call", "portId": "out" }, "target": { "nodeId": "end", "portId": "in" } }
    }
  }
}

{
  "kind": "channelos.workflow",
  "schemaVersion": "1.0",
  "workflowId": "",
  "name": "conditional_branch",
  "graph": {
    "nodes": {
      "start": { "id": "start", "label": "Start", "actionType": "flow.start", "config": {} },
      "check": {
        "id": "check",
        "label": "High value?",
        "actionType": "logic.condition",
        "config": { "expression": "input.amount > 1000" }
      },
      "priority": {
        "id": "priority",
        "label": "Notify priority",
        "actionType": "communication.send_message",
        "config": {
          "channel": "telegram",
          "to": "{{env.TELEGRAM_CHAT_ID}}",
          "text": "High-value order: {{input.orderId}} ({{input.amount}} USD)"
        }
      },
      "standard": {
        "id": "standard",
        "label": "Standard notify",
        "actionType": "communication.send_message",
        "config": {
          "channel": "email",
          "to": "{{input.email}}",
          "subject": "Order received",
          "body": "Your order {{input.orderId}} is being processed."
        }
      },
      "end": { "id": "end", "label": "End", "actionType": "flow.end", "config": {} }
    },
    "edges": {
      "e1": { "id": "e1", "source": { "nodeId": "start", "portId": "out" }, "target": { "nodeId": "check", "portId": "in" } },
      "e2": { "id": "e2", "source": { "nodeId": "check", "portId": "true" }, "target": { "nodeId": "priority", "portId": "in" } },
      "e3": { "id": "e3", "source": { "nodeId": "check", "portId": "false" }, "target": { "nodeId": "standard", "portId": "in" } },
      "e4": { "id": "e4", "source": { "nodeId": "priority", "portId": "out" }, "target": { "nodeId": "end", "portId": "in" } },
      "e5": { "id": "e5", "source": { "nodeId": "standard", "portId": "out" }, "target": { "nodeId": "end", "portId": "in" } }
    }
  }
}

{
  "kind": "channelos.workflow",
  "schemaVersion": "1.0",
  "workflowId": "",
  "name": "foreach_email",
  "graph": {
    "nodes": {
      "start": { "id": "start", "label": "Start", "actionType": "flow.start", "config": {} },
      "loop": {
        "id": "loop",
        "label": "For each recipient",
        "actionType": "logic.foreach",
        "config": { "collection": "recipients" }
      },
      "send": {
        "id": "send",
        "label": "Send email",
        "actionType": "communication.send_message",
        "config": {
          "channel": "email",
          "to": "{{input.item.email}}",
          "subject": "{{input.item.subject}}",
          "body": "Hello {{input.item.name}}, {{input.item.message}}"
        }
      },
      "loop_end": { "id": "loop_end", "label": "Loop end", "actionType": "logic.foreach_join", "config": {} },
      "end": { "id": "end", "label": "End", "actionType": "flow.end", "config": {} }
    },
    "edges": {
      "e1": { "id": "e1", "source": { "nodeId": "start", "portId": "out" }, "target": { "nodeId": "loop", "portId": "in" } },
      "e2": { "id": "e2", "source": { "nodeId": "loop", "portId": "out" }, "target": { "nodeId": "send", "portId": "in" } },
      "e3": { "id": "e3", "source": { "nodeId": "send", "portId": "out" }, "target": { "nodeId": "loop_end", "portId": "in" } },
      "e4": { "id": "e4", "source": { "nodeId": "loop_end", "portId": "out" }, "target": { "nodeId": "end", "portId": "in" } }
    }
  }
}

{
  "kind": "channelos.workflow",
  "schemaVersion": "1.0",
  "workflowId": "",
  "name": "approval_flow",
  "graph": {
    "nodes": {
      "start": { "id": "start", "label": "Start", "actionType": "flow.start", "config": {} },
      "capture": {
        "id": "capture",
        "label": "Capture input",
        "actionType": "data.transform",
        "config": {
          "mapping": {
            "requesterEmail": "{{input.requesterEmail}}",
            "title": "{{input.title}}"
          }
        }
      },
      "notify_reviewer": {
        "id": "notify_reviewer",
        "label": "Notify reviewer",
        "actionType": "communication.send_message",
        "config": {
          "channel": "email",
          "to": "{{env.REVIEWER_EMAIL}}",
          "subject": "Review requested: {{input.title}}",
          "body": "Please review the request and complete the task in the portal."
        }
      },
      "review": {
        "id": "review",
        "label": "Human review",
        "actionType": "task.manual",
        "config": {}
      },
      "check": {
        "id": "check",
        "label": "Approved?",
        "actionType": "logic.condition",
        "config": { "expression": "input.approved === true" }
      },
      "on_approved": {
        "id": "on_approved",
        "label": "Notify approved",
        "actionType": "communication.send_message",
        "config": {
          "channel": "email",
          "to": "{{steps.capture.requesterEmail}}",
          "subject": "Your request was approved",
          "body": "Your request has been approved."
        }
      },
      "on_rejected": {
        "id": "on_rejected",
        "label": "Notify rejected",
        "actionType": "communication.send_message",
        "config": {
          "channel": "email",
          "to": "{{steps.capture.requesterEmail}}",
          "subject": "Your request was rejected",
          "body": "Your request was not approved."
        }
      },
      "end": { "id": "end", "label": "End", "actionType": "flow.end", "config": {} }
    },
    "edges": {
      "e1": { "id": "e1", "source": { "nodeId": "start", "portId": "out" }, "target": { "nodeId": "capture", "portId": "in" } },
      "e2": { "id": "e2", "source": { "nodeId": "capture", "portId": "out" }, "target": { "nodeId": "notify_reviewer", "portId": "in" } },
      "e3": { "id": "e3", "source": { "nodeId": "notify_reviewer", "portId": "out" }, "target": { "nodeId": "review", "portId": "in" } },
      "e4": { "id": "e4", "source": { "nodeId": "review", "portId": "output" }, "target": { "nodeId": "check", "portId": "in" } },
      "e5": { "id": "e5", "source": { "nodeId": "check", "portId": "true" }, "target": { "nodeId": "on_approved", "portId": "in" } },
      "e6": { "id": "e6", "source": { "nodeId": "check", "portId": "false" }, "target": { "nodeId": "on_rejected", "portId": "in" } },
      "e7": { "id": "e7", "source": { "nodeId": "on_approved", "portId": "out" }, "target": { "nodeId": "end", "portId": "in" } },
      "e8": { "id": "e8", "source": { "nodeId": "on_rejected", "portId": "out" }, "target": { "nodeId": "end", "portId": "in" } }
    }
  }
}