PraisonAI 4.6.150__tar.gz → 4.6.151__tar.gz

{praisonai-4.6.150 → praisonai-4.6.151}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.150
+Version: 4.6.151
 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,12 +11,12 @@ 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.6.153
-Requires-Dist: praisonai-code>=0.0.49
-Requires-Dist: praisonai-bot>=0.0.34
-Requires-Dist: praisonai-train>=0.0.5
-Requires-Dist: praisonai-browser>=0.0.2
-Requires-Dist: praisonai-mcp>=0.0.2
+Requires-Dist: praisonaiagents>=1.6.154
+Requires-Dist: praisonai-code>=0.0.50
+Requires-Dist: praisonai-bot>=0.0.35
+Requires-Dist: praisonai-train>=0.0.6
+Requires-Dist: praisonai-browser>=0.0.3
+Requires-Dist: praisonai-mcp>=0.0.3
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.150 → praisonai-4.6.151}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.150
+Version: 4.6.151
 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,12 +11,12 @@ 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.6.153
-Requires-Dist: praisonai-code>=0.0.49
-Requires-Dist: praisonai-bot>=0.0.34
-Requires-Dist: praisonai-train>=0.0.5
-Requires-Dist: praisonai-browser>=0.0.2
-Requires-Dist: praisonai-mcp>=0.0.2
+Requires-Dist: praisonaiagents>=1.6.154
+Requires-Dist: praisonai-code>=0.0.50
+Requires-Dist: praisonai-bot>=0.0.35
+Requires-Dist: praisonai-train>=0.0.6
+Requires-Dist: praisonai-browser>=0.0.3
+Requires-Dist: praisonai-mcp>=0.0.3
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.150 → praisonai-4.6.151}/PraisonAI.egg-info/SOURCES.txt

@@ -558,10 +558,8 @@ praisonai/tools/skill_manage.py
 praisonai/train/__init__.py
 praisonai/ui/_aiui_datastore.py
 praisonai/ui/_external_agents.py
-praisonai/ui/callbacks.py
 praisonai/ui/context.py
 praisonai/ui/database_config.py
-praisonai/ui/components/aicoder.py
 praisonai/ui_agents/__init__.py
 praisonai/ui_agents/default_app.py
 praisonai/ui_bot/__init__.py

{praisonai-4.6.150 → praisonai-4.6.151}/PraisonAI.egg-info/requires.txt

@@ -1,12 +1,12 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.153
-praisonai-code>=0.0.49
-praisonai-bot>=0.0.34
-praisonai-train>=0.0.5
-praisonai-browser>=0.0.2
-praisonai-mcp>=0.0.2
+praisonaiagents>=1.6.154
+praisonai-code>=0.0.50
+praisonai-bot>=0.0.35
+praisonai-train>=0.0.6
+praisonai-browser>=0.0.3
+praisonai-mcp>=0.0.3
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.150 → praisonai-4.6.151}/praisonai/agents_generator.py

@@ -401,7 +401,7 @@ def _resolve_yaml_cli_backend(cli_backend_config, logger):
 
 
 class AgentsGenerator:
-    def __init__(self, agent_file, framework, config_list, log_level=None, agent_callback=None, task_callback=None, agent_yaml=None, tools=None, cli_config=None, adapter_registry=None, tool_timeout_executor=None):
+    def __init__(self, agent_file, framework, config_list, log_level=None, agent_callback=None, task_callback=None, agent_yaml=None, tools=None, cli_config=None, adapter_registry=None, tool_timeout_executor=None, tool_resolver=None):
         """
         Initialize the AgentsGenerator object.
 
@@ -416,6 +416,7 @@ class AgentsGenerator:
             tools (dict, optional): A dictionary containing the tools to be used for the agents. Defaults to None.
             cli_config (dict, optional): CLI configuration to override YAML settings. Defaults to None.
             adapter_registry (FrameworkAdapterRegistry, optional): Registry for framework adapters. Defaults to process default.
+            tool_resolver (ToolResolver, optional): Canonical tool resolver. Defaults to the shared context-local resolver so discovery runs once per run.
 
         Attributes:
             agent_file (str): The path to the agent file.
@@ -448,9 +449,14 @@ class AgentsGenerator:
         elif os.environ.get('LOGLEVEL'):
             self.logger.setLevel(getattr(logging, os.environ.get('LOGLEVEL', 'INFO').upper(), logging.INFO))
         
-        # Initialize tool resolver (single source of truth for tool resolution)
-        from .tool_resolver import ToolResolver
-        self.tool_resolver = ToolResolver()
+        # Initialize tool resolver (single source of truth for tool resolution).
+        # DI-friendly: callers (e.g. AutoGenerator hand-off, tests) may pass a
+        # resolver; otherwise share the context-local default so tool discovery
+        # runs once per run instead of once per generator construction.
+        if tool_resolver is None:
+            from .tool_resolver import _get_default_resolver
+            tool_resolver = _get_default_resolver()
+        self.tool_resolver = tool_resolver
         
         # DI-friendly: tests/multi-tenant runtimes pass their own registry;
         # CLI users get the process default.

{praisonai-4.6.150 → praisonai-4.6.151}/praisonai/api/agent_invoke.py

@@ -168,6 +168,109 @@ def list_registered_agents() -> list:
     return list(_agent_registry.keys())
 
 
+def _is_real_agent(agent: Any) -> bool:
+    """Return True when ``agent`` is a genuine ``praisonaiagents`` ``Agent``.
+
+    Uses ``isinstance`` against the real ``Agent`` class so **subclasses defined
+    in application code** are recognised too (they inherit the per-session
+    machinery and ``clone_for_channel``). Plain mocks / lightweight callables are
+    not ``Agent`` instances, so they fall back to the shared instance for
+    backward compatibility. If ``praisonaiagents`` cannot be imported we treat
+    the object as non-isolatable.
+    """
+    try:
+        from praisonaiagents import Agent
+    except Exception:
+        return False
+    return isinstance(agent, Agent)
+
+
+def _supports_session_isolation(agent: Any) -> bool:
+    """Return True when ``agent`` can be safely cloned per session.
+
+    A real ``Agent`` (or any subclass) exposes the per-session machinery
+    (``_session_id`` binding, ``chat_history`` and a safe clone path). Plain
+    mocks / lightweight callables do not, so they stay on the shared instance to
+    preserve backward compatibility.
+    """
+    if not _is_real_agent(agent):
+        return False
+    if not hasattr(agent, "_session_id"):
+        return False
+    if not hasattr(agent, "chat_history"):
+        return False
+    return callable(getattr(agent, "clone_for_channel", None))
+
+
+def _clone_agent(agent: Any) -> Any:
+    """Create an independent copy of a real ``Agent``.
+
+    Prefers ``clone_for_channel`` (purpose-built for multi-channel isolation
+    with fresh locks), falling back to ``deepcopy``.
+    """
+    clone_for_channel = getattr(agent, "clone_for_channel", None)
+    if callable(clone_for_channel):
+        return clone_for_channel()
+    import copy as _copy
+
+    return _copy.deepcopy(agent)
+
+
+def resolve_session_agent(agent_id: str, session_id: Optional[str]) -> Any:
+    """Resolve an isolated, session-scoped agent for a single request.
+
+    The registry holds a *template* agent, not a live conversation. Every
+    request gets its own clone so concurrent callers never share mutable
+    ``chat_history``:
+
+    - With a ``session_id``: the clone is bound to that session so its history
+      is loaded from (and persisted to) the shared, file-locked session store —
+      giving continuity across requests and isolation between sessions.
+    - Without a ``session_id``: the clone is ephemeral (no session binding), so
+      no global state is mutated.
+
+    Agents that don't support cloning/session binding (e.g. plain mocks) fall
+    back to the shared registry instance for backward compatibility.
+    """
+    template = get_agent(agent_id)
+    if template is None:
+        return None
+
+    if not _supports_session_isolation(template):
+        return template
+
+    try:
+        agent = _clone_agent(template)
+    except Exception as e:
+        # A clone failure must never silently fall back to the shared template:
+        # doing so would leak one session's chat_history into another. Fail the
+        # request instead so isolation is guaranteed.
+        logger.error(
+            f"Failed to clone agent '{agent_id}' for session isolation: {e}"
+        )
+        raise RuntimeError(
+            f"Failed to isolate agent '{agent_id}' for session: {e}"
+        ) from e
+
+    # Reset per-request conversation state so the clone starts clean and
+    # (re)loads the requested session's history lazily on first chat.
+    try:
+        agent.chat_history = []
+    except Exception:
+        pass
+    if hasattr(agent, "_session_store_initialized"):
+        agent._session_store_initialized = False
+    if session_id:
+        agent._session_id = session_id
+        if hasattr(agent, "_history_session_id"):
+            agent._history_session_id = session_id
+    else:
+        agent._session_id = None
+        if hasattr(agent, "_history_session_id"):
+            agent._history_session_id = None
+    return agent
+
+
 def _supports_async_start(agent: Any) -> bool:
     """Return True if agent.astart is a coroutine function."""
     astart = getattr(agent, "astart", None)
@@ -218,8 +321,17 @@ if FASTAPI_AVAILABLE and APIRouter is not None:
         }
         ```
         """
-        # Get agent from registry
-        agent = get_agent(agent_id)
+        # Resolve a per-session isolated agent view so concurrent callers never
+        # share mutable chat_history. A provided session_id gives continuity via
+        # the shared session store; its absence yields an ephemeral conversation.
+        try:
+            agent = resolve_session_agent(agent_id, request.session_id)
+        except Exception as e:
+            logger.error(f"Failed to isolate agent {agent_id}: {e}")
+            raise HTTPException(
+                status_code=500,
+                detail=f"Agent execution failed: {str(e)}"
+            )
         if not agent:
             logger.error(f"Agent not found: {agent_id}")
             raise HTTPException(
@@ -228,7 +340,7 @@ if FASTAPI_AVAILABLE and APIRouter is not None:
             )
         
         try:
-            # Set session ID if provided
+            # Session ID echoed back to the caller
             session_id = request.session_id or "default"
             
             # Apply agent config overrides if provided
@@ -362,15 +474,19 @@ async def invoke_agent_standalone(
     This can be used in environments where FastAPI is not available
     or when integrating with other web frameworks.
     """
-    agent = get_agent(agent_id)
-    if not agent:
+    if get_agent(agent_id) is None:
         return {
             "error": f"Agent '{agent_id}' not found",
             "status": "error",
             "available_agents": list_registered_agents()
         }
-    
+
     try:
+        # Per-session isolated agent view (see resolve_session_agent). Done
+        # inside the try so a clone/isolation failure returns a clean error
+        # rather than leaking one session's history into another.
+        agent = resolve_session_agent(agent_id, session_id)
+
         # Apply config if provided
         if agent_config:
             logger.debug(f"Agent config provided: {agent_config}")

{praisonai-4.6.150 → praisonai-4.6.151}/praisonai/auto.py

@@ -733,10 +733,50 @@ class BaseAutoGenerator:
             raise error[0]
         return result[0]
 
-    @staticmethod
-    def get_available_tools() -> List[str]:
-        """Return list of available tools for agent assignment."""
-        return AVAILABLE_TOOLS.copy()
+    def _get_tool_resolver(self):
+        """Lazily construct the canonical ToolResolver (single source of truth).
+
+        Uses the shared context-local resolver so every generator in a run
+        (auto phase + AgentsGenerator + workflow/job generators) reuses one
+        warm cache instead of repeating full tool discovery. Kept lazy so
+        importing auto.py stays cheap and so a resolver-construction failure
+        never blocks generation — callers fall back to keyword/legacy hints.
+        """
+        resolver = getattr(self, "_tool_resolver", None)
+        if resolver is None:
+            try:
+                from .tool_resolver import _get_default_resolver
+                resolver = _get_default_resolver()
+            except Exception as e:  # pragma: no cover - defensive
+                logger.debug("ToolResolver unavailable (%s); using keyword hints only.", e)
+                resolver = False  # sentinel: attempted, not available
+            self._tool_resolver = resolver
+        return resolver or None
+
+    def _available_tools(self) -> List[str]:
+        """Return the real, installed tool names from the canonical ToolResolver.
+
+        This is the single source of truth shared with AgentsGenerator. Returns
+        an empty list if the resolver is unavailable so callers can fall back.
+        """
+        resolver = self._get_tool_resolver()
+        if resolver is None:
+            return []
+        try:
+            return sorted(resolver.list_available().keys())
+        except Exception as e:  # pragma: no cover - defensive
+            logger.debug("ToolResolver.list_available() failed (%s).", e)
+            return []
+
+    def get_available_tools(self) -> List[str]:
+        """Return list of available tools for agent assignment.
+
+        Routes through the canonical ToolResolver (single source of truth) so
+        the LLM is shown only tools that are actually installed. Falls back to
+        the frozen ``AVAILABLE_TOOLS`` list solely when the resolver is
+        unavailable or returns nothing.
+        """
+        return self._available_tools() or AVAILABLE_TOOLS.copy()
     
     @staticmethod
     def analyze_complexity(topic: str) -> str:
@@ -1103,38 +1143,6 @@ class AutoGenerator(BaseAutoGenerator):
         
         return merged_data
 
-    def _get_tool_resolver(self):
-        """Lazily construct the canonical ToolResolver (single source of truth).
-
-        Kept lazy so importing auto.py stays cheap and so a resolver-construction
-        failure never blocks generation — callers fall back to keyword hints.
-        """
-        resolver = getattr(self, "_tool_resolver", None)
-        if resolver is None:
-            try:
-                from .tool_resolver import ToolResolver
-                resolver = ToolResolver()
-            except Exception as e:  # pragma: no cover - defensive
-                logger.debug("ToolResolver unavailable (%s); using keyword hints only.", e)
-                resolver = False  # sentinel: attempted, not available
-            self._tool_resolver = resolver
-        return resolver or None
-
-    def _available_tools(self) -> List[str]:
-        """Return the real, installed tool names from the canonical ToolResolver.
-
-        This is the single source of truth shared with AgentsGenerator. Returns
-        an empty list if the resolver is unavailable so callers can fall back.
-        """
-        resolver = self._get_tool_resolver()
-        if resolver is None:
-            return []
-        try:
-            return sorted(resolver.list_available().keys())
-        except Exception as e:  # pragma: no cover - defensive
-            logger.debug("ToolResolver.list_available() failed (%s).", e)
-            return []
-
     def discover_tools_for_topic(self) -> List[str]:
         """
         Discover appropriate tools for the topic.

praisonai-4.6.151/praisonai/version.py

@@ -0,0 +1 @@
+__version__ = "4.6.151"

{praisonai-4.6.150 → praisonai-4.6.151}/pyproject.toml

@@ -12,12 +12,12 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=1.6.153",
-    "praisonai-code>=0.0.49",
-    "praisonai-bot>=0.0.34",
-    "praisonai-train>=0.0.5",
-    "praisonai-browser>=0.0.2",
-    "praisonai-mcp>=0.0.2",
+    "praisonaiagents>=1.6.154",
+    "praisonai-code>=0.0.50",
+    "praisonai-bot>=0.0.35",
+    "praisonai-train>=0.0.6",
+    "praisonai-browser>=0.0.3",
+    "praisonai-mcp>=0.0.3",
     "python-dotenv>=0.19.0",
     "litellm>=1.83.14,<2",
     "PyYAML>=6.0",

{praisonai-4.6.150 → praisonai-4.6.151}/tests/test_n8n_agent_invoke.py

@@ -333,6 +333,141 @@ class TestAgentInvokeFastAPI:
         assert response.status_code == 404
 
 
+class TestSessionIsolation:
+    """Verify session_id yields isolated + continuous conversations (Issue #3105)."""
+
+    def test_resolve_session_agent_falls_back_for_mocks(self):
+        """Non-Agent objects (mocks) stay on the shared instance for back-compat."""
+        from praisonai.api.agent_invoke import (
+            register_agent,
+            unregister_agent,
+            resolve_session_agent,
+        )
+
+        mock_agent = Mock(spec=["start", "name"])
+        register_agent("mock-fallback", mock_agent)
+        try:
+            resolved = resolve_session_agent("mock-fallback", "s1")
+            assert resolved is mock_agent
+        finally:
+            unregister_agent("mock-fallback")
+
+    def test_resolve_session_agent_missing_returns_none(self):
+        from praisonai.api.agent_invoke import resolve_session_agent
+
+        assert resolve_session_agent("does-not-exist", "s1") is None
+
+    def test_real_agent_clones_are_isolated(self, tmp_path, monkeypatch):
+        """Two session_ids produce distinct, isolated agent clones."""
+        praisonaiagents = pytest.importorskip("praisonaiagents")
+        from praisonai.api.agent_invoke import (
+            register_agent,
+            unregister_agent,
+            resolve_session_agent,
+        )
+
+        agent = praisonaiagents.Agent(
+            name="iso-agent",
+            instructions="test",
+            llm="gpt-4o-mini",
+        )
+        register_agent("iso-agent", agent)
+        try:
+            a = resolve_session_agent("iso-agent", "A")
+            b = resolve_session_agent("iso-agent", "B")
+
+            # Distinct clones, distinct histories, correct session binding.
+            assert a is not b
+            assert a is not agent
+            assert a._session_id == "A"
+            assert b._session_id == "B"
+            assert a.chat_history is not b.chat_history
+
+            # Mutating one clone's history does not affect the other or template.
+            a.chat_history.append({"role": "user", "content": "hi from A"})
+            assert b.chat_history == []
+            assert agent.chat_history == []
+        finally:
+            unregister_agent("iso-agent")
+
+    def test_no_session_id_is_ephemeral(self):
+        """Absent session_id yields an unbound (ephemeral) clone."""
+        praisonaiagents = pytest.importorskip("praisonaiagents")
+        from praisonai.api.agent_invoke import (
+            register_agent,
+            unregister_agent,
+            resolve_session_agent,
+        )
+
+        agent = praisonaiagents.Agent(
+            name="ephemeral-agent",
+            instructions="test",
+            llm="gpt-4o-mini",
+        )
+        register_agent("ephemeral-agent", agent)
+        try:
+            clone = resolve_session_agent("ephemeral-agent", None)
+            assert clone is not agent
+            assert clone._session_id is None
+            assert clone.chat_history == []
+        finally:
+            unregister_agent("ephemeral-agent")
+
+    def test_agent_subclass_is_isolated(self):
+        """Application-defined ``Agent`` subclasses are isolated, not shared."""
+        praisonaiagents = pytest.importorskip("praisonaiagents")
+        from praisonai.api.agent_invoke import (
+            register_agent,
+            unregister_agent,
+            resolve_session_agent,
+        )
+
+        class MyAgent(praisonaiagents.Agent):
+            pass
+
+        agent = MyAgent(name="sub-agent", instructions="test", llm="gpt-4o-mini")
+        register_agent("sub-agent", agent)
+        try:
+            a = resolve_session_agent("sub-agent", "A")
+            b = resolve_session_agent("sub-agent", "B")
+            # Subclass must be recognised and cloned per session, not shared.
+            assert a is not agent
+            assert isinstance(a, MyAgent)
+            assert a is not b
+            assert a._session_id == "A"
+            assert b._session_id == "B"
+            assert a.chat_history is not b.chat_history
+        finally:
+            unregister_agent("sub-agent")
+
+    def test_clone_failure_raises_instead_of_sharing(self, monkeypatch):
+        """A clone failure must raise, never fall back to the shared template."""
+        praisonaiagents = pytest.importorskip("praisonaiagents")
+        from praisonai.api import agent_invoke
+        from praisonai.api.agent_invoke import (
+            register_agent,
+            unregister_agent,
+            resolve_session_agent,
+        )
+
+        agent = praisonaiagents.Agent(
+            name="clonefail-agent",
+            instructions="test",
+            llm="gpt-4o-mini",
+        )
+        register_agent("clonefail-agent", agent)
+
+        def _boom(_agent):
+            raise RuntimeError("clone exploded")
+
+        monkeypatch.setattr(agent_invoke, "_clone_agent", _boom)
+        try:
+            with pytest.raises(RuntimeError):
+                resolve_session_agent("clonefail-agent", "A")
+        finally:
+            unregister_agent("clonefail-agent")
+
+
 def test_agent_invoke_smoke_test():
     """Smoke test to verify agent invoke module can be imported and used."""
     try:

praisonai-4.6.150/praisonai/ui/callbacks.py

@@ -1,57 +0,0 @@
-import logging
-from typing import Dict, Any, Callable, Optional, Union
-import asyncio
-
-logger = logging.getLogger(__name__)
-
-class CallbackManager:
-    """Manages callbacks for the PraisonAI UI"""
-    
-    def __init__(self):
-        self._callbacks: Dict[str, Dict[str, Union[Callable, bool]]] = {}
-    
-    def register(self, name: str, callback: Callable, is_async: bool = False) -> None:
-        """Register a callback function"""
-        self._callbacks[name] = {
-            'func': callback,
-            'is_async': is_async
-        }
-    
-    async def call(self, name: str, **kwargs) -> None:
-        """Call a registered callback"""
-        if name not in self._callbacks:
-            logger.warning(f"No callback registered for {name}")
-            return
-            
-        callback_info = self._callbacks[name]
-        func = callback_info['func']
-        is_async = callback_info['is_async']
-        
-        try:
-            if is_async:
-                await func(**kwargs)
-            else:
-                if asyncio.iscoroutinefunction(func):
-                    await func(**kwargs)
-                else:
-                    await asyncio.get_event_loop().run_in_executor(None, lambda: func(**kwargs))
-        except Exception as e:
-            logger.error(f"Error in callback {name}: {str(e)}")
-
-# Global callback manager instance
-callback_manager = CallbackManager()
-
-def register_callback(name: str, callback: Callable, is_async: bool = False) -> None:
-    """Register a callback with the global callback manager"""
-    callback_manager.register(name, callback, is_async)
-
-async def trigger_callback(name: str, **kwargs) -> None:
-    """Trigger a callback from the global callback manager"""
-    await callback_manager.call(name, **kwargs)
-
-# Decorator for registering callbacks
-def callback(name: str, is_async: bool = False):
-    def decorator(func):
-        register_callback(name, func, is_async)
-        return func
-    return decorator