PraisonAI 4.6.32__tar.gz → 4.6.34__tar.gz

{praisonai-4.6.32 → praisonai-4.6.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.32
+Version: 4.6.34
 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,7 +11,7 @@ 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.32
+Requires-Dist: praisonaiagents>=1.6.34
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<=1.82.6,>=1.81.0
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.32 → praisonai-4.6.34}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.32
+Version: 4.6.34
 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,7 +11,7 @@ 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.32
+Requires-Dist: praisonaiagents>=1.6.34
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<=1.82.6,>=1.81.0
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.32 → praisonai-4.6.34}/PraisonAI.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ praisonai/__main__.py
 praisonai/_approval_spec.py
 praisonai/_async_bridge.py
 praisonai/_logging.py
+praisonai/_safe_loader.py
 praisonai/agent.py
 praisonai/agent_scheduler.py
 praisonai/agents_generator.py

{praisonai-4.6.32 → praisonai-4.6.34}/PraisonAI.egg-info/requires.txt

@@ -1,7 +1,7 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.32
+praisonaiagents>=1.6.34
 python-dotenv>=0.19.0
 litellm<=1.82.6,>=1.81.0
 PyYAML>=6.0

praisonai-4.6.34/praisonai/_safe_loader.py

@@ -0,0 +1,100 @@
+"""
+Safe module loader with PRAISONAI_ALLOW_LOCAL_TOOLS opt-in.
+
+This module provides a safe way to load user-supplied .py files with the same
+security posture as tool_resolver.py. All exec_module() calls should route
+through this helper to ensure consistent opt-in behavior.
+"""
+import importlib.util
+import logging
+import os
+from pathlib import Path
+from types import ModuleType
+
+logger = logging.getLogger(__name__)
+
+
+class LocalToolsDisabled(RuntimeError):
+    """Raised when local tools loading is disabled but required."""
+    pass
+
+
+def load_user_module(module_path: str | Path, *, name: str) -> ModuleType | None:
+    """Load a user-supplied .py file with the same opt-in tool_resolver enforces.
+
+    Args:
+        module_path: Path to the .py file to load
+        name: Module name to use for the spec
+
+    Returns:
+        Loaded module or None if loading is disabled or the file is missing.
+
+    Raises:
+        LocalToolsDisabled: If caller wants strict behavior when disabled.
+    """
+    if os.environ.get("PRAISONAI_ALLOW_LOCAL_TOOLS", "").lower() != "true":
+        logger.warning(
+            "Refusing to exec %s: set PRAISONAI_ALLOW_LOCAL_TOOLS=true to enable.",
+            module_path,
+        )
+        return None
+
+    path = Path(module_path).resolve()
+    if not path.is_file():
+        return None
+
+    # Optional: enforce that the path is under CWD or an explicit allowlist
+    # to prevent ../-style traversal from API/network inputs.
+    cwd = Path.cwd().resolve()
+    try:
+        path.relative_to(cwd)
+    except ValueError:
+        logger.warning("Refusing to exec %s: outside working directory.", path)
+        return None
+
+    spec = importlib.util.spec_from_file_location(name, str(path))
+    if spec is None or spec.loader is None:
+        return None
+    
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def load_user_module_strict(module_path: str | Path, *, name: str) -> ModuleType:
+    """Load a user-supplied .py file, raising LocalToolsDisabled if disabled.
+
+    Args:
+        module_path: Path to the .py file to load
+        name: Module name to use for the spec
+
+    Returns:
+        Loaded module
+
+    Raises:
+        LocalToolsDisabled: If PRAISONAI_ALLOW_LOCAL_TOOLS is not set to 'true'
+        FileNotFoundError: If the file doesn't exist
+    """
+    if os.environ.get("PRAISONAI_ALLOW_LOCAL_TOOLS", "").lower() != "true":
+        raise LocalToolsDisabled(
+            f"Refusing to exec {module_path}: set PRAISONAI_ALLOW_LOCAL_TOOLS=true to enable."
+        )
+
+    path = Path(module_path).resolve()
+    if not path.is_file():
+        raise FileNotFoundError(f"Module file not found: {path}")
+
+    # Security: enforce that the path is under CWD
+    cwd = Path.cwd().resolve()
+    try:
+        path.relative_to(cwd)
+    except ValueError:
+        raise LocalToolsDisabled(f"Refusing to exec {path}: outside working directory.")
+
+    spec = importlib.util.spec_from_file_location(name, str(path))
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Could not create spec for {path}")
+    
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module

