PraisonAI 4.7.8__tar.gz → 4.7.9__tar.gz

{praisonai-4.7.8 → praisonai-4.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.8
+Version: 4.7.9
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,14 +11,14 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.7.6
-Requires-Dist: praisonai-code>=0.1.5
-Requires-Dist: praisonai-bot>=0.1.5
-Requires-Dist: praisonai-train>=0.1.5
-Requires-Dist: praisonai-browser>=0.1.5
-Requires-Dist: praisonai-mcp>=0.1.7
-Requires-Dist: praisonai-sandbox>=0.1.5
-Requires-Dist: praisonai-deploy>=0.1.5
+Requires-Dist: praisonaiagents>=1.7.7
+Requires-Dist: praisonai-code>=0.1.6
+Requires-Dist: praisonai-bot>=0.1.6
+Requires-Dist: praisonai-train>=0.1.6
+Requires-Dist: praisonai-browser>=0.1.6
+Requires-Dist: praisonai-mcp>=0.1.8
+Requires-Dist: praisonai-sandbox>=0.1.6
+Requires-Dist: praisonai-deploy>=0.1.6
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0
@@ -140,6 +140,8 @@ Requires-Dist: agent-client-protocol>=0.7.0; extra == "acp"
 Provides-Extra: flow
 Requires-Dist: langflow>=1.0.0; extra == "flow"
 Requires-Dist: requests>=2.31.0; extra == "flow"
+Requires-Dist: a2a-sdk[http-server]>=1.0.0; extra == "flow"
+Requires-Dist: fastapi-pagination>=0.12.34; extra == "flow"
 Provides-Extra: lite
 Provides-Extra: all
 Requires-Dist: fastapi>=0.115.0; extra == "all"

{praisonai-4.7.8 → praisonai-4.7.9}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.8
+Version: 4.7.9
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,14 +11,14 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.7.6
-Requires-Dist: praisonai-code>=0.1.5
-Requires-Dist: praisonai-bot>=0.1.5
-Requires-Dist: praisonai-train>=0.1.5
-Requires-Dist: praisonai-browser>=0.1.5
-Requires-Dist: praisonai-mcp>=0.1.7
-Requires-Dist: praisonai-sandbox>=0.1.5
-Requires-Dist: praisonai-deploy>=0.1.5
+Requires-Dist: praisonaiagents>=1.7.7
+Requires-Dist: praisonai-code>=0.1.6
+Requires-Dist: praisonai-bot>=0.1.6
+Requires-Dist: praisonai-train>=0.1.6
+Requires-Dist: praisonai-browser>=0.1.6
+Requires-Dist: praisonai-mcp>=0.1.8
+Requires-Dist: praisonai-sandbox>=0.1.6
+Requires-Dist: praisonai-deploy>=0.1.6
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0
@@ -140,6 +140,8 @@ Requires-Dist: agent-client-protocol>=0.7.0; extra == "acp"
 Provides-Extra: flow
 Requires-Dist: langflow>=1.0.0; extra == "flow"
 Requires-Dist: requests>=2.31.0; extra == "flow"
+Requires-Dist: a2a-sdk[http-server]>=1.0.0; extra == "flow"
+Requires-Dist: fastapi-pagination>=0.12.34; extra == "flow"
 Provides-Extra: lite
 Provides-Extra: all
 Requires-Dist: fastapi>=0.115.0; extra == "all"

{praisonai-4.7.8 → praisonai-4.7.9}/PraisonAI.egg-info/requires.txt

@@ -1,14 +1,14 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.7.6
-praisonai-code>=0.1.5
-praisonai-bot>=0.1.5
-praisonai-train>=0.1.5
-praisonai-browser>=0.1.5
-praisonai-mcp>=0.1.7
-praisonai-sandbox>=0.1.5
-praisonai-deploy>=0.1.5
+praisonaiagents>=1.7.7
+praisonai-code>=0.1.6
+praisonai-bot>=0.1.6
+praisonai-train>=0.1.6
+praisonai-browser>=0.1.6
+praisonai-mcp>=0.1.8
+praisonai-sandbox>=0.1.6
+praisonai-deploy>=0.1.6
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0
@@ -153,6 +153,8 @@ praisonai-sandbox[e2b]
 [flow]
 langflow>=1.0.0
 requests>=2.31.0
+a2a-sdk[http-server]>=1.0.0
+fastapi-pagination>=0.12.34
 
 [gateway]
 praisonai-bot[gateway]

{praisonai-4.7.8 → praisonai-4.7.9}/praisonai/agents_generator.py

@@ -844,8 +844,11 @@ class AgentsGenerator:
         # Build tools dictionary using shared logic
         tools_dict = self._build_tools_dict(config)
         
-        # Select framework and resolve adapter variant
-        framework_name = self.framework or config.get('framework', 'praisonai')
+        # Select framework and resolve adapter variant. Registry is the single
+        # source of truth for the default, so no literal framework name here.
+        framework_name = self._adapter_registry.resolve_or_default(
+            self.framework or config.get('framework')
+        )
         adapter = self._select_framework(framework_name, config)
         
         # Validate framework availability through the injected registry so a
@@ -1376,10 +1379,13 @@ class AgentsGenerator:
         if self._is_workflow_yaml(config):
             # Bracket the workflow run in the same observability session the
             # sequential/hierarchical path uses so AgentOps init/finalize fires
-            # for workflow YAMLs too. Workflow YAMLs are native-only, so tag
-            # them 'praisonai'.
+            # for workflow YAMLs too. Tag with the config-resolved framework
+            # (registry default when omitted) rather than a hardcoded name.
             self._validate_workflow_cli_capabilities()
-            with observability_session("praisonai"):
+            workflow_label = self._adapter_registry.resolve_or_default(
+                self.framework or config.get('framework')
+            ).lower()
+            with observability_session(workflow_label):
                 return self._run_yaml_workflow(config)
 
         # Use shared preparation logic
@@ -1432,10 +1438,14 @@ class AgentsGenerator:
         if self._is_workflow_yaml(config):
             # Bracket the async workflow run in the same observability session
             # the sequential/hierarchical path uses so AgentOps init/finalize
-            # fires for workflow YAMLs too. Workflow YAMLs are native-only, so
-            # tag them 'praisonai'.
+            # fires for workflow YAMLs too. Tag with the config-resolved
+            # framework (registry default when omitted) rather than a hardcoded
+            # name.
             self._validate_workflow_cli_capabilities()
-            with observability_session("praisonai"):
+            workflow_label = self._adapter_registry.resolve_or_default(
+                self.framework or config.get('framework')
+            ).lower()
+            with observability_session(workflow_label):
                 return await self._arun_yaml_workflow(config)
 
         # Use shared preparation logic (off the event loop to avoid blocking imports)
@@ -1493,23 +1503,35 @@ class AgentsGenerator:
         )
         # Validate the YAML-declared framework first so a non-native workflow
         # YAML (e.g. framework: crewai) can't slip through just because the
