fix: resolve critical async safety issues identified by code reviewers

- Fix threading.Lock used with async with in Process class (issue #1289)
  * Replace sync lock creation with lazy async lock initialization
  * Prevents runtime AttributeError in aworkflow method
- Improve thread safety in AsyncPostgres lazy lock initialization
  * Add double-checked locking pattern to prevent race conditions
  * Ensures only one asyncio.Lock instance created across coroutines
- Remove redundant asyncio import in async_postgres.py
- Improve exception chaining for better error diagnostics

Addresses critical issues raised by Gemini, Qodo, CodeRabbit reviewers.

Co-authored-by: Mervin Praison <MervinPraison@users.noreply.github.com>

Author: praisonai-triage-agent[bot]

src/praisonai-agents/praisonaiagents/process/process.py

@@ -45,7 +45,7 @@ def __init__(
         self.workflow_timeout = workflow_timeout
         self.task_retry_counter: Dict[str, int] = {} # Initialize retry counter
         self.workflow_finished = False # ADDED: Workflow finished flag
-        self._state_lock = threading.Lock() # Thread lock for shared state protection
+        self._state_lock = None # Lazy-initialized async lock for shared state protection
 
         # Resolve verbose from output= param (takes precedence) or legacy verbose= param
         if output is not None:
@@ -597,6 +597,8 @@ async def aworkflow(self) -> AsyncGenerator[str, None]:
                     break
 
             # Reset completed task to "not started" so it can run again (atomic operation)
+            if self._state_lock is None:
+                self._state_lock = asyncio.Lock()
             async with self._state_lock:
                 if self.tasks[task_id].status == "completed":
                     # Never reset loop tasks, decision tasks, or their subtasks if rerun is False

src/praisonai/praisonai/persistence/conversation/async_postgres.py

@@ -8,6 +8,7 @@
 import asyncio
 import json
 import logging
+import threading
 import time
 from typing import List, Optional
 
@@ -64,24 +65,26 @@ def __init__(
         self._pool = None
         self._initialized = False
         self._init_lock = None
+        self._lock_creation_lock = threading.Lock()
 
     async def init(self):
         """Initialize connection pool and create tables."""
         if self._init_lock is None:
-            import asyncio
-            self._init_lock = asyncio.Lock()
+            with self._lock_creation_lock:
+                if self._init_lock is None:  # Double-checked locking
+                    self._init_lock = asyncio.Lock()
 
         async with self._init_lock:
             if self._initialized:
                 return
 
             try:
                 import asyncpg
-            except ImportError:
+            except ImportError as err:
                 raise ImportError(
                     "asyncpg is required for async PostgreSQL support. "
                     "Install with: pip install asyncpg"
-                )
+                ) from err
 
             if self.url:
                 self._pool = await asyncpg.create_pool(self.url, min_size=1, max_size=self.pool_size)