Edges

Edges are the routing logic that connects nodes in your MindedJS flows. They determine how your agent moves through the workflow, making intelligent decisions about which path to take based on different conditions and contexts.

What are Edges?

Edges define the transitions between nodes in your flow. Each edge specifies:

• Source - The starting node

• Target - The destination node

• Type - The routing logic type

• Condition - The criteria for taking this path

• Prompt - The prompt for the LLM to make a decision

Edge Types

MindedJS provides three types of edges for different routing scenarios:

Edge Type	Purpose	When to Use
Step Forward	Unconditional	Sequential processing, guaranteed transitions
Prompt Condition	LLM-based	Intelligent routing based on context and content
Logical Condition	Code-based	Deterministic routing based on memory/data

Step Forward Edges

Step forward edges create unconditional transitions between nodes. They're useful for sequential processing where you always want to move to the next step.

- source: Customer Support Request
  target: Support Agent
  type: stepForward

Use Cases: Data transformation pipelines, required validation steps, guaranteed notifications, logging and audit trails.

Prompt Condition Edges

Prompt condition edges use language models to make intelligent routing decisions based on conversation context, memory state, and complex reasoning.

- source: Support Agent
  target: Escalate to Human
  type: promptCondition
  prompt: 'Based on the conversation, should this be escalated to a human agent?'

Context-Aware Routing

- source: Customer Service Bot
  target: VIP Support
  type: promptCondition
  prompt: |
    Should this customer be routed to VIP support?

    Consider:
    - Customer tier: {{memory.customerTier}}
    - Issue severity: {{memory.issueSeverity}}  
    - Previous escalations: {{memory.previousEscalations}}
    - Current sentiment: (analyze from conversation)

Multi-Path Routing

# Route to different specialists based on issue type
- source: Issue Classifier
  target: Technical Support
  type: promptCondition
  prompt: 'Is this a technical/software issue requiring troubleshooting?'

- source: Issue Classifier
  target: Billing Support
  type: promptCondition
  prompt: 'Is this a billing, payment, or account-related issue?'

- source: Issue Classifier
  target: General Support
  type: promptCondition
  prompt: "Is this a general inquiry that doesn't fit other categories?"

Logical Condition Edges

Logical condition edges use JavaScript expressions to make deterministic routing decisions based on memory state, providing precise control over flow logic. Prefer using prompt condition edges, unless you need an exact match of an ouput of a previous node.

- source: Order Lookup
  target: Refund Processing
  type: logicalCondition
  condition: "state.memory.orderStatus === 'delivered'"

How Condition Expressions Work

The condition field accepts a JavaScript expression that will be evaluated to determine if the edge should be taken. The expression has access to the current agent state through the state variable and the previous node's result through the lastNodeResult variable.

The condition is automatically wrapped in a function that provides the state and lastNodeResult result context:

// Your condition: state.memory.orderStatus === 'delivered'
// Becomes:
(function ({ state, lastNodeResult }) {
  return state.memory.orderStatus === 'delivered';
});

// Your condition: lastNodeResult.price > 100
// Becomes:
(function ({ state, lastNodeResult }) {
  return lastNodeResult.price > 100;
});

Supported Expression Types

Simple Comparisons

# Equality check
condition: "state.memory.status === 'active'"

# Numeric comparison
condition: "state.memory.orderValue > 1000"

# String comparison
condition: "state.memory.customerTier !== 'basic'"

# Boolean check
condition: "state.memory.isVerified"
condition: "!state.memory.hasErrors"

Complex Expressions

# Multiple conditions with AND
condition: "state.memory.orderValue > 500 && state.memory.customerAge < 30"

# OR conditions
condition: "state.memory.priority === 'high' || state.memory.customerTier === 'vip'"

# Nested property access
condition: "state.memory.order.items.length > 5"

# Array methods
condition: "state.memory.tags.includes('urgent')"

# String methods
condition: "state.memory.email.endsWith('@company.com')"

# Combining state and lastNodeResult
condition: "lastNodeResult.status === 'success' && state.memory.retryCount === 0"

# lastNodeResult result with fallback
condition: "(lastNodeResult?.productName || state.memory.defaultProduct) === 'iPhone 15'"

Advanced JavaScript Operations

# Ternary operators
condition: "state.memory.score > 80 ? state.memory.level === 'expert' : state.memory.level === 'beginner'"