{praisonai-4.6.32 → praisonai-4.6.34}/praisonai/agents_generator.py

@@ -351,6 +351,24 @@ class AgentsGenerator:
         spec.loader.exec_module(module)
         return {name: obj for name, obj in inspect.getmembers(module, self.is_function_or_decorated)}
     
+    def _extract_tool_classes(self, module):
+        """
+        Extract tool classes from a loaded module that inherit from BaseTool 
+        or are part of langchain_community.tools package.
+        """
+        result = {}
+        for name, obj in inspect.getmembers(module, 
+            lambda x: inspect.isclass(x) and (
+                x.__module__.startswith('langchain_community.tools') or 
+                (PRAISONAI_TOOLS_AVAILABLE and BaseTool and issubclass(x, BaseTool))
+            ) and x is not BaseTool):
+            try:
+                result[name] = obj()
+            except Exception as e:
+                self.logger.warning(f"Error instantiating tool class {name}: {e}")
+                continue
+        return result
+    
     def load_tools_from_module_class(self, module_path):
         """
         Loads tools from a specified module path containing classes that inherit from BaseTool 
@@ -403,16 +421,13 @@ class AgentsGenerator:
         """
         tools_list = []
         try:
-            # Try to import tools.py from current directory
-            spec = importlib.util.spec_from_file_location("tools", "tools.py")
-            self.logger.debug(f"Spec: {spec}")
-            if spec is None:
-                self.logger.debug("tools.py not found in current directory")
+            # Try to import tools.py from current directory using safe loading
+            from ._safe_loader import load_user_module
+            module = load_user_module("tools.py", name="tools")
+            if module is None:
+                self.logger.debug("tools.py not found or local tools loading disabled")
                 return tools_list
 
-            module = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(module)
-
             # Register functions in the tool registry instead of globals()
             registered_tools = self.tool_registry.register_from_module(module)
             tools_list = [self.tool_registry.get_function(name) for name in registered_tools]
@@ -532,11 +547,21 @@ class AgentsGenerator:
         tools_dir_path = Path(root_directory) / 'tools'
         
         if os.path.isfile(tools_py_path):
-            tools_dict.update(self.load_tools_from_module_class(tools_py_path))
-            self.logger.debug("tools.py exists in the root directory. Loading tools.py and skipping tools folder.")
+            from ._safe_loader import load_user_module
+            module = load_user_module(tools_py_path, name="tools_module")
+            if module is not None:
+                tools_dict.update(self._extract_tool_classes(module))
+                self.logger.debug("tools.py exists in the root directory. Loading tools.py and skipping tools folder.")
         elif tools_dir_path.is_dir():
-            tools_dict.update(self.load_tools_from_module_class(tools_dir_path))
-            self.logger.debug("tools folder exists in the root directory")
+            from ._safe_loader import load_user_module
+            for py_file in tools_dir_path.glob("*.py"):
+                if py_file.name.startswith("__"):
+                    continue
+                module = load_user_module(py_file, name=f"tools_{py_file.stem}")
+                if module is not None:
+                    tools_dict.update(self._extract_tool_classes(module))
+            if tools_dict:
+                self.logger.debug("tools folder exists in the root directory")
 
         framework = self.framework or config.get('framework', 'crewai')
 

{praisonai-4.6.32 → praisonai-4.6.34}/praisonai/api/call.py

@@ -69,11 +69,25 @@ tools_path = os.path.join(os.getcwd(), 'tools.py')
 logger.debug(f"Tools path: {tools_path}")
 
 def import_tools_from_file(file_path):
-    spec = importlib.util.spec_from_file_location("custom_tools", file_path)
-    custom_tools_module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(custom_tools_module)
-    logger.debug(f"Imported tools from {file_path}")
-    return custom_tools_module
+    """Import tools from file with PRAISONAI_ALLOW_LOCAL_TOOLS opt-in.
+    
+    This function is reachable from network input via API requests.
+    Additional security: only allow files under the current working directory.
+    """
+    from .._safe_loader import load_user_module_strict, LocalToolsDisabled
+    try:
+        custom_tools_module = load_user_module_strict(file_path, name="custom_tools")
+        logger.debug(f"Imported tools from {file_path}")
+        return custom_tools_module
+    except LocalToolsDisabled as e:
+        logger.warning(f"Tools loading disabled: {e}")
+        raise ValueError("Local tools loading disabled. Set PRAISONAI_ALLOW_LOCAL_TOOLS=true to enable.")
+    except FileNotFoundError as e:
+        logger.warning(f"Tools file not found: {e}")
+        raise ValueError(f"Tools file not found: {file_path}")
+    except Exception as e:
+        logger.error("Failed to import tools from %s", file_path, exc_info=True)
+        raise ValueError(f"Failed to import tools from {file_path}") from e
 
 try:
     # Security: Require explicit opt-in for local tools loading

