feat: improve event bus thread safety and async support

Add thread-safe, async-compatible event bus with read–write locking and
handler dependency ordering. Remove blinker dependency and implement
direct dispatch. Improve type safety, error handling, and deterministic
event synchronization.

Refactor tests to auto-wait for async handlers, ensure clean teardown,
and add comprehensive concurrency coverage. Replace thread-local state
in AgentEvaluator with instance-based locking for correct cross-thread
access. Enhance tracing reliability and event finalization.

lib/crewai/tests/memory/test_external_memory.py

@@ -1,23 +1,36 @@
-from unittest.mock import MagicMock, patch, ANY
+import threading
 from collections import defaultdict
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.memory_events import (
-    MemorySaveStartedEvent,
-    MemorySaveCompletedEvent,
-    MemoryQueryStartedEvent,
-    MemoryQueryCompletedEvent,
-)
+from unittest.mock import ANY, MagicMock, patch
+
 import pytest
 from mem0.memory.main import Memory
 
 from crewai.agent import Agent
 from crewai.crew import Crew, Process
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.memory_events import (
+    MemoryQueryCompletedEvent,
+    MemoryQueryStartedEvent,
+    MemorySaveCompletedEvent,
+    MemorySaveStartedEvent,
+)
 from crewai.memory.external.external_memory import ExternalMemory
 from crewai.memory.external.external_memory_item import ExternalMemoryItem
 from crewai.memory.storage.interface import Storage
 from crewai.task import Task
 
 
+@pytest.fixture(autouse=True)
+def cleanup_event_handlers():
+    """Cleanup event handlers after each test"""
+    yield
+    with crewai_event_bus._rwlock.w_locked():
+        crewai_event_bus._sync_handlers = {}
+        crewai_event_bus._async_handlers = {}
+        crewai_event_bus._handler_dependencies = {}
+        crewai_event_bus._execution_plan_cache = {}
+
+
 @pytest.fixture
 def mock_mem0_memory():
     mock_memory = MagicMock(spec=Memory)
@@ -238,24 +251,26 @@ def test_external_memory_search_events(
     custom_storage, external_memory_with_mocked_config
 ):
     events = defaultdict(list)
+    event_received = threading.Event()
 
     external_memory_with_mocked_config.storage = custom_storage
-    with crewai_event_bus.scoped_handlers():
 
-        @crewai_event_bus.on(MemoryQueryStartedEvent)
-        def on_search_started(source, event):
-            events["MemoryQueryStartedEvent"].append(event)
+    @crewai_event_bus.on(MemoryQueryStartedEvent)
+    def on_search_started(source, event):
+        events["MemoryQueryStartedEvent"].append(event)
 
-        @crewai_event_bus.on(MemoryQueryCompletedEvent)
-        def on_search_completed(source, event):
-            events["MemoryQueryCompletedEvent"].append(event)
+    @crewai_event_bus.on(MemoryQueryCompletedEvent)
+    def on_search_completed(source, event):
+        events["MemoryQueryCompletedEvent"].append(event)
+        event_received.set()
 
-        external_memory_with_mocked_config.search(
-            query="test value",
-            limit=3,
-            score_threshold=0.35,
-        )
+    external_memory_with_mocked_config.search(
+        query="test value",
+        limit=3,
+        score_threshold=0.35,
+    )
 
+    assert event_received.wait(timeout=5), "Timeout waiting for search events"
     assert len(events["MemoryQueryStartedEvent"]) == 1
     assert len(events["MemoryQueryCompletedEvent"]) == 1
 
@@ -300,24 +315,25 @@ def test_external_memory_save_events(
     custom_storage, external_memory_with_mocked_config
 ):
     events = defaultdict(list)
+    event_received = threading.Event()
 
     external_memory_with_mocked_config.storage = custom_storage
 
-    with crewai_event_bus.scoped_handlers():
+    @crewai_event_bus.on(MemorySaveStartedEvent)
+    def on_save_started(source, event):
+        events["MemorySaveStartedEvent"].append(event)
 
-        @crewai_event_bus.on(MemorySaveStartedEvent)
-        def on_save_started(source, event):
-            events["MemorySaveStartedEvent"].append(event)
+    @crewai_event_bus.on(MemorySaveCompletedEvent)
+    def on_save_completed(source, event):
+        events["MemorySaveCompletedEvent"].append(event)
+        event_received.set()
 