# Date comparisons
condition: "new Date(state.memory.orderDate) < new Date()"

# Regular expressions
condition: "/^[A-Z]{2}\\d{4}$/.test(state.memory.orderId)"

# Math operations
condition: "Math.abs(state.memory.temperature - 72) < 5"

# JSON operations
condition: "JSON.parse(state.memory.configString).enabled === true"

Available Context

Your condition expressions have access to:

• state: The full agent state object (access as state.memory, state.messages, etc.)

• lastNodeResult: The result from the previous node in the flow

• Standard JavaScript globals: Math, Date, JSON, console

• String/Array/Object methods: All standard JavaScript methods

Accessing State Properties

# Access memory through state
condition: "state.memory.orderStatus === 'pending'"

# Access messages
condition: "state.messages.length > 10"

# Access other state properties
condition: "state.conversationId && state.memory.isAuthenticated"

Accessing Previous Node Results

The lastNodeResult object provides access to the result of the last executed node in the flow. This is particularly useful when you need to route based on what the previous operator or tool returned.

# Route based on operator output
- source: Search Products
  target: Show Results
  type: logicalCondition
  condition: 'lastNodeResult && lastNodeResult.productCount > 0'

# Route based on tool result
- source: Validate Order
  target: Process Payment
  type: logicalCondition
  condition: "lastNodeResult.status === 'valid'"

# Check specific fields from operator outputSchema
- source: Extract Customer Data
  target: VIP Handler
  type: logicalCondition
  condition: "lastNodeResult.customerTier === 'premium'"

How lastNodeResult Works

MindedJS automatically extracts and normalizes results from different node types:

• Operator (Browser Task) nodes: Extracts from outputSchema fields

• Tool nodes: Extracts the result property returned by the tool

• RPA nodes: Extracts collected data from RPA steps

• App Tool nodes: Extracts the tool execution result

Example with Operator:

# Operator node with outputSchema
- name: search-amazon
  type: browserTask
  displayName: Search Amazon
  prompt: Search for iPhone 15 on Amazon and extract the price
  outputSchema:
    - name: productName
      type: string
    - name: price
      type: number

# Next node with logical condition using lastNodeResult
- source: search-amazon
  target: High Price Handler
  type: logicalCondition
  condition: 'lastNodeResult.price > 1000'

- source: search-amazon
  target: Low Price Handler
  type: logicalCondition
  condition: 'lastNodeResult.price <= 1000'

Example with Tool:

// Tool that returns a result
const validateOrderTool: Tool = {
  name: 'validateOrder',
  execute: async ({ input, state }) => {
    return {
      result: {
        status: 'valid',
        orderId: '12345',
        total: 299.99,
      },
    };
  },
};

# Route based on tool result
- source: Validate Order Tool
  target: Process Payment
  type: logicalCondition
  condition: "lastNodeResult.status === 'valid' && lastNodeResult.total < 500"

Safety Checks:

Always check if lastNodeResult exists before accessing its properties:

# Safe condition with null check
condition: "lastNodeResult && lastNodeResult.status === 'success'"

# Alternative with optional chaining syntax
condition: "lastNodeResult?.productName === 'iPhone 15'"

Example: Using lastNodeResult After a Tool

When a tool executes and returns a result, you can route based on that result using logical conditions. Here's a complete example with the refundOrder tool:

Tool Implementation:

const refundOrderTool: Tool<typeof schema, Memory> = {
  name: 'refundOrder',
  description: 'Refund order',
  input: schema,
  execute: async ({ input, state }) => {
    return {
      result: {
        status: 'success', // or 'failure'
        refundAmount: 100,
      },
    };
  },
};

Flow Configuration with Logical Conditions:

edges:
  - source: refundOrder
    target: Success
    type: logicalCondition
    condition: "lastNodeResult.status === 'success'"

  - source: refundOrder
    target: Failure
    type: logicalCondition
    condition: "else"

In this example, the tool returns a result object with a status property. The edges then route to different nodes based on whether the refund was successful or failed.

Example: Using lastNodeResult After an Operator

For Operator (Browser Task) nodes, you need to define the output schema first, then you can route based on the operator's result.

Step 1: Configure Operator Output Schema

In your operator node, add an output schema field to capture the result:

• Field name: result

• Field type: Number

• Description: 0 = failure, 1 = success

Step 2: Configure Edges with Logical Conditions