{praisonai-4.6.32 → praisonai-4.6.34}/praisonai/async_agent_scheduler.py

@@ -116,7 +116,6 @@ class AsyncAgentScheduler:
         
         self.is_running = False
         self._task: Optional[asyncio.Task] = None
-        self._stop_event = asyncio.Event()
         self._executor = AsyncPraisonAgentExecutor(agent)
         self._execution_count = 0
         self._success_count = 0
@@ -124,6 +123,7 @@ class AsyncAgentScheduler:
         
         # Sync lock for async primitives creation and bound loop tracking
         self._primitives_lock = threading.Lock()
+        self._stop_event: Optional[asyncio.Event] = None
         self._cancel_event: Optional[asyncio.Event] = None
         self._stats_lock: Optional[asyncio.Lock] = None
         self._bound_loop: Optional[asyncio.AbstractEventLoop] = None
@@ -138,6 +138,7 @@ class AsyncAgentScheduler:
         
         with self._primitives_lock:
             if self._bound_loop is not loop:
+                self._stop_event = asyncio.Event()
                 self._cancel_event = asyncio.Event()
                 self._stats_lock = asyncio.Lock()
                 self._bound_loop = loop
@@ -167,6 +168,7 @@ class AsyncAgentScheduler:
         try:
             interval = ScheduleParser.parse(schedule_expr)
             self.is_running = True
+            self._ensure_async_primitives()  # NEW — bind to the loop start() runs on
             self._stop_event.clear()
             
             logger.info(f"Starting async agent scheduler: {getattr(self.agent, 'name', 'Agent')}")
@@ -208,19 +210,22 @@ class AsyncAgentScheduler:
             logger.info("Async scheduler is not running")
             return True
         
+        logger.info("Stopping async agent scheduler...")
+        
+        # _stop_event is guaranteed non-None after a successful start()
+        if self._stop_event is None:
+            logger.warning("stop() called before start(); nothing to stop.")
+            self.is_running = False
+            return True
+            
         # Ensure we're on the same loop that was bound during start()
-        try:
-            current_loop = asyncio.get_running_loop()
-            if self._bound_loop is not None and current_loop is not self._bound_loop:
-                raise RuntimeError(
-                    "stop() must be called from the same event loop as start(). "
-                    f"Expected: {self._bound_loop}, got: {current_loop}"
-                )
-        except RuntimeError:
-            # No running loop - this is fine if scheduler was never started
-            pass
+        current_loop = asyncio.get_running_loop()
+        if self._bound_loop is not None and current_loop is not self._bound_loop:
+            raise RuntimeError(
+                "stop() must be called from the same event loop as start(). "
+                f"Expected: {self._bound_loop}, got: {current_loop}"
+            )
             
-        logger.info("Stopping async agent scheduler...")
         self._stop_event.set()
         
         try:
@@ -266,6 +271,7 @@ class AsyncAgentScheduler:
     async def _run_schedule(self, interval: int, max_retries: int):
         """Internal method to run scheduled agent executions."""
         try:
