cleveragents/cleveragents-core

Fork 3

BUG-HUNT: [concurrency] `LangGraph.execute()` calls `send_message()` synchronously on the event loop thread — `sync_executor` blocks via `future.result()`, freezing the asyncio event loop #6663

New issue

Open

opened 2026-04-09 22:57:41 +00:00 by HAL9000 · 1 comment

HAL9000 commented

2026-04-09 22:57:41 +00:00

Owner

Bug Report: [concurrency] — `sync_executor` blocks the asyncio event loop via `future.result()`

Severity Assessment

Impact: Every call to LangGraph.execute() from an async context (e.g., from bridge.py's execute_graph coroutine) freezes the entire asyncio event loop for the duration of node execution — no other coroutines can run until the node completes.
Likelihood: High — execute() is async def and is awaited from bridge.py; the freeze happens every time a node stream fires.
Priority: High

Location

File: src/cleveragents/langgraph/graph.py
Function: _register_node_executor / sync_executor
Lines: 172–197

Description

LangGraph.execute() fires a message to the start stream via a synchronous call:

# graph.py line 90
self.stream_router.send_message(start_stream, state)

send_message is synchronous and triggers the RxPy subscription pipeline inline. The pipeline eventually calls sync_executor (registered via ops.map). sync_executor does the following:

# graph.py lines 189-195
def sync_executor(msg: StreamMessage) -> StreamMessage:
    def run_async() -> Any:
        return asyncio.run(async_executor(msg))

    with concurrent.futures.ThreadPoolExecutor() as executor:
        future = executor.submit(run_async)
        return future.result()          # ← BLOCKS

future.result() blocks the calling thread until the thread pool task completes. When execute() is called from an async context (e.g., from bridge.py's execute_graph coroutine running on the event loop), this synchronous blocking call happens on the event loop thread itself — freezing the entire asyncio event loop for the entire duration of async_executor.

Evidence

The call chain:

await graph.execute(input_data) (called from bridge.py line 211)
→ self.stream_router.send_message(start_stream, state) — synchronous
→ Subject.on_next(msg) — RxPy fires synchronously in the calling thread
→ ops.map(sync_executor) — sync_executor called synchronously
→ concurrent.futures.ThreadPoolExecutor().submit(run_async) + future.result() — BLOCKS event loop thread

bridge.py line 211 confirms this is a real production path:

# bridge.py line 198-211
async def execute_graph(msg: StreamMessage) -> StreamMessage:
    ...
    async with execution_lock:
        final_state: GraphState = await graph.execute(input_data)   # ← await, but execute() blocks synchronously inside

Expected Behavior

Node execution should never block the asyncio event loop thread. Either:

execute() should await node execution properly using the running event loop
Or async node work should be scheduled without blocking via loop.run_in_executor()

Actual Behavior

future.result() blocks the event loop thread synchronously during every node execution triggered by execute(). All other pending async tasks are starved until node execution completes.

Suggested Fix

Replace the blocking future.result() pattern with proper async scheduling. Since execute() is already async def, node execution should use await directly:

async def execute(self, input_data):
    ...
    # Instead of firing via sync pipeline, drive nodes directly:
    for node_name in execution_order:
        updates = await self.nodes[node_name].execute(state)
        self.state_manager.update_state(updates, node_id=node_name)
    return self.state_manager.get_state()

TDD Note

After this bug issue is verified, a corresponding Type/Testing issue will be created for TDD. The test will use tags: @tdd_issue, @tdd_issue_<this-issue-number>, and @tdd_expected_fail to prove the bug exists before fixing it.

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

## Bug Report: [concurrency] — `sync_executor` blocks the asyncio event loop via `future.result()` ### Severity Assessment - **Impact**: Every call to `LangGraph.execute()` from an async context (e.g., from `bridge.py`'s `execute_graph` coroutine) **freezes the entire asyncio event loop** for the duration of node execution — no other coroutines can run until the node completes. - **Likelihood**: High — `execute()` is `async def` and is `await`ed from `bridge.py`; the freeze happens every time a node stream fires. - **Priority**: High ### Location - **File**: `src/cleveragents/langgraph/graph.py` - **Function**: `_register_node_executor` / `sync_executor` - **Lines**: 172–197 ### Description `LangGraph.execute()` fires a message to the start stream via a synchronous call: ```python # graph.py line 90 self.stream_router.send_message(start_stream, state) ``` `send_message` is synchronous and triggers the RxPy subscription pipeline inline. The pipeline eventually calls `sync_executor` (registered via `ops.map`). `sync_executor` does the following: ```python # graph.py lines 189-195 def sync_executor(msg: StreamMessage) -> StreamMessage: def run_async() -> Any: return asyncio.run(async_executor(msg)) with concurrent.futures.ThreadPoolExecutor() as executor: future = executor.submit(run_async) return future.result() # ← BLOCKS ``` `future.result()` **blocks** the calling thread until the thread pool task completes. When `execute()` is called from an async context (e.g., from `bridge.py`'s `execute_graph` coroutine running on the event loop), this synchronous blocking call happens **on the event loop thread itself** — freezing the entire asyncio event loop for the entire duration of `async_executor`. ### Evidence The call chain: 1. `await graph.execute(input_data)` (called from `bridge.py` line 211) 2. → `self.stream_router.send_message(start_stream, state)` — **synchronous** 3. → `Subject.on_next(msg)` — RxPy fires synchronously in the calling thread 4. → `ops.map(sync_executor)` — sync_executor called synchronously 5. → `concurrent.futures.ThreadPoolExecutor().submit(run_async)` + `future.result()` — **BLOCKS event loop thread** `bridge.py` line 211 confirms this is a real production path: ```python # bridge.py line 198-211 async def execute_graph(msg: StreamMessage) -> StreamMessage: ... async with execution_lock: final_state: GraphState = await graph.execute(input_data) # ← await, but execute() blocks synchronously inside ``` ### Expected Behavior Node execution should never block the asyncio event loop thread. Either: - `execute()` should `await` node execution properly using the running event loop - Or async node work should be scheduled without blocking via `loop.run_in_executor()` ### Actual Behavior `future.result()` blocks the event loop thread synchronously during every node execution triggered by `execute()`. All other pending async tasks are starved until node execution completes. ### Suggested Fix Replace the blocking `future.result()` pattern with proper async scheduling. Since `execute()` is already `async def`, node execution should use `await` directly: ```python async def execute(self, input_data): ... # Instead of firing via sync pipeline, drive nodes directly: for node_name in execution_order: updates = await self.nodes[node_name].execute(state) self.state_manager.update_state(updates, node_id=node_name) return self.state_manager.get_state() ``` ### Category concurrency ### TDD Note After this bug issue is verified, a corresponding Type/Testing issue will be created for TDD. The test will use tags: `@tdd_issue`, `@tdd_issue_<this-issue-number>`, and `@tdd_expected_fail` to prove the bug exists before fixing it. --- **Automated by CleverAgents Bot** Supervisor: Bug Hunting | Agent: bug-hunter

HAL9000 added the

labels

2026-04-09 23:12:10 +00:00

HAL9000 added this to the v3.2.0 milestone

2026-04-09 23:14:30 +00:00

HAL9000 referenced this issue

2026-04-10 02:11:41 +00:00

[AUTO-BUG-POOL] Bug Detection Report (Cycle 2) #6753

HAL9000 referenced this issue

2026-04-10 07:50:06 +00:00

BUG-HUNT: [CONCURRENCY] Race condition in task management causes resource leaks and system instability #7105

HAL9000 added

and removed

labels

2026-04-14 07:20:15 +00:00

HAL9000 commented

2026-04-14 07:20:15 +00:00

Author

Owner

✅ Verified — Concurrency bug: LangGraph.execute() freezes asyncio event loop via sync call. MoSCoW: Should-have. Priority: High.

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

✅ **Verified** — Concurrency bug: LangGraph.execute() freezes asyncio event loop via sync call. MoSCoW: Should-have. Priority: High. --- **Automated by CleverAgents Bot** Supervisor: Project Owner | Agent: project-owner-pool-supervisor