edges:
  - source: Operator
    target: Success
    type: logicalCondition
    condition: 'lastNodeResult.result === 1'

  - source: Operator
    target: Failure
    type: logicalCondition
    condition: 'lastNodeResult.result === 0'

The operator will extract the result value according to the prompt and output schema, and the edges will route based on whether the result is 1 (success) or 0 (failure).

Note: For security, the following are NOT available:

• process, require, global, Buffer

• File system or network operations

• Module imports

Memory-Based Routing

# Route based on customer tier
- source: Customer Routing
  target: Premium Support
  type: logicalCondition
  condition: "state.memory.customerTier === 'premium'"

# Route based on order value
- source: Order Processing
  target: Manual Review
  type: logicalCondition
  condition: 'state.memory.orderValue > 1000'

Complex Logic Conditions

# Multiple conditions with AND logic
- source: Payment Processor
  target: Fraud Check
  type: logicalCondition
  condition: |
    state.memory.orderValue > 500 && 
    state.memory.customerAge < 30 &&
    state.memory.shippingCountry !== state.memory.billingCountry

# Date-based conditions
- source: Order Validator
  target: Late Order Handler
  type: logicalCondition
  condition: |
    (Date.now() - new Date(state.memory.orderDate).getTime()) / (1000 * 60 * 60 * 24) > 30

Debugging Logical Conditions

For comprehensive debugging of logical conditions, see the Debugging Guide.

Edge Evaluation Order

When multiple edges exist from the same source node, MindedJS evaluates them by edge type priority, not declaration order:

Priority System

Priority	Edge Type	Behavior
1st	stepForward	Always executes first (max 1 per source)
2nd	logicalCondition	Executes if no step forward edge
3rd	promptCondition	Executes if no step forward and logical conditions fail

# Priority-based evaluation regardless of declaration order
edges:
  - source: Decision Node
    target: AI Router # 3rd priority: Only if logical fails
    type: promptCondition
    prompt: 'Which handler should process this request?'

  - source: Decision Node
    target: Default Handler # 1st priority: Always executes
    type: stepForward

  - source: Decision Node
    target: High Priority # 2nd priority: Checked if no stepForward are present
    type: logicalCondition
    condition: "state.memory.priority === 'high'"

Logical Condition Order

Within logical condition edges from the same source, evaluation follows declaration order:

edges:
  # Logical conditions evaluated in declaration order: 1 -> 2 -> 3
  - source: Order Processor
    target: VIP Handler # 1st: Checked first
    type: logicalCondition
    condition: "state.memory.customerTier === 'vip'"

  - source: Order Processor
    target: Large Order # 2nd: Checked if VIP fails
    type: logicalCondition
    condition: 'state.memory.orderValue > 1000'

  - source: Order Processor
    target: Standard Handler # 3rd: Checked if both above fail
    type: logicalCondition
    condition: 'true' # Fallback condition

Mixed Edge Example

edges:
  # This stepForward will ALWAYS execute first, regardless of order
  - source: Payment Processor
    target: Success Page
    type: stepForward

  # These will never execute because stepForward takes priority
  - source: Payment Processor
    target: Error Handler
    type: logicalCondition
    condition: "state.memory.status === 'error'"

  - source: Payment Processor
    target: AI Router
    type: promptCondition
    prompt: 'Should we route to error handling?'

Advanced Patterns

Fallback Chains

When you have multiple logicalCondition edges from the same source, you can define a final fallback edge by using condition: "else". This fallback edge is taken only if none of the previous conditions evaluate to true.

# Try specific handlers first, fall back to general
- source: Issue Classifier
  target: Billing Specialist
  type: logicalCondition
  condition: "state.memory.issueType === 'billing'"

- source: Issue Classifier
  target: General Support
  type: logicalCondition
  condition: "else"

Error Handling

- source: Payment Processor
  target: Success Handler
  type: logicalCondition
  condition: "state.memory.paymentStatus === 'success'"

- source: Payment Processor
  target: Failure Handler
  type: logicalCondition
  condition: "state.memory.paymentStatus === 'failed' || state.memory.retryCount >= 3"

Next Steps

• Tools - Build powerful functions that your edges can route to

• Memory Types - Design state that supports effective routing

• Implementation Examples - See complete edge examples

Master edges to create intelligent, responsive flows that adapt to any situation! 🔄