-        # generator instance still holds the default 'praisonai'.
-        workflow_framework = framework_from_config(config)
+        # generator instance still holds the default 'praisonai'. Resolve
+        # through the injected registry (not the process default) so the
+        # build-time framework agrees with the observability label and a
+        # tenant-scoped adapter is honoured. Fall back to the process default
+        # when the instance was built without an injected registry.
+        registry = getattr(self, "_adapter_registry", None) or _get_default_adapter_registry()
+        workflow_framework = framework_from_config(
+            config, registry=registry
+        )
         validate_workflow_framework(
             workflow_framework,
             source="agents.yaml workflow section",
+            registry=registry,
         )
         if self.framework:
             validate_workflow_framework(
                 self.framework,
                 source="AgentsGenerator framework",
+                registry=registry,
             )
 
         # Parity with the sequential/hierarchical path: reject an incompatible
         # cli_backend in a workflow YAML at build time instead of accepting it
         # silently. Workflow YAMLs are native-only, so validate against
         # 'praisonai'.
-        self._validate_cli_backend_compatibility(config, workflow_framework or 'praisonai')
+        self._validate_cli_backend_compatibility(
+            config,
+            registry.resolve_or_default(workflow_framework),
+        )
 
         # The framework-level check above passes for 'praisonai' because the
         # sequential/hierarchical adapter does support cli_backend — but

{praisonai-4.7.8 → praisonai-4.7.9}/praisonai/api/agent_invoke.py

@@ -443,6 +443,42 @@ def _apply_agent_config(agent: Any, agent_config: Optional[Dict[str, Any]]) -> N
             )
 
 
