Error executing memory callback for task X

[azulaaGy]

i'm getting this error

[14:05:06] ERROR    [14:05:06] **agents.py:633 ERROR Error executing memory callback for task 0: There is no current event loop in thread      agents.py:633**
                    'ScriptRunner.scriptThread'.
C:\Users\david\AppData\Local\Programs\Python\Python313\Lib\site-packages\rich\text.py:144: ResourceWarning: unclosed database in <sqlite3.Connection object at 0x00000265F93F84F0>
  def __init__(
ResourceWarning: Enable tracemalloc to get the object allocation traceback
           ERROR    [14:05:06] agents.py:634 ERROR There is no current event loop in thread 'ScriptRunner.scriptThread'.                     agents.py:634
                    ╭───────────────────────────────────────── Traceback (most recent call last)───────────────╮ 
                    │ C:\Users\david\AppData\Local\Programs\Python\Python313\Lib\site-packages\praisonaiagents\agents\agents.py:626 in     
                    │ run_task                                                                                                                                                                                        
                    │                                                                                                                                                                                                       
                    │   623 │   │   │   │   │   task.status = "completed"                                                                                                                        
                    │   624 │   │   │   │   │   # Run execute_callback for memory operations                                                                                      
                    │   625 │   │   │   │   │   try:                                                                                                                                                            
                    │ ❱ 626 │   │   │   │   │   │   if asyncio.get_event_loop().is_running():                                                                                                      
                    │   627 │   │   │   │   │   │   │   asyncio.create_task(task.execute_callback(task_output))                                                               
                    │   628 │   │   │   │   │   │   else:                                                                                                                                                     
                    │   629 │   │   │   │   │   │   │   loop = asyncio.new_event_loop()                                                                                                  
                    │                                                                                                                                                                                                      
                    │ C:\Users\david\AppData\Local\Programs\Python\Python313\Lib\asyncio\events.py:716 in get_event_loop                            
                    │                                                                                                                                                                                                      
                    │   713 │   │   │   self.set_event_loop(self.new_event_loop())                                                                                                          
                    │   714 │   │                                                                                                                                                                                     
                    │   715 │   │   if self._local._loop is None:                                                                                                                                       
                    │ ❱ 716 │   │   │   raise RuntimeError('There is no current event loop in thread %r.'                                                                     
                    │   717 │   │   │   │   │   │   │      % threading.current_thread().name)                                                                                           
                    │   718 │   │                                                                                                                                                                                     
                    │   719 │   │   return self._local._loop                                                                                                                                              
                    ╰───────────────────────────────────────────────────────────────────────────╯ 
                    RuntimeError: There is no current event loop in thread 'ScriptRunner.scriptThread'.

for python 3.13. i tried running the same code with python 3.10 and the error is the same except i'm also getting this warning despite praisonaiagents[memory] already being installed:

WARNING  [12:47:21] memory.py:18 WARNING To use memory features, please run: pip install "praisonaiagents[memory]"    

[MervinPraison]

@claude review this request

[claude]

Claude finished @MervinPraison's task —— View job

---

Reviewing Memory Callback Error

Analyzing the asyncio event loop error in memory callback execution.

Todo List

• Read and analyze agents.py file around line 626
• Check memory.py for installation warning logic
• Review asyncio event loop handling
• Provide recommendations for fixes

Analysis Results

I've identified the root cause of both issues reported:

1. Asyncio Event Loop Error (agents.py:446, 768)

Problem: The error occurs in two locations in agents.py:

• Line 446 (async method arun_task)
• Line 768 (sync method run_task)

Root Cause: The code uses the deprecated asyncio.get_event_loop() method which doesn't work properly in non-main threads (like 'ScriptRunner.scriptThread' from Streamlit):

if asyncio.get_event_loop().is_running():
    asyncio.create_task(task.callback(task_output))

Issues:

• asyncio.get_event_loop() is deprecated in Python 3.10+ and raises RuntimeError when called from non-main threads
• The logic assumes an event loop exists, but in Streamlit threads there might not be one
• Missing proper exception handling for the RuntimeError

2. Memory Installation Warning (task.py:51-54)

Problem: The warning appears despite having praisonaiagents[memory] installed.

Root Cause: The import check in task.py is too strict:

try:
    from ..memory.memory import Memory
    MEMORY_AVAILABLE = True
except ImportError:
    raise ImportError(
        "Memory features requested in Task but memory dependencies not installed. "
        "Please install with: pip install \"praisonaiagents[memory]\""
    )

Issue: This fails if any sub-dependency of the memory module is missing (like chromadb, openai, mem0, etc.), even if the main package is installed.

Recommendations

Fix 1: Replace deprecated asyncio.get_event_loop()

Replace the problematic code with Python 3.7+ compatible approach:

# Instead of:
if asyncio.get_event_loop().is_running():
    asyncio.create_task(task.callback(task_output))

# Use:
try:
    loop = asyncio.get_running_loop()
    loop.create_task(task.callback(task_output))
except RuntimeError:
    # No event loop running, create new one
    asyncio.run(task.callback(task_output))

Fix 2: Improve memory dependency check

Make the memory import check more granular and informative:

try:
    from ..memory.memory import Memory
    MEMORY_AVAILABLE = True
except ImportError as e:
    logger.warning(f"Memory dependency missing: {e}")
    logger.warning("Some memory features may not work. Install with: pip install \"praisonaiagents[memory]\"")
    MEMORY_AVAILABLE = False
    # Don't raise - let it continue with limited functionality

Fix 3: Add proper thread-safe event loop handling

For Streamlit and other non-main thread environments, implement thread-safe callback execution.

Summary

Issue Analysis Complete: The user is experiencing two related but separate issues:

1. Primary Issue: Asyncio event loop error due to deprecated asyncio.get_event_loop() usage in non-main threads (Streamlit)
2. Secondary Issue: Misleading memory installation warning caused by strict dependency checking

Both issues stem from compatibility problems with Python 3.10+ and threaded environments. The recommended fixes address the root causes and will resolve both the RuntimeError and the false warning message.

[MervinPraison]

@claude do we need to make any change to fix this. if so propose those changes.

[claude]

Claude finished @MervinPraison's task —— View job • claude/issue-307-20250528_161908 • Create PR ➔

---

✅ Fixed Asyncio Event Loop Error in Memory Callbacks

---

Todo List

• Read current agents.py file to locate the problematic asyncio code
• Read task.py file to understand memory dependency checking
• Fix asyncio event loop handling in agents.py
• Fix memory dependency warning in task.py
• Test changes and commit to branch
• Create pull request

Problem Analysis

1. Asyncio Event Loop Error (Lines 446 & 768 in agents.py)

The code used deprecated asyncio.get_event_loop() which fails in non-main threads like Streamlit's 'ScriptRunner.scriptThread'.

2. Memory Dependency Warning (Lines 51-54 in task.py)

The import check was too strict and raised exceptions instead of graceful warnings.

✅ Fixes Implemented

1. Fixed Asyncio Event Loop Error

• Replaced deprecated asyncio.get_event_loop() with asyncio.get_running_loop()
• Added proper RuntimeError handling for when no event loop exists in non-main threads
• Uses asyncio.run() to create new event loop when needed
• Compatible with Python 3.10+ and threaded environments like Streamlit

2. Fixed Memory Dependency Warning

• Changed from raising ImportError to logging warnings
• Gracefully continues with limited functionality when memory dependencies are missing
• More informative error messages for debugging

Changes Made

• agents.py: Updated both async (arun_task) and sync (run_task) methods to use modern asyncio patterns
• task.py: Improved memory dependency checking to be more user-friendly

These changes should resolve both the RuntimeError in Streamlit and the false memory dependency warnings.

---