fix: avoid acquire_sync deadlock under running event loop

Agent-Logs-Url: https://github.com/MervinPraison/PraisonAI/sessions/c9e7c913-a80d-474a-bd5d-731c129ad614

Co-authored-by: MervinPraison <454862+MervinPraison@users.noreply.github.com>

Author: Copilot

src/praisonai-agents/praisonaiagents/agent/concurrency.py

@@ -86,25 +86,19 @@ async def acquire(self, agent_name: str) -> None:
     def acquire_sync(self, agent_name: str) -> None:
         """Synchronous acquire — for non-async code paths.
         
-        Uses a proper sync-to-async bridge to avoid private attribute manipulation.
         Prefer async acquire() when possible.
         """
         sem = self._get_semaphore(agent_name)
         if sem is None:
             return
         try:
             asyncio.get_running_loop()
-            # We're inside an async loop — cannot block. Run acquire in a thread
-            # with its own loop to go through the semaphore's proper acquire path.
-            import concurrent.futures
-            def _acquire_in_new_loop():
-                loop = asyncio.new_event_loop()
-                try:
-                    loop.run_until_complete(sem.acquire())
-                finally:
-                    loop.close()
-            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
-                pool.submit(_acquire_in_new_loop).result(timeout=30)
+            # Running loop in current thread: blocking here can deadlock.
+            logger.warning(
+                f"acquire_sync('{agent_name}') called with a running event loop; "
+                "use async acquire() in async contexts."
+            )
+            return
         except RuntimeError:
             # No running loop — safe to create one
             loop = asyncio.new_event_loop()

src/praisonai-agents/tests/unit/agent/test_agent_concurrency.py

@@ -106,3 +106,13 @@ def test_sync_acquire_release(self):
         # Sync acquire should work
         reg.acquire_sync("sync_agent")
         reg.release("sync_agent")
+
+    @pytest.mark.asyncio
+    async def test_sync_acquire_running_loop_noop(self):
+        """Sync acquire in async context should not block event loop."""
+        from praisonaiagents.agent.concurrency import ConcurrencyRegistry
+        reg = ConcurrencyRegistry()
+        reg.set_limit("loop_agent", 1)
+        await reg.acquire("loop_agent")
+        reg.acquire_sync("loop_agent")
+        reg.release("loop_agent")