+async def _safe_close_agent(agent: Any) -> None:
+    """Best-effort teardown of a per-request agent clone.
+
+    ``resolve_session_agent`` returns a fresh clone for every invoke of a
+    session-isolatable ``Agent`` (so concurrent callers never share
+    ``chat_history``). Those clones lazily spin up LLM client pools,
+    tool-executor threads and MCP subprocesses that
+    ``Agent.close()``/``aclose()`` release — without this teardown each request
+    leaks them into the long-lived server process.
+
+    Only a *clone* is closed. Ownership is derived from the agent itself via
+    :func:`_supports_session_isolation`: an isolatable agent was cloned for this
+    request and is safe to close, whereas a non-isolatable one (plain mock /
+    lightweight callable) is the shared registry instance and must NOT be closed
+    or the next request would run against a torn-down agent. Deriving ownership
+    from the resolved object — rather than comparing it against a second,
+    independently-timed registry lookup — is race-free even when the registry
+    entry is concurrently replaced.
+
+    Errors are swallowed (logged) so cleanup never masks a successful response.
+    """
+    if agent is None or not _supports_session_isolation(agent):
+        return
+    try:
+        aclose = getattr(agent, "aclose", None)
+        if inspect.iscoroutinefunction(aclose):
+            await aclose()
+        else:
+            close = getattr(agent, "close", None)
+            if callable(close):
+                import asyncio
+                await asyncio.to_thread(close)
+    except Exception:
+        logger.exception("Agent cleanup failed")
+
+
 def _supports_async_start(agent: Any) -> bool:
     """Return True if agent.astart is a coroutine function."""
     astart = getattr(agent, "astart", None)
@@ -511,52 +547,60 @@ if FASTAPI_AVAILABLE and APIRouter is not None:
                 status_code=404,
                 detail=f"Agent '{agent_id}' not found"
             )
-        
-        # Apply per-request agent_config overrides to the isolated clone, or
-        # reject unsupported keys with a 400 so the caller isn't silently
-        # running a different config than they asked for.
-        try:
-            _apply_agent_config(agent, request.agent_config)
-        except AgentConfigError as e:
-            raise HTTPException(status_code=400, detail=str(e))
 
         try:
