> For the complete documentation index, see [llms.txt](https://dataqueue.gitbook.io/voicehub-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://dataqueue.gitbook.io/voicehub-docs/agent-design-and-usage/pathway-action-nodes.md). # Pathway Action Nodes The goal of this overview page is to provide details on the notion of action nodes in voicehub. ## **Integration Nodes** ### **Webhook Node** **Overview** The Webhook Node is an action node used to perform HTTP requests to external APIs or services. It enables the agent to interact with external systems by sending or retrieving data, making it a key integration point within the flow. **When to Use** • When you need to fetch data from an external API.\ • When you need to send data to an external system. • For integrations with third-party services (e.g., CRM, databases, internal APIs).\ • When dynamic, real-time data is required during the conversation. **Features** • Supports multiple HTTP methods:\ • GET, POST, PUT, DELETE.\ • Fully configurable request setup:\ • API URL.\ • Headers.\ • Query Parameters:\ • Request Body. • Authentication support:\ • OAuth2 authentication.\ • Flexible request handling:\ • Supports sending a request body even with GET requests (for APIs that require it).\ • Timeout configuration to control request execution time.\ • Retry mechanism with exponential backoff for handling failures.\ • Execute synchronously or asynchronously (fire-and-forget).\ • Conditional routing based on response results. • Response handling:\ • Allows defining Response Data extraction.\ • Extract specific values from the JSON response.\ • Makes response data available for use in downstream nodes.\ • Built-in webhook/API testing before execution. **Example Usage & How to Use** Use case:\ Integrate the agent with external systems by calling APIs to send or retrieve real-time data during the conversation (e.g., fetching user details from a CRM). How to use: • Use the prompt to define what should be say while executing the webhook node (Optional).\ • Configure the API request by selecting the HTTP method (GET, POST, PUT, DELETE) and providing the request URL.\ • Add headers when needed (e.g., authentication tokens, content-type) and choose whether they are static, dynamic, or extracted from variables.\ • Define query parameters and body parameters to pass data to the API, using static values, extracted variables, or dynamic inputs.\ • Enable OAuth2 if the API requires authentication and select a valid connection (the system will inject the authorization token automatically).\ • Configure timeout to control how long the system waits for a response before failing the request.\ • Enable Response Data to extract specific values from the API response using JSONPath and make them available for downstream nodes. You can use `$._status` to get the HTTP status code, and `$._error.` to get fields from the error body (e.g. `$._error.message`). Fields prefixed with `$._error` will stay empty if the webhook succeeds.\ • Optionally enable Execute Async (Fire and Forget) if the request should run without waiting for a response (note: cannot be used together with Response Data).\ • Configure Exponential Backoff to automatically retry failed requests with increasing delays (set initial delay, number of retries, and multiplier).

## **Widget Nodes** ### **Client Tool Node** **Overview** The Client Tool Node is an action node that allows the agent (via the widget) to execute JavaScript functions on the hosting website. It works by defining a function signature that must be implemented on the client side. When the node is triggered, the agent calls this function and executes it directly within the website. **When to Use** • When you need to trigger frontend actions from the agent.\ • To interact with the hosting website UI or logic. • When integrating the agent with custom JavaScript functionality.\ • For actions that must happen on the client side. **Features** • Executes JavaScript functions on the client (browser).\ • Defines a contract between the agent and frontend through a callable function.\ • Supports configurable tool definitions:\ • Tool Name.\ • Function Description.\ • Input Parameters. • Generates a ready-to-use JavaScript snippet for frontend integration.\ • Allows seamless integration with the hosting application by implementing the generated function. • Enables real-time interaction between the agent and the frontend environment. **Limitations** • Supported only for widget-based calls. **Example Usage & How to Use** Use case:\ Execute frontend-side logic such as triggering client-side actions based on agent decisions. How to use:\ • Define a Tool Name that represents the JavaScript function the frontend will implement.\ • Add a Description to explain what the function should do when called. • Configure the Parameters required by the function:\ • Use Static values for fixed inputs.\ • Use Extracted variables to pass data collected earlier in the flow.\ • Use Dynamic values to pass real-time data from the conversation.

• Once ready, visit widget configuration to find the code snippet including that tool as a function.\ • Review the generated JavaScript snippet that the system provides.\ • Implement the function in your frontend using the same function name and expected parameters.

### Widget UI Node #### Overview The Widget UI Node renders a JSON-defined user interface inside the embedded widget using a safe, predefined set of components. It allows a pathway to display structured information such as text, badges, icons, images, rows, columns, grids, and cards without executing raw HTML, CSS, or JavaScript. When the node is executed: 1. Dynamic pathway variables are resolved. 2. The layout is validated and sanitized. 3. The resulting UI is sent to the web widget. 4. The pathway automatically continues to the next connected node.

#### When to Use Use the Widget UI Node when you need to: * Display structured information inside the widget. * Show a customer summary or confirmation card. * Present extracted pathway variables visually. * Display a status badge or icon. * Organize information using rows, columns, grids, or cards. * Render dynamic UI without allowing arbitrary HTML, CSS, or JavaScript. #### Features * Uses a JSON-based UI configuration. * Supports predefined content components. * Supports nested layout components. * Resolves dynamic pathway variables. * Supports repeating row, column, card, and grid layouts from array pathway variables. * Supports configurable multi-column grid layouts. * Supports conditional style values based on pathway variables. * Supports semantic status color tokens: success, warning, error, and info. * Supports dynamic image URLs from pathway variables. * Provides a live preview in the pathway editor. * Uses whitelisted theme tokens for colors. * Supports safe, whitelisted styling properties. * Rejects unsupported components, properties, and values. * Displays detailed validation errors for invalid configurations. * Automatically continues to the next pathway node after rendering. *** #### Configuration Enter the Widget UI layout as JSON in the node configuration field.

*Figure 2: Widget UI Node configuration containing a JSON layout with nested components and safe styling options*

*** #### Preview A preview of the parsed Widget UI layout is available before the pathway is executed, allowing you to verify: * Component structure. * Nested layouts. * Theme colors. * Font styling. * Spacing. * Width. * Text wrapping. * Repeated array content using values from Test Call Context.

Widget UI Node preview — *Figure 3: Live preview of the configured Widget UI card in the pathway editor.*

*** #### Supported Components Widget UI supports the following predefined components. Select a component below to view its configuration and example. {% tabs %} {% tab title="Text" %} Displays plain text. Required property: * `value` Example: ```json { "component": "text", "value": "Customer information" } ``` {% endtab %} {% tab title="Badge" %} Displays text inside a compact badge. Required property: * `value` Example: ```json { "component": "badge", "value": "Request received", "style": { "color": "primary-foreground", "backgroundColor": "primary", "padding": 8, "borderRadius": 16 } } ``` {% endtab %} {% tab title="Divider" %} Displays a horizontal divider. Example: ```json { "component": "divider" } ``` {% endtab %} {% tab title="Image" %} Displays an image from a valid HTTP or HTTPS URL. Required properties: * `src` * `alt` Example: ```json { "component": "image", "src": "https://example.com/customer-summary.png", "alt": "Customer summary", "style": { "borderRadius": 12, "widthPercent": 100 } } ``` {% endtab %} {% tab title="Icon" %} Displays one of the supported predefined icons. Required property: * `name` Supported icon names: * `check` * `info` * `warning` * `error` Example: ```json { "component": "icon", "name": "check", "style": { "color": "primary" } } ``` {% endtab %} {% endtabs %} *** #### Supported Layouts Layout components organize one or more child components. The `children` array is required and must contain at least one valid Widget UI component. #### Row Displays child components horizontally. The row can wrap its children when there is not enough horizontal space. Example: ```json { "component": "row", "style": { "gap": 12, "widthPercent": 100 }, "children": [ { "component": "icon", "name": "check" }, { "component": "text", "value": "Request completed" } ] } ``` *** #### Column Displays child components vertically. Example: ```json { "component": "column", "style": { "gap": 8, "widthPercent": 100 }, "children": [ { "component": "text", "value": "Customer name" }, { "component": "text", "value": "{{customerName}}" } ] } ``` *** #### Card Displays child components inside a bordered container. Example: ```json { "component": "card", "style": { "backgroundColor": "card", "padding": 16, "gap": 12, "borderRadius": 12, "widthPercent": 100 }, "children": [ { "component": "text", "value": "Customer summary" } ] } ``` #### **Grid** Displays child components in a configurable multi-column grid. Use the `columns` property to define the number of columns. The value must be a positive integer. Example: ```json { "component": "grid", "columns": 2, "style": { "gap": 12, "widthPercent": 100 }, "children": [ { "component": "card", "children": [ { "component": "text", "value": "Flight A" } ] }, { "component": "card", "children": [ { "component": "text", "value": "Flight B" } ] } ] } ``` #### Repeating Layouts The `row`, `column`, `card`, and `grid` layouts can repeat their children for each item in an array pathway variable. Use the `repeat` property with: * `items`: The array pathway variable to iterate over. * `itemName`: The name used to reference the current item. Example: ```json { "component": "column", "repeat": { "items": "{{customers}}", "itemName": "customer" }, "children": [ { "component": "card", "children": [ { "component": "text", "value": "{{customer.name}}" }, { "component": "text", "value": "Requested service: {{customer.requestedService}}" } ] } ] } ``` If `customers` contains multiple items, the card is rendered once for each item. An empty array renders no repeated content. The `repeat` property is supported only on `row`, `column`, and `card`. #### Styling Options Widget UI styling uses a safe, whitelisted schema, and raw CSS, CSS class names, HEX colors, HTML, and JavaScript are not accepted. {% hint style="info" %} Widget UI colors use predefined theme tokens instead of raw color values to remain compatible with white-label themes and different appearance settings. {% endhint %} | Property | Accepted values | Unit or behavior | | ----------------- | -------------------------------------------- | ------------------------------ | | `color` | Supported text color token | Theme-controlled color | | `backgroundColor` | Supported background color token | Theme-controlled background | | `fontSize` | Integer from `8` to `72` | Pixels | | `fontWeight` | `400`, `500`, `600`, or `700` | CSS font weight | | `textAlign` | `left`, `center`, `right`, `start`, or `end` | Text alignment | | `padding` | Integer from `0` to `64` | Pixels | | `gap` | Integer from `0` to `64` | Pixels | | `borderRadius` | Integer from `0` to `64` | Pixels | | `widthPercent` | Integer from `1` to `100` | Percentage of the parent width | #### Supported Text Color Tokens The `color` property accepts: * `foreground` * `muted-foreground` * `primary` * `primary-foreground` * `success` * `warning` * `error` * `info` Example: ```json { "component": "text", "value": "Customer information", "style": { "color": "foreground" } } ``` #### Supported Background Color Tokens The `backgroundColor` property accepts: * `background` * `card` * `primary` * `muted` * `success` * `warning` * `error` * `info` Example: ```json { "component": "card", "style": { "backgroundColor": "card" }, "children": [ { "component": "text", "value": "Customer information" } ] } ``` Theme tokens ensure that Widget UI layouts remain compatible with white-label themes and light or dark appearance settings. #### Styling Notes * Use `gap` primarily with `row`, `column`, `card`, and `grid`. * Use `fontSize`, `fontWeight`, and `textAlign` primarily with text-based components. * Use `widthPercent` instead of a raw CSS width value. * Numeric spacing and size values must be integers. * Unsupported or misspelled properties are rejected. *** #### **Conditional Styling** Widget UI style values can be selected dynamically based on pathway variables. Conditional styling uses a restricted expression format and does not execute arbitrary JavaScript. Supported comparison operators: * `===` * `!==` Both possible results must still be valid values for the selected style property. Example: ```json { "component": "badge", "value": "{{status}}", "style": { "backgroundColor": "{{status === 'departed' ? 'error' : 'info'}}" } } ``` Conditional expressions can also return numeric style values: ```json { "component": "text", "value": "Priority request", "style": { "fontWeight": "{{priority === 'high' ? 700 : 400}}" } } ``` Nested pathway variables are supported: ```json { "component": "card", "style": { "backgroundColor": "{{flight.status === 'delayed' ? 'error' : 'success'}}" }, "children": [ { "component": "text", "value": "{{flight.flightNumber}}" } ] } ``` Conditional styles also work inside repeated layouts, where each repeated item is evaluated using its own item context. #### Dynamic Pathway Variables Widget UI values can reference pathway variables using double curly braces. When the node executes, the variable is replaced with its current pathway value. Example: ```json { "component": "text", "value": "Customer name: {{customerName}}" } ``` Output: ```json Customer name: Sara ``` Inside a repeated layout, fields from the current item can be referenced using dot notation. Example: ```json { "component": "text", "value": "Customer: {{customer.name}} - Service: {{customer.requestedService}}" } ``` Dynamic variables are supported in: * Text values. * Badge values. * Image source URLs. * Image alternative text. * Supported conditional style expressions. Example: ```json { "component": "image", "src": "{{customerImageUrl}}", "alt": "Profile image for {{customerName}}" } ``` {% hint style="info" %} The resolved image source must still be a valid HTTP or HTTPS URL. {% endhint %} *** #### Complete JSON Example The following example displays a styled customer request summary: ```json { "component": "card", "style": { "backgroundColor": "card", "padding": 20, "gap": 14, "borderRadius": 16, "widthPercent": 100 }, "children": [ { "component": "text", "value": "Customer request summary", "style": { "color": "foreground", "fontSize": 22, "fontWeight": 700, "textAlign": "center", "widthPercent": 100 } }, { "component": "divider", "style": { "widthPercent": 100 } }, { "component": "row", "style": { "backgroundColor": "muted", "padding": 12, "gap": 12, "borderRadius": 12, "widthPercent": 100 }, "children": [ { "component": "icon", "name": "check", "style": { "color": "primary" } }, { "component": "column", "style": { "gap": 8, "widthPercent": 100 }, "children": [ { "component": "text", "value": "Customer: {{customerName}}", "style": { "color": "foreground", "fontSize": 18, "fontWeight": 600, "textAlign": "start", "widthPercent": 100 } }, { "component": "badge", "value": "Requested service: {{requestedService}}", "style": { "color": "primary-foreground", "backgroundColor": "primary", "fontSize": 14, "fontWeight": 500, "textAlign": "center", "padding": 8, "borderRadius": 18, "widthPercent": 100 } } ] } ] } ] } ``` *** #### Runtime Rendering During a widget-based call, the Widget UI Node sends the resolved layout to the widget. The widget renders the predefined components using the active platform theme.

Widget UI runtime rendering — Figure 4: Widget UI card rendered inside the public widget with resolved pathway variables.

After the layout is rendered, the pathway automatically continues to the next connected node. *** #### Validation The node configuration validates the JSON syntax, component structure, style properties, and nested layouts. Validation errors identify the invalid property and its location. Example: ``` layout.children[0].style.fontSize must be an integer between 8 and 72 ```

Figure 5: Path-aware validation message for an out-of-range Widget UI font size.

*** #### Limitations * Widget UI rendering is supported only for widget-based calls. * Raw HTML, CSS, CSS class names, JavaScript rendering, and HEX colors are not supported. * Only documented theme color tokens are accepted. * Only predefined components and icons are supported. * Layouts must contain at least one child. * Widget UI layouts support a maximum of 10 nesting levels. * Channel types that do not support Widget UI skip the visual rendering and continue through the pathway. * The `repeat` property is supported only on `row`, `column`, and `card` layouts. * The repeat source must resolve to an array. * Static image sources must use HTTP or HTTPS. Dynamic image sources may use pathway variable expressions, but the resolved value must be a valid HTTP or HTTPS URL. * Grid `columns` must be a positive integer. * Conditional styling supports only the documented restricted expression syntax; arbitrary JavaScript expressions are not supported. ## **Calendar Nodes** ### **Schedule Event Node** **Overview** The Schedule Event Node is an action node used to create and schedule events in a connected calendar (Google Calendar). It sends a calendar invite based on information collected during the conversation. **When to Use** • When the user wants to book a meeting or appointment.\ • For scheduling demos, or sessions. **Limitations** • Requires Google Calendar to be connected. **Example Usage & How to Use** Use case:\ Schedule a meeting or event based on user input, such as booking appointments. How to use:\ • As a best practice add a Default Node before this node to collect and structure all required event data in a consistent format. • In the Default Node, define and extract the following variables:\ • title → Event title.\ • startDate → Date in YYYY-MM-DD format.\ • startTime → Time in HH:MM:SS format.\ • timeZone → IANA time zone format.\ • duration → Event duration in minutes.\ • guests → Comma-separated list of emails.\ • description → Event description. • In the Schedule Event Node, select the appropriate calendar from the connected integrations. • • For each parameter, choose the mode:\ • Extracted Variable (recommended): Map values from the Default Node.\ • Static: Use fixed predefined values when needed.\ • Dynamic: Provide instructions for runtime extraction from the conversation. • Use the result of the action (stored in scheduleEventResult) in downstream nodes if needed (e.g., confirmation messages or follow-up actions).

### **Availability Check Node** **Overview** The Availability Check Node is an action node used to check calendar availability for a specific date in the connected Google Calendar. **When to Use** • Before scheduling events.\ • When suggesting available time slots to users.\ • To avoid scheduling conflicts. **Limitations** • Requires Google Calendar to be connected. **Example Usage & How to Use** Use case:\ Check whether a specific date is available in a connected calendar before scheduling an event (e.g., verifying if a day has free slots before booking a meeting). How to use:\ • As a best practice add a Default Node before this node to collect and structure all required event data in a consistent format. • In the Default Node, define and extract the following variables:\ • date → Date in YYYY-MM-DD format.\ • timeZone → Time zone in IANA format. • In the Availability Check Node, select the appropriate calendar from the connected integrations. • For each parameter, choose the mode:\ • Extracted Variable (recommended): Map values from the Default Node.\ • Static: Use fixed values if the date or time zone is predefined.\ • Dynamic: Allow the agent to determine values at runtime from the conversation. • Use the result of the action (stored in availabilityCheckResult) in downstream if needed (e.g., confirmation messages or follow-up actions).

### Cancel Event Node **Overview** The Cancel Event Node is an action node used to cancel an existing calendar event in the connected Google Calendar. **When to Use** • When the user requests to cancel a scheduled meeting or appointment.\ • In flows that handle booking management or rescheduling. **Limitations** • Requires Google Calendar to be connected. **Example Usage & How to Use** Use case:\ Cancel an existing calendar event based on user-provided details (e.g., a user requests to cancel a scheduled meeting or appointment). How to use: • As a best practice add a Default Node before this node to collect and structure all required event data in a consistent format. • In the Default Node, define and extract the following variables:\ • date → Event date in YYYY-MM-DD format.\ • time → Event time in HH:MM:SS format.\ • duration → Event duration in minutes.\ • timeZone → Time zone in IANA format. • In the Cancel Event Node, select the appropriate calendar from the connected integrations. • For each parameter, choose the mode:\ • Extracted Variable (recommended): Map values from the Default Node.\ • Static: Use fixed values when the event details are predefined.\ • Dynamic: Allow the agent to determine values at runtime from the conversation. • Use the result of the action (stored in cancelEventResult) in downstream nodes if needed (e.g., confirmation messages or follow-up actions).

## **Messaging Nodes** ### **Send SMS Node** **Overview** The Send SMS Node is an action node used to send SMS messages to a user’s phone. It uses Twilio as the SMS provider and requires prior configuration of a phone number before it can be used. **When to Use** • When you need to send notifications via SMS.\ • For sending confirmations (e.g., bookings, OTPs).\ • When users prefer communication via mobile messages.\ • To follow up with users outside the conversation. **Limitations** • Requires Twilio configuration before use.\ • Valid phone numbers must be provided. **Example Usage & How to Use** Use case:\ Send an SMS notification to a user (e.g., appointment confirmation). How to use:\ • As a best practice add a Default Node before this node to collect and structure all required SMS data in a consistent format. • In the Default Node, define and extract the following variables:\ • phoneNumber → Recipient phone number in international format (e.g., +1234567890)\ • message → The SMS content to be sent. • In the Send SMS Node, select the provider (e.g., Twilio). • Select the outbound number that will be used to send the SMS. • For each parameter, choose the mode:\ • Extracted Variable (recommended): Map values from the Default Node\ • Static: Use fixed values if the phone number or message is predefined\ • Dynamic: Allow the agent to determine values at runtime from the conversation. • Use the result of the action (stored in sendSmsResult) in downstream if needed (e.g., confirmation messages or follow-up actions).

### **Send WhatsApp Message Node** **Overview** The Send WhatsApp Message Node is an action node used to send WhatsApp messages to users using pre-approved message templates via Meta (WhatsApp Business API). It allows sending structured and personalized messages during the agent flow. **When to Use** • When you need to send messages via WhatsApp.\ • For notifications, confirmations, and reminders. **Limitations** • Requires Meta Business account integration.\ • Only works with approved WhatsApp templates. **Example Usage & How to Use** Use case:\ Send a WhatsApp message to a user using a predefined template (e.g., order updates). How to use:\ • As a best practice add a Default Node before this node to collect and structure all required WhatsApp message data in a consistent format. • In the Default Node, define and extract the following variables:\ • to → Recipient phone number in international format (e.g., +1234567890)\ • templateParams → Values required for the selected WhatsApp template (if applicable). • In the Send WhatsApp Message Node, select phone number. • Choose the appropriate WhatsApp message template from the available templates. • For each parameter, choose the mode:\ • Extracted Variable (recommended): Map values from the Default Node\ • Static: Use a fixed phone number if predefined\ • Dynamic: Allow the agent to determine values at runtime from the conversation. • Use the result of the action (stored in sendWhatsappMessageResult) in downstream nodes if needed (e.g., confirmation messages or follow-up actions)

### **Send Email Node** **Overview** The Send Email Node is an action node used to send emails to users during the agent’s conversation flow. It requires prior email configuration. **When to Use** • When you need to send information via email.\ • For sending confirmations, reports, or summaries.\ • When users request to receive details in their inbox. **Limitations** • Requires email configuration before use. **Example Usage & How to Use** Use case:\ Send an email to one or more recipients (e.g., follow-ups). How to use:\ • As a best practice add a Default Node before this node to collect and structure all required email data in a consistent format. • In the Default Node, define and extract the following variables:\ • title → Email subject/title\ • recipients → Comma-separated list of email addresses (e.g., , )\ • body → Email content/body. • In the Send Email Node, select the appropriate email provider from the configured integrations. • For each parameter, choose the mode:\ • Extracted Variable (recommended): Map values from the Default Node.\ • Static: Use fixed values if the email content is predefined.\ • Dynamic: Allow the agent to generate values at runtime from the conversation. • Use the result of the action (stored in sendEmailResult) in downstream nodes if needed (e.g., confirmation messages or follow-up actions).

## **Utility Nodes** ### **Decision Node** **Overview** The Decision Node is an action node that automatically selects the next edge in the flow without requiring any user input. It is designed to execute logic instantly—such as routing, evaluating conditions, or extracting variables—without interrupting the conversation. **When to Use** • When you need to route between multiple paths based on existing context.\ • For logic-based decisions that should run immediately.\ • When you want to extract variables without waiting for user input. • At the start of a flow (e.g., after agent transfer) to determine the correct path. **Example Usage & How to Use** Use case:\ Seamlessly transfer a conversation between agents (e.g., from a Support Agent to a Billing Agent) while preserving context, then automatically decide the next step without requiring the user to repeat information. How to use: • Agent A transfers a call to Agent B. • At the start of Agent B’s flow:\ • A Decision Node is used to determine the next step\ • It evaluates previously collected data\ • Routes the flow automatically without asking the user

### **Call Reschedule Node** **Overview** The Call Reschedule Node is an action node responsible for rescheduling a VoIP call based on user input. It allows the agent to reschedule the call using information provided by the user during the conversation. **When to Use** • When a user requests to reschedule a call. • When adjusting call timing based on user availability. **Limitations** • Requires an existing VoIP call to reschedule. • Supported only for VoIP calls. **Example Usage & How to Use** Use case:\ Reschedule an existing call when the user requests a different time (e.g., a user says *“Can we move my call to tomorrow at 3 PM?”* and the system schedule a call accordingly). How to use:\ • As a best practice, add a Default Node before this node to collect and structure all required call rescheduling data in a consistent format. • In the Default Node, define and extract the following variables:\ • date → Date in YYYY-MM-DD format\ • time → Time in HH:MM:SS format (24-hour)\ • timeZone → Time zone in IANA format. • In the Call Reschedule Node, configure the required parameters (date, time, time zone). • For each parameter, choose the mode:\ • Extracted Variable (recommended): Map values from the Default Node.\ • Static: Use fixed values if the email content is predefined.\ • Dynamic: Allow the agent to generate values at runtime from the conversation. • Optionally enable “Remember Call Context” to preserve conversation history and extracted variables for the rescheduled call. • Use the result of the action (stored in callRescheduleResult) in downstream nodes if needed (e.g., confirmation messages or follow-up actions).

### **Trigger Call Node** **Overview** The Trigger Call Node is an action node used to allow a user to trigger or schedule an outbound VoIP call through the conversation. It enables making a call to a specific destination number with provided context while the current agent flow is still executing. **When to Use** • When you need to initiate an outbound call from an agent to a specific number. **Limitations** • Requires VoIP configuration and valid phone number. **Example Usage & How to Use** Use case:\ Trigger a follow-up or outbound call to a user (e.g., after completing a support request, the system initiates a new call from another agent to continue the conversation or handle a different task such as sales or onboarding). How to use:\ • As a best practice, add a Default Node before this node to collect and structure all required call data in a consistent format. • In the Default Node, define and extract the following variables:\ • toNumber → Recipient phone number in international format (e.g., +123456789)\ • dateAndTime → Scheduled date and time in ISO format (optional).\ • timeZone → Time zone in IANA format (optional).\ • callContext → Context or purpose of the call (optional). • In the Trigger Call Node, select the target Agent that will handle the new call. • Configure the parameters:\ • To Number: Required field for the recipient.\ • Schedule At (Optional): Define when the call should be triggered.\ • Call Context (Optional): Provide additional context to guide the receiving agent. • For each parameter, choose the mode:\ • Extracted Variable (recommended): Map values from the Default Node.\ • Static: Use fixed values if known in advance.\ • Dynamic: Allow the agent to determine values at runtime from the conversation. • Use the result of the action (stored in triggerCallResult) in downstream nodes if needed (e.g., confirmation messages or follow-up actions).

### **Schedule Trigger Node** **Overview** The Schedule Trigger Node is an action node used exclusively for text-based calls (such as WhatsApp text calls). In text flows, this node triggers and executes the connected downstream nodes at a specified time interval, allowing for repeated and automated actions. **When to Use** • When you need to repeat an action periodically in a text-based flow. • To send recurring messages (e.g., reminders, updates). • When automating interval-based communication in WhatsApp or chat. **Limitations** • Supported only for text-based calls. **Example Usage & How to Use** Use case:\ Send a WhatsApp message every 60 minutes to a user. How to use: • Configure the Interval (minutes) to control how often the trigger runs. • Optionally set Max Triggers to limit how many times the action executes. • Use this node at the start of a flow to repeatedly initiate downstream actions without user interaction. • The trigger automatically executes connected nodes based on the defined schedule and conditions.

### **Math Node** **Overview** The Math Node is an action node that automatically performs math and string operations on extracted variables without requiring any user input. It evaluates one or more formulas defined as a newline-separated list, then immediately saves the results as in the extracted variables and moves to the next node. **When to Use** * Calculating a value from existing variables (e.g., totals, discounts, durations). * String manipulation, like combining names, checking lengths, or extracting substrings. * When you want to derive a new variable without waiting for user input or LLM-based variable extraction. * To prepare a formatted value for use in a later prompt, condition, or integration node. **Limitations** * Each line must follow the `variableName = expression` format; lines that don't match this format (including comments) are skipped. **Features** * Supports multiple formulas per node — each line is evaluated independently, in order. * Later formulas can reference variables computed by earlier formulas in the same node. * Lines starting with `#` are treated as comments and are skipped during evaluation — useful for documenting what a formula does. * Insert any extracted or context variable into a formula using the **Add Variable** dropdown. * Failed formulas are skipped automatically — a single broken line won't block the rest of the node from executing. **Supported features:** * Basic operations: * Assignments of static values: `variable = 5`, `name = "Jeff"` . * Arithmetic: `+`, `-`, `*`, `/`, `^`, `%`. * Comparisons and logic: `==`, `!=`, `<`, `>`, `and`, `or`, `not,` ternary (`condition ? a : b`). * Generate a random decimal within a range: `random(0, i)` . * Generate a random integer within a range: `randomInt(0, i)` . > Careful: `&&,` `||` and `!` are not supported. Use the `and,` `or, not` keywords intead (e.g. `x = true and false` instead of `x = true && false`) * String operations: * Concatenate strings with `concat()`: `concat(firstName, " ", lastName)` * Get string length with `length()`: `length(name)` * Convert to lowercase with `toLower()`: `toLower("Hello")` → `"hello"` * Convert to uppercase with `toUpper()`: `toUpper("hello")` → `"HELLO"` * Check if a string contains a substring with `contains()`: `contains("cardLimit", "card")` → `true` * Split a string into an array with `split()`: `split("hello world", " ")` → `["hello", "world"]` * Extract a substring with `subset()`: `subset("Hello", index(range(0, 3)))` → `"Hel"` * Array slicing on strings e.g `string = "abc"`, `s1[1:2]` → `"b"` . * Strings can be compared with `==` and `!=` directly. * Replace all occurrences of a string or regular expression within a string:\ `replaceAll(value, pattern, replacement)` .\ example: `replaceAll("32-1222-3232", "-", "")` → `3212223232` . * Regular expressions can be created using the `regex(pattern, flag)` function and used with `replaceAll`.\ example: `replaceAll("John Smith", regex("\s+", "g"), "_")` → `John_Smith` . {% hint style="info" %} Regular expressions have `g` flag automatically enforced. {% endhint %} * Arrays for numeric and string data: * Define an array with square brackets: `prices = [10, 20, 30]`. * Combine arrays or append items `concat()`: `prices = concat([10, 20], [30])` , `otherPrices = concat(prices, [450])` * Get the number of items in an array with `length()`: `length(prices)`. * Sum all numbers in an array with `sum()`: `sum(prices)`. * Access an item by position using brackets, e.g. `prices[0]` for the first item. * Get a range of items with slicing, e.g. `prices[0:1]` for the first two items. * Check if an array contains a value with `contains()`: `contains(financial_questions, "Salary")`→ `true` or `false` * Join an array into a string with `join()`: `join(["a", "b", "c"], "-")` → `"a-b-c"` * Shuffle an array randomly with `shuffle()`: `shuffle(questions)` — returns a new randomly ordered array each time. Useful for random selection. * Filter an array with `filter()`: `filter([1, 2, 3, 4], fn(x) = x > 2)` → `[3, 4]` . * Transform each item with `map()`: `map([1, 2, 3], fn(x) = x * 2)` → `[2, 4, 6]` . {% hint style="info" %} Arrays are 0-indexed (first item's index is 0). {% endhint %} * Objects**:** * Define an object with curly braces: `user = {"name": "John", "age": 30}` * Access a property with dot notation: `user.name` → `"John"` **Reference** The Math Node uses [math.js](https://mathjs.org/docs/index.html) to evaluate formulas. For the full list of supported functions and operators, see the math.js documentation. Note that only a curated subset of math.js functions is available in the Math Node for security reasons — functions involving symbolic computation or file/network access are not supported. **Example** Pathway:

Node Implementation:

Result:

Example of Array manipulation: