cleveragents/cleveragents-core

Fork 3

BUG-HUNT: [boundary] GraphExecutor._follow_chained_edges infinite loop on non-router graph cycles #7771

New issue

Open

opened 2026-04-12 03:30:47 +00:00 by HAL9000 · 3 comments

HAL9000 commented

2026-04-12 03:30:47 +00:00

Owner

Bug Report: Boundary — `GraphExecutor._follow_chained_edges` Infinite Loop on Non-Router Graph Cycles

Severity Assessment

Impact: A graph configuration with a cycle that does not pass through the message_router node causes _follow_chained_edges to loop forever, hanging the entire execution thread with no way to escape.
Likelihood: Medium — requires a cycle in chained (non-router) edges, which can occur in misconfigured graphs or adversarial configs.
Priority: High

Location

File: src/cleveragents/reactive/graph_executor.py
Function/Class: GraphExecutor._follow_chained_edges
Lines: 261–294

Description

The _follow_chained_edges static method follows a while next_node: loop that terminates only on three conditions:

next_node == "end"
router_node in chained_targets (loops back to the message_router)
not chained_targets (dead end)

There is no visited-node tracking and no iteration cap. If the graph contains a cycle among non-router, non-end nodes (e.g., node A points to node B and node B points back to node A), the loop runs forever:

next_node = A -> chained_targets = [B] -> next_node = B
next_node = B -> chained_targets = [A] -> next_node = A
... infinite

Note: the outer execute() loop has a max_iterations cap (line 54), but _follow_chained_edges is called within a single outer iteration. The outer cap does not bound the inner while loop.

Evidence

# src/cleveragents/reactive/graph_executor.py lines 275-293
@staticmethod
def _follow_chained_edges(
    next_targets, current_message, context, node_actor_map,
    agents, router_node, select_targets_fn
):
    next_node = next_targets[0]
    while next_node:                      # <-- no visited set, no iteration cap
        if next_node == "end":
            return current_message, True
        next_actor = node_actor_map.get(next_node, next_node)
        next_agent = agents.get(next_actor)
        if next_agent is not None:
            result = GraphExecutor._invoke_agent(next_agent, current_message, context)
            current_message = result if result else current_message
        chained_targets = select_targets_fn(next_node)
        if router_node in chained_targets:   # exits if router in targets
            return current_message, False
        if "end" in chained_targets:         # exits on 'end'
            return current_message, True
        if not chained_targets:              # exits on dead end
            return current_message, False
        next_node = chained_targets[0]       # <-- no cycle check here
    return current_message, False

Example infinite cycle configuration:

nodes:
  router: {type: message_router, rules: [...]}
  node_a: {type: actor, actor: agent_a}
  node_b: {type: actor, actor: agent_b}
edges:
  - {source: router, target: node_a}
  - {source: node_a, target: node_b}   # node_a -> node_b
  - {source: node_b, target: node_a}   # node_b -> node_a (cycle!)

When node_a is processed and _follow_chained_edges is called with next_targets=["node_b"], the while loop enters an infinite cycle between node_b and node_a.

Expected Behavior

The method should detect visited nodes and terminate with an appropriate error or log-and-return after visiting a node a second time.

Actual Behavior

The method loops infinitely, hanging the execution thread permanently.

Suggested Fix

@staticmethod
def _follow_chained_edges(
    next_targets, current_message, context, node_actor_map,
    agents, router_node, select_targets_fn,
    max_hops: int = 50,  # safety cap
):
    next_node = next_targets[0]
    visited: set[str] = set()
    hops = 0
    while next_node:
        if next_node in visited:
            logger.warning("Cycle detected in chained edges at node '%s'", next_node)
            return current_message, False
        if hops >= max_hops:
            logger.warning("Max chained edge hops (%d) exceeded", max_hops)
            return current_message, False
        visited.add(next_node)
        hops += 1
        # ... rest of existing logic

TDD Note

After this bug issue is verified, a corresponding Type/Testing issue will be created for TDD.

Automated by CleverAgents Bot
Supervisor: Bug Hunting | Agent: bug-hunter

## Bug Report: Boundary — `GraphExecutor._follow_chained_edges` Infinite Loop on Non-Router Graph Cycles ### Severity Assessment - **Impact**: A graph configuration with a cycle that does not pass through the message_router node causes `_follow_chained_edges` to loop forever, hanging the entire execution thread with no way to escape. - **Likelihood**: Medium — requires a cycle in chained (non-router) edges, which can occur in misconfigured graphs or adversarial configs. - **Priority**: High ### Location - **File**: `src/cleveragents/reactive/graph_executor.py` - **Function/Class**: `GraphExecutor._follow_chained_edges` - **Lines**: 261–294 ### Description The `_follow_chained_edges` static method follows a `while next_node:` loop that terminates only on three conditions: 1. `next_node == "end"` 2. `router_node in chained_targets` (loops back to the message_router) 3. `not chained_targets` (dead end) There is no visited-node tracking and no iteration cap. If the graph contains a cycle among non-router, non-end nodes (e.g., node A points to node B and node B points back to node A), the loop runs forever: - `next_node = A` -> chained_targets = [B] -> next_node = B - `next_node = B` -> chained_targets = [A] -> next_node = A - ... infinite Note: the outer `execute()` loop has a `max_iterations` cap (line 54), but `_follow_chained_edges` is called *within* a single outer iteration. The outer cap does not bound the inner `while` loop. ### Evidence ```python # src/cleveragents/reactive/graph_executor.py lines 275-293 @staticmethod def _follow_chained_edges( next_targets, current_message, context, node_actor_map, agents, router_node, select_targets_fn ): next_node = next_targets[0] while next_node: # <-- no visited set, no iteration cap if next_node == "end": return current_message, True next_actor = node_actor_map.get(next_node, next_node) next_agent = agents.get(next_actor) if next_agent is not None: result = GraphExecutor._invoke_agent(next_agent, current_message, context) current_message = result if result else current_message chained_targets = select_targets_fn(next_node) if router_node in chained_targets: # exits if router in targets return current_message, False if "end" in chained_targets: # exits on 'end' return current_message, True if not chained_targets: # exits on dead end return current_message, False next_node = chained_targets[0] # <-- no cycle check here return current_message, False ``` **Example infinite cycle configuration:** ```yaml nodes: router: {type: message_router, rules: [...]} node_a: {type: actor, actor: agent_a} node_b: {type: actor, actor: agent_b} edges: - {source: router, target: node_a} - {source: node_a, target: node_b} # node_a -> node_b - {source: node_b, target: node_a} # node_b -> node_a (cycle!) ``` When `node_a` is processed and `_follow_chained_edges` is called with `next_targets=["node_b"]`, the while loop enters an infinite cycle between `node_b` and `node_a`. ### Expected Behavior The method should detect visited nodes and terminate with an appropriate error or log-and-return after visiting a node a second time. ### Actual Behavior The method loops infinitely, hanging the execution thread permanently. ### Suggested Fix ```python @staticmethod def _follow_chained_edges( next_targets, current_message, context, node_actor_map, agents, router_node, select_targets_fn, max_hops: int = 50, # safety cap ): next_node = next_targets[0] visited: set[str] = set() hops = 0 while next_node: if next_node in visited: logger.warning("Cycle detected in chained edges at node '%s'", next_node) return current_message, False if hops >= max_hops: logger.warning("Max chained edge hops (%d) exceeded", max_hops) return current_message, False visited.add(next_node) hops += 1 # ... rest of existing logic ``` ### Category boundary ### TDD Note After this bug issue is verified, a corresponding Type/Testing issue will be created for TDD. --- **Automated by CleverAgents Bot** Supervisor: Bug Hunting | Agent: bug-hunter

HAL9000 added this to the v3.2.0 milestone

2026-04-12 03:46:16 +00:00

HAL9000 referenced this issue

2026-04-12 03:47:56 +00:00

[AUTO-PROJ-OWN] Project Owner Report (Cycle 1) #7724

HAL9000 added the

labels

2026-04-12 05:47:53 +00:00

freemo added the

Type

Bug

label

2026-04-12 18:33:37 +00:00

HAL9000 added

and removed

labels

2026-04-14 05:58:17 +00:00

HAL9000 commented

2026-04-14 05:58:17 +00:00

Author

Owner

✅ Verified — Critical bug: GraphExecutor can infinite loop on graph cycles. MoSCoW: Must-have. Priority: High — can hang execution.

Automated by CleverAgents Bot
Supervisor: Project Owner | Agent: project-owner-pool-supervisor

✅ **Verified** — Critical bug: GraphExecutor can infinite loop on graph cycles. MoSCoW: Must-have. Priority: High — can hang execution. --- **Automated by CleverAgents Bot** Supervisor: Project Owner | Agent: project-owner-pool-supervisor

HAL9000 commented

2026-04-14 06:11:35 +00:00

Author

Owner

✅ Verified — Critical bug: GraphExecutor can infinite loop on graph cycles. MoSCoW: Must-have. Priority: High — can hang execution.

Automated by CleverAgents Bot
Supervisor: Project Owner | Agent: project-owner-pool-supervisor