-            # Session ID echoed back to the caller
-            session_id = request.session_id or "default"
-            
-            # Invoke agent (handle both sync and async agents)
-            if _supports_async_start(agent):
-                # Async agent
-                result = await agent.astart(request.message)
-            elif _supports_sync_start(agent):
-                # Sync agent - run in a worker thread to avoid blocking the event
-                # loop. ``asyncio.to_thread`` is the correct primitive inside a
-                # running request coroutine (``get_event_loop()`` is deprecated
-                # there since Python 3.10).
-                import asyncio
-                result = await asyncio.to_thread(agent.start, request.message)
-            else:
-                raise AttributeError(f"Agent {agent_id} must provide start() or async astart()")
-            
-            logger.info(f"Agent {agent_id} invoked successfully")
-            
-            return AgentInvokeResponse(
-                result=str(result),
-                session_id=session_id,
-                status="success",
-                metadata={
-                    "agent_id": agent_id,
-                    "message_length": len(request.message),
-                    "response_length": len(str(result))
-                }
-            )
-            
-        except Exception as e:
-            logger.error(f"Agent {agent_id} invocation failed: {e}")
-            raise HTTPException(
-                status_code=500,
-                detail=f"Agent execution failed: {str(e)}"
-            )
+            # Apply per-request agent_config overrides to the isolated clone, or
+            # reject unsupported keys with a 400 so the caller isn't silently
+            # running a different config than they asked for.
+            try:
+                _apply_agent_config(agent, request.agent_config)
+            except AgentConfigError as e:
+                raise HTTPException(status_code=400, detail=str(e))
+
+            try:
+                # Session ID echoed back to the caller
+                session_id = request.session_id or "default"
+
+                # Invoke agent (handle both sync and async agents)
+                if _supports_async_start(agent):
+                    # Async agent
+                    result = await agent.astart(request.message)
+                elif _supports_sync_start(agent):
+                    # Sync agent - run in a worker thread to avoid blocking the event
+                    # loop. ``asyncio.to_thread`` is the correct primitive inside a
+                    # running request coroutine (``get_event_loop()`` is deprecated
+                    # there since Python 3.10).
+                    import asyncio
+                    result = await asyncio.to_thread(agent.start, request.message)
+                else:
+                    raise AttributeError(f"Agent {agent_id} must provide start() or async astart()")
+
+                logger.info(f"Agent {agent_id} invoked successfully")
+
+                return AgentInvokeResponse(
+                    result=str(result),
+                    session_id=session_id,
+                    status="success",
+                    metadata={
+                        "agent_id": agent_id,
+                        "message_length": len(request.message),
+                        "response_length": len(str(result))
+                    }
+                )
+
+            except HTTPException:
+                raise
+            except Exception as e:
+                logger.error(f"Agent {agent_id} invocation failed: {e}")
+                raise HTTPException(
+                    status_code=500,
+                    detail=f"Agent execution failed: {str(e)}"
+                )
+        finally:
+            # Release the per-request clone's resources (LLM pools, tool-executor
+            # threads, MCP subprocesses). No-op when the agent fell back to the
+            # shared template. Never masks the response.
+            await _safe_close_agent(agent)
 
     @router.get("/agents")
     async def list_agents(
@@ -669,6 +713,7 @@ async def invoke_agent_standalone(
             "available_agents": list_registered_agents()
         }
 
+    agent = None
     try:
         # Per-session isolated agent view (see resolve_session_agent). Done
         # inside the try so a clone/isolation failure returns a clean error
@@ -715,6 +760,10 @@ async def invoke_agent_standalone(
             "status": "error",
             "agent_id": agent_id
         }
+    finally:
+        # Release the per-request clone's resources; no-op for the shared
+        # template fallback. Never masks the response.
+        await _safe_close_agent(agent)
 
 
 # Example usage and helper functions

{praisonai-4.7.8 → praisonai-4.7.9}/praisonai/capabilities/passthrough.py

@@ -7,7 +7,91 @@ Provides generic API passthrough functionality for provider-specific endpoints.
 from dataclasses import dataclass, field
 from typing import Optional, Any, Dict
 from urllib.parse import urlparse
+import asyncio
 import ipaddress
+import threading
+
+
+# Shared HTTP clients for the httpx fallback path (used when litellm's
+# passthrough route is unavailable). Reused across calls so the hot passthrough
+# fallback shares a keep-alive connection pool instead of opening + tearing down
+# a socket per agent call. Timeout is applied per-request, so a single client
+# safely serves callers with different ``timeout`` values.
+_sync_client: Any = None
+_async_client: Any = None
+_async_client_loop: Any = None
+_client_lock = threading.Lock()
+
+
+def _get_sync_client() -> Any:
+    """Return the shared sync httpx client, constructing it lazily."""
+    global _sync_client
+    if _sync_client is None:
+        with _client_lock:
+            if _sync_client is None:
+                import httpx
+                _sync_client = httpx.Client()
+    return _sync_client
+
+
+def _get_async_client() -> Any:
+    """Return the shared async httpx client for the running event loop.
+
+    ``httpx.AsyncClient`` binds its connection pool to the event loop that first
+    used it, so a client cached across separate ``asyncio.run()`` lifecycles (or
+    reused from a different loop) fails with a loop-closed error. We therefore
+    key the cached client to its owning loop and rebuild it whenever the current
+    loop differs from the one that created it.
+    """
+    global _async_client, _async_client_loop
+    import httpx
+
+    try:
+        current_loop = asyncio.get_running_loop()
+    except RuntimeError:
+        current_loop = None
+
+    with _client_lock:
+        if _async_client is None or _async_client_loop is not current_loop:
+            _async_client = httpx.AsyncClient()
+            _async_client_loop = current_loop
+        return _async_client
+
+
+def close_clients() -> None:
+    """Close the cached sync client and clear the sync/async globals.
+
+    Provided as an explicit shutdown hook for long-lived hosts that want to
+    release the pooled sockets deterministically. The async client cannot be
+    awaited from this sync helper, so it is dropped (and rebuilt per-loop on next
+    use); the sync client is closed here.
+    """
+    global _sync_client, _async_client, _async_client_loop
+    with _client_lock:
+        if _sync_client is not None:
+            try:
+                _sync_client.close()
+            finally:
+                _sync_client = None
+        _async_client = None
+        _async_client_loop = None
+
+
+async def aclose_clients() -> None:
+    """Await-close the cached async client (in its own loop) and the sync one."""
+    global _sync_client, _async_client, _async_client_loop
+    client = None
+    with _client_lock:
+        client = _async_client
+        _async_client = None
+        _async_client_loop = None
+        if _sync_client is not None:
+            try:
+                _sync_client.close()
+            finally:
+                _sync_client = None
+    if client is not None:
+        await client.aclose()
 
 
 @dataclass
@@ -121,22 +205,20 @@ def passthrough(
             metadata=metadata or {},
         )
     except AttributeError:
-        # Fallback to httpx if passthrough not available
-        import httpx
-        
+        # Fallback to a shared httpx client if the passthrough route is missing.
         url = f"{_validate_api_base(api_base) if api_base else 'https://api.openai.com'}{endpoint}"
         request_headers = headers or {}
         if api_key:
             request_headers['Authorization'] = f"Bearer {api_key}"
         
-        with httpx.Client(timeout=timeout) as client:
-            response = client.request(
-                method=method,
-                url=url,
-                headers=request_headers,
-                json=json_data,
-                data=data,
-            )
+        response = _get_sync_client().request(
+            method=method,
+            url=url,
+            headers=request_headers,
+            json=json_data,
+            data=data,
+            timeout=timeout,
+        )
         
         return PassthroughResult(
             data=response.json() if response.headers.get('content-type', '').startswith('application/json') else response.text,
@@ -203,21 +285,19 @@ async def apassthrough(
             metadata=metadata or {},
         )
     except AttributeError:
-        import httpx
-        
         url = f"{_validate_api_base(api_base) if api_base else 'https://api.openai.com'}{endpoint}"
         request_headers = headers or {}
         if api_key:
             request_headers['Authorization'] = f"Bearer {api_key}"
         
-        async with httpx.AsyncClient(timeout=timeout) as client:
-            response = await client.request(
-                method=method,
-                url=url,
-                headers=request_headers,
-                json=json_data,
-                data=data,
-            )
+        response = await _get_async_client().request(
+            method=method,
+            url=url,
+            headers=request_headers,
+            json=json_data,
+            data=data,
+            timeout=timeout,
+        )
         
         return PassthroughResult(
             data=response.json() if response.headers.get('content-type', '').startswith('application/json') else response.text,

{praisonai-4.7.8 → praisonai-4.7.9}/praisonai/cli/langfuse_client.py

@@ -83,7 +83,24 @@ class LangfuseClient:
         self.secret_key = secret_key
         self.host = host.rstrip("/")  # Remove trailing slash
         self._auth = HTTPBasicAuth(public_key, secret_key)
+        # Reuse a single Session so keep-alive connections and the auth handler
+        # persist across the many trace/session/observation lookups made by the
+        # interactive ``praisonai langfuse`` browser.
+        self._session = requests.Session()
+        self._session.auth = self._auth
     
+    def close(self) -> None:
+        """Close the underlying HTTP session and release its connection pool."""
+        session = getattr(self, "_session", None)
+        if session is not None:
+            session.close()
+
+    def __enter__(self) -> "LangfuseClient":
+        return self
+
+    def __exit__(self, *exc_info: Any) -> None:
+        self.close()
+
     @classmethod
     def from_config_file(cls, config_path: Optional[Path] = None) -> "LangfuseClient":
         """
@@ -149,7 +166,7 @@ class LangfuseClient:
         url = f"{self.host}{endpoint}"
         
         try:
-            response = requests.get(url, auth=self._auth, params=params, timeout=30)
+            response = self._session.get(url, params=params, timeout=30)
             response.raise_for_status()
             return response.json()
         except requests.exceptions.HTTPError as e:

{praisonai-4.7.8 → praisonai-4.7.9}/praisonai/framework_adapters/registry.py

@@ -109,7 +109,29 @@ class FrameworkAdapterRegistry(PluginRegistry[FrameworkAdapter]):
             "No supported framework installed. Available adapters: "
             f"{self.list_all_names()}"
         )
-    
+
+    def resolve_or_default(self, name: Optional[str]) -> str:
+        """Resolve an explicit framework name, or fall back to the default.
+
+        Single source of truth for the ``name or 'praisonai'`` fallbacks that
+        were previously scattered across the wrapper (agents_generator, jobs,
+        scheduler, workflow_framework). Callers pass whatever the user gave —
+        typically ``self.framework or config.get('framework')`` — and get back
+        either that name (stripped) or the registry-selected default.
+
+        When ``pick_default()`` cannot resolve (no adapter installed), fall back
+        to ``DEFAULT_PRIORITY[0]`` so downstream availability validation can
+        raise its own actionable error instead of this helper masking it.
+        """
+        if name:
+            resolved = str(name).strip()
+            if resolved:
+                return resolved
+        try:
+            return self.pick_default()
+        except RuntimeError:
+            return self.DEFAULT_PRIORITY[0]
+
     def _validate_adapter(self, name: str, adapter) -> None:
         """Validate that adapter implements the required protocol signature.
 

{praisonai-4.7.8 → praisonai-4.7.9}/praisonai/framework_adapters/workflow_framework.py

@@ -70,6 +70,13 @@ def validate_workflow_framework(
     raise ValueError(message)
 
 
-def framework_from_config(config: Dict[str, Any]) -> str:
-    """Return normalised framework name from a parsed YAML config dict."""
-    return str(config.get("framework") or "praisonai").lower()
+def framework_from_config(config: Dict[str, Any], *, registry: Any = None) -> str:
+    """Return normalised framework name from a parsed YAML config dict.
+
+    Falls back to the registry-selected default (single source of truth) rather
+    than a hardcoded framework name when the config omits ``framework``.
+    """
+    from .registry import get_default_registry
+
+    registry = registry or get_default_registry()
+    return registry.resolve_or_default(config.get("framework")).lower()