+            self._ensure_async_primitives()
             while not self._stop_event.is_set():
                 logger.info(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Starting async scheduled agent execution")
                 

{praisonai-4.6.32 → praisonai-4.6.34}/praisonai/auto.py

@@ -649,42 +649,28 @@ class AutoGenerator(BaseAutoGenerator):
         # Initialize base class first (handles config_list and client)
         super().__init__(config_list=config_list)
         
-        # Validate framework availability and show framework-specific messages
-        if framework == "crewai" and not _check_crewai_available():
-            raise ImportError("""
-CrewAI is not installed. Please install with:
-    pip install "praisonai[crewai]"
-""")
-        elif framework == "autogen" and not (_check_autogen_available() or _check_autogen_v4_available()):
-            raise ImportError("""
-AutoGen is not installed. Please install with:
-    pip install "praisonai[autogen]" for v0.2
-    pip install "praisonai[autogen-v4]" for v0.4
-""")
-        elif framework == "praisonai" and not _check_praisonai_available():
-            raise ImportError("""
-Praisonai is not installed. Please install with:
-    pip install praisonaiagents
-""")
-        elif framework == "ag2" and not _check_ag2_available():
-            raise ImportError("""
-AG2 is not installed. Please install with:
-    pip install "praisonai[ag2]"
-""")
-
-        # Only show tools message if using a framework and tools are needed
-        if (framework in ["crewai", "autogen"]) and not _check_praisonai_tools_available():
-            if framework == "autogen":
-                logger.warning("""
-Tools are not available for autogen. To use tools, install:
-    pip install "praisonai[autogen]" for v0.2
-    pip install "praisonai[autogen-v4]" for v0.4
-""")
-            else:
-                logger.warning(f"""
-Tools are not available for {framework}. To use tools, install:
-    pip install "praisonai[{framework}]"
-""")
+        # Validate framework availability using adapter registry
+        from .framework_adapters.registry import FrameworkAdapterRegistry
+        
+        registry = FrameworkAdapterRegistry.get_instance()
+        try:
+            adapter = registry.create(framework)
+        except ValueError as e:
+            raise ImportError(
+                f"Unknown framework '{framework}'. Available frameworks: "
+                f"{', '.join(registry.list_registered())}"
+            ) from e
+
+        # Use safe fallbacks for new adapter attributes
+        install_hint = getattr(adapter, "install_hint", f"pip install {framework}")
+        requires_tools_extra = bool(getattr(adapter, "requires_tools_extra", False))
+        
+        if not adapter.is_available():
+            raise ImportError(f"{adapter.name} is not installed. Please install with:\n    {install_hint}")
+        
+        # Check tools availability if required by this framework
+        if requires_tools_extra and not _check_praisonai_tools_available():
+            logger.warning(f"Tools are not available for {framework}. To use tools, install:\n    {install_hint}")
 
         self.topic = topic
         self.agent_file = agent_file

{praisonai-4.6.32 → praisonai-4.6.34}/praisonai/bots/_http_approval.py

@@ -233,19 +233,14 @@ async function decide(d) {{
         )
 
     def request_approval_sync(self, request) -> Any:
-        """Synchronous wrapper — runs async method in a new event loop."""
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            loop = None
-
-        if loop and loop.is_running():
-            import concurrent.futures
-            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
-                future = pool.submit(asyncio.run, self.request_approval(request))
-                return future.result(timeout=self._timeout + 10)
-        else:
-            return asyncio.run(self.request_approval(request))
+        """Synchronous wrapper — delegates to the shared async bridge."""
+        from .._async_bridge import run_sync
+        # run_sync raises RuntimeError if called from a running loop, so callers
+        # in async contexts get a clear error instead of a silent thread cold-start.
+        return run_sync(
+            self.request_approval(request),
+            timeout=self._timeout + 10,
+        )
 
     async def shutdown(self) -> None:
         """Stop the HTTP server gracefully."""

{praisonai-4.6.32 → praisonai-4.6.34}/praisonai/bots/_webhook_approval.py

@@ -178,19 +178,14 @@ class WebhookApproval:
                 )
 
     def request_approval_sync(self, request) -> Any:
-        """Synchronous wrapper — runs async method in a new event loop."""
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            loop = None
-
-        if loop and loop.is_running():
-            import concurrent.futures
-            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
-                future = pool.submit(asyncio.run, self.request_approval(request))
-                return future.result(timeout=self._timeout + 10)
-        else:
-            return asyncio.run(self.request_approval(request))
+        """Synchronous wrapper — delegates to the shared async bridge."""
+        from .._async_bridge import run_sync
+        # run_sync raises RuntimeError if called from a running loop, so callers
+        # in async contexts get a clear error instead of a silent thread cold-start.
+        return run_sync(
+            self.request_approval(request),
+            timeout=self._timeout + 10,
+        )
 
     # ── Polling ─────────────────────────────────────────────────────────
 

{praisonai-4.6.32 → praisonai-4.6.34}/praisonai/cli/features/job_workflow.py

@@ -294,8 +294,30 @@ class JobWorkflowExecutor:
         return {"ok": True, "output": result.stdout.strip()}
 
     def _exec_inline_python(self, code: str, step: Dict, flags: Dict) -> Dict:
-        """Execute inline Python code in an isolated namespace."""
-        _safe_builtins = {
+        """Execute Python code safely using AST validation.
+        
+        Supports both expressions and limited statements for backward compatibility.
+        """
+        import ast
+        
+        # Allowed AST node types for safe execution
+        _ALLOWED_NODES = (
+            # Expressions
+            ast.Expression, ast.BoolOp, ast.BinOp, ast.UnaryOp, ast.Compare,
+            ast.IfExp, ast.Constant, ast.Name, ast.Load, ast.Store, ast.Subscript,
+            ast.List, ast.Tuple, ast.Dict, ast.Set,
+            ast.And, ast.Or, ast.Not, ast.Eq, ast.NotEq, ast.Lt, ast.LtE,
+            ast.Gt, ast.GtE, ast.In, ast.NotIn, ast.Add, ast.Sub, ast.Mult,
+            ast.Div, ast.Mod, ast.FloorDiv, ast.USub, ast.UAdd,
+            # Calls and attribute access (security enforced via safe builtins whitelist)
+            ast.Call, ast.Attribute, ast.keyword, ast.Starred,
+            # Limited statements for backward compatibility
+            ast.Module, ast.Assign, ast.Import, ast.ImportFrom,
+            ast.alias,
+        )
+
+        # Safe builtins whitelist — no __import__, exec, eval, open, compile
+        _SAFE_BUILTINS = {
             "True": True, "False": False, "None": None,
             "int": int, "float": float, "str": str, "bool": bool,
             "list": list, "dict": dict, "tuple": tuple, "set": set,
@@ -305,20 +327,64 @@ class JobWorkflowExecutor:
             "min": min, "max": max, "sum": sum, "abs": abs, "round": round,
             "isinstance": isinstance, "type": type,
             "print": print, "repr": repr,
-            "hasattr": hasattr, "getattr": getattr, "setattr": setattr,
+            "hasattr": hasattr, "getattr": getattr,
+        }
+
+        # Safe namespace with whitelisted environment variables only
+        safe_env = {
+            k: v for k, v in os.environ.items()
+            if k.startswith(('PRAISON', 'HOME', 'USER', 'PATH')) and
+            not k.upper().endswith(('KEY', 'SECRET', 'TOKEN', 'PASSWORD'))
         }
+
         namespace = {
             "flags": flags,
             "vars": {k: self._resolve_var_value(v) for k, v in self._vars.items()},
-            "env": os.environ.copy(),
+            "env": safe_env,  # Whitelisted env vars only
             "cwd": self._cwd,
-            "__builtins__": _safe_builtins,
+            "__builtins__": _SAFE_BUILTINS,
         }
+
         try:
-            exec(code, namespace)
-            return {"ok": True, "output": namespace.get("result", "")}
+            # First try parsing as expression
+            try:
+                tree = ast.parse(code.strip(), mode="eval")
+                is_expression = True
+            except SyntaxError:
+                # Fall back to exec mode for statements
+                tree = ast.parse(code.strip(), mode="exec")
+                is_expression = False
+
+            # Validate all nodes are in allowlist
+            for node in ast.walk(tree):
+                if not isinstance(node, _ALLOWED_NODES):
+                    return {"ok": False, "error": f"Disallowed code node: {type(node).__name__}. Only safe expressions and limited statements are allowed."}
+
+                # Additional safety checks for imports
+                if isinstance(node, (ast.Import, ast.ImportFrom)):
+                    # Only allow standard library modules commonly used in workflows
+                    allowed_modules = {'os', 'datetime', 'time', 'json', 'math', 're', 'collections', 'itertools'}
+                    if isinstance(node, ast.Import):
+                        for alias in node.names:
+                            if alias.name.split('.')[0] not in allowed_modules:
+                                return {"ok": False, "error": f"Import of '{alias.name}' not allowed. Only standard library modules are permitted."}
+                    elif node.module and node.module.split('.')[0] not in allowed_modules:
+                        return {"ok": False, "error": f"Import of '{node.module}' not allowed. Only standard library modules are permitted."}
+
+            # Execute within safe namespace
+            if is_expression:
+                result = eval(compile(tree, "<workflow>", "eval"), namespace)
+                return {"ok": True, "output": str(result)}
+            else:
+                exec(compile(tree, "<workflow>", "exec"), namespace)
+                # Return the 'result' variable if it was set (backward compatibility)
+                result = namespace.get("result", "")
+                return {"ok": True, "output": str(result)}
+            
+        except SyntaxError as e:
+            return {"ok": False, "error": f"Syntax error: {e}"}
         except Exception as e:
-            return {"ok": False, "error": str(e)}
+            return {"ok": False, "error": f"Evaluation error: {e}"}
 
     def _exec_action(self, action_name: str, step: Dict, flags: Dict) -> Dict:
         """