-        @crewai_event_bus.on(MemorySaveCompletedEvent)
-        def on_save_completed(source, event):
-            events["MemorySaveCompletedEvent"].append(event)
-
-        external_memory_with_mocked_config.save(
-            value="saving value",
-            metadata={"task": "test_task"},
-        )
+    external_memory_with_mocked_config.save(
+        value="saving value",
+        metadata={"task": "test_task"},
+    )
 
+    assert event_received.wait(timeout=5), "Timeout waiting for save events"
     assert len(events["MemorySaveStartedEvent"]) == 1
     assert len(events["MemorySaveCompletedEvent"]) == 1
 

lib/crewai/tests/memory/test_long_term_memory.py

@@ -1,7 +1,9 @@
+import threading
 from collections import defaultdict
 from unittest.mock import ANY
 
 import pytest
+
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.types.memory_events import (
     MemoryQueryCompletedEvent,
@@ -21,27 +23,37 @@ def long_term_memory():
 
 def test_long_term_memory_save_events(long_term_memory):
     events = defaultdict(list)
+    all_events_received = threading.Event()
 
-    with crewai_event_bus.scoped_handlers():
+    @crewai_event_bus.on(MemorySaveStartedEvent)
+    def on_save_started(source, event):
+        events["MemorySaveStartedEvent"].append(event)
+        if (
+            len(events["MemorySaveStartedEvent"]) == 1
+            and len(events["MemorySaveCompletedEvent"]) == 1
+        ):
+            all_events_received.set()
 
-        @crewai_event_bus.on(MemorySaveStartedEvent)
-        def on_save_started(source, event):
-            events["MemorySaveStartedEvent"].append(event)
+    @crewai_event_bus.on(MemorySaveCompletedEvent)
+    def on_save_completed(source, event):
+        events["MemorySaveCompletedEvent"].append(event)
+        if (
+            len(events["MemorySaveStartedEvent"]) == 1
+            and len(events["MemorySaveCompletedEvent"]) == 1
+        ):
+            all_events_received.set()
 
-        @crewai_event_bus.on(MemorySaveCompletedEvent)
-        def on_save_completed(source, event):
-            events["MemorySaveCompletedEvent"].append(event)
-
-        memory = LongTermMemoryItem(
-            agent="test_agent",
-            task="test_task",
-            expected_output="test_output",
-            datetime="test_datetime",
-            quality=0.5,
-            metadata={"task": "test_task", "quality": 0.5},
-        )
-        long_term_memory.save(memory)
+    memory = LongTermMemoryItem(
+        agent="test_agent",
+        task="test_task",
+        expected_output="test_output",
+        datetime="test_datetime",
+        quality=0.5,
+        metadata={"task": "test_task", "quality": 0.5},
+    )
+    long_term_memory.save(memory)
 
+    assert all_events_received.wait(timeout=5), "Timeout waiting for save events"
     assert len(events["MemorySaveStartedEvent"]) == 1
     assert len(events["MemorySaveCompletedEvent"]) == 1
     assert len(events["MemorySaveFailedEvent"]) == 0
@@ -86,21 +98,31 @@ def test_long_term_memory_save_events(long_term_memory):
 
 def test_long_term_memory_search_events(long_term_memory):
     events = defaultdict(list)
+    all_events_received = threading.Event()
 
-    with crewai_event_bus.scoped_handlers():
+    @crewai_event_bus.on(MemoryQueryStartedEvent)
+    def on_search_started(source, event):
+        events["MemoryQueryStartedEvent"].append(event)
+        if (
+            len(events["MemoryQueryStartedEvent"]) == 1
+            and len(events["MemoryQueryCompletedEvent"]) == 1
+        ):
+            all_events_received.set()
 
-        @crewai_event_bus.on(MemoryQueryStartedEvent)
-        def on_search_started(source, event):
-            events["MemoryQueryStartedEvent"].append(event)
+    @crewai_event_bus.on(MemoryQueryCompletedEvent)
+    def on_search_completed(source, event):
+        events["MemoryQueryCompletedEvent"].append(event)
+        if (
+            len(events["MemoryQueryStartedEvent"]) == 1
+            and len(events["MemoryQueryCompletedEvent"]) == 1
+        ):
+            all_events_received.set()
 
-        @crewai_event_bus.on(MemoryQueryCompletedEvent)
-        def on_search_completed(source, event):
-            events["MemoryQueryCompletedEvent"].append(event)
+    test_query = "test query"
 
-        test_query = "test query"
-
-        long_term_memory.search(test_query, latest_n=5)
+    long_term_memory.search(test_query, latest_n=5)
 
+    assert all_events_received.wait(timeout=5), "Timeout waiting for search events"
     assert len(events["MemoryQueryStartedEvent"]) == 1
     assert len(events["MemoryQueryCompletedEvent"]) == 1
     assert len(events["MemoryQueryFailedEvent"]) == 0

lib/crewai/tests/memory/test_short_term_memory.py

@@ -1,3 +1,4 @@
+import threading
 from collections import defaultdict
 from unittest.mock import ANY, patch
 
@@ -37,24 +38,33 @@ def short_term_memory():
 
 def test_short_term_memory_search_events(short_term_memory):
     events = defaultdict(list)
+    search_started = threading.Event()
+    search_completed = threading.Event()
 
     with patch.object(short_term_memory.storage, "search", return_value=[]):
-        with crewai_event_bus.scoped_handlers():
 
-            @crewai_event_bus.on(MemoryQueryStartedEvent)
-            def on_search_started(source, event):
-                events["MemoryQueryStartedEvent"].append(event)
+        @crewai_event_bus.on(MemoryQueryStartedEvent)
+        def on_search_started(source, event):
+            events["MemoryQueryStartedEvent"].append(event)
+            search_started.set()
 
-            @crewai_event_bus.on(MemoryQueryCompletedEvent)
-            def on_search_completed(source, event):
-                events["MemoryQueryCompletedEvent"].append(event)
+        @crewai_event_bus.on(MemoryQueryCompletedEvent)
+        def on_search_completed(source, event):
+            events["MemoryQueryCompletedEvent"].append(event)
+            search_completed.set()
 
-            # Call the save method
-            short_term_memory.search(
-                query="test value",
-                limit=3,
-                score_threshold=0.35,
-            )
+        short_term_memory.search(
+            query="test value",
+            limit=3,
+            score_threshold=0.35,
+        )
+
+        assert search_started.wait(timeout=2), (
+            "Timeout waiting for search started event"
+        )
+        assert search_completed.wait(timeout=2), (
+            "Timeout waiting for search completed event"
+        )
 
     assert len(events["MemoryQueryStartedEvent"]) == 1
     assert len(events["MemoryQueryCompletedEvent"]) == 1
@@ -98,20 +108,26 @@ def test_short_term_memory_search_events(short_term_memory):
 
 def test_short_term_memory_save_events(short_term_memory):
     events = defaultdict(list)
-    with crewai_event_bus.scoped_handlers():
+    save_started = threading.Event()
+    save_completed = threading.Event()
 
-        @crewai_event_bus.on(MemorySaveStartedEvent)
-        def on_save_started(source, event):
-            events["MemorySaveStartedEvent"].append(event)
+    @crewai_event_bus.on(MemorySaveStartedEvent)
+    def on_save_started(source, event):
+        events["MemorySaveStartedEvent"].append(event)
+        save_started.set()
 
-        @crewai_event_bus.on(MemorySaveCompletedEvent)
-        def on_save_completed(source, event):
-            events["MemorySaveCompletedEvent"].append(event)
+    @crewai_event_bus.on(MemorySaveCompletedEvent)
+    def on_save_completed(source, event):
+        events["MemorySaveCompletedEvent"].append(event)
+        save_completed.set()
 
-        short_term_memory.save(
-            value="test value",
-            metadata={"task": "test_task"},
-        )
+    short_term_memory.save(
+        value="test value",
+        metadata={"task": "test_task"},
+    )
+
+    assert save_started.wait(timeout=2), "Timeout waiting for save started event"
+    assert save_completed.wait(timeout=2), "Timeout waiting for save completed event"
 
     assert len(events["MemorySaveStartedEvent"]) == 1
     assert len(events["MemorySaveCompletedEvent"]) == 1