PraisonAI 4.6.55__tar.gz → 4.6.56__tar.gz

{praisonai-4.6.55 → praisonai-4.6.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.55
+Version: 4.6.56
 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.55
+Requires-Dist: praisonaiagents>=1.6.56
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.55 → praisonai-4.6.56}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.55
+Version: 4.6.56
 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.55
+Requires-Dist: praisonaiagents>=1.6.56
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.55 → praisonai-4.6.56}/PraisonAI.egg-info/SOURCES.txt

@@ -20,7 +20,6 @@ praisonai/agent_scheduler.py
 praisonai/agents_generator.py
 praisonai/async_agent_scheduler.py
 praisonai/auto.py
-praisonai/deploy.py
 praisonai/profiler.py
 praisonai/setup.py
 praisonai/test.py

{praisonai-4.6.55 → praisonai-4.6.56}/PraisonAI.egg-info/requires.txt

@@ -1,7 +1,7 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.55
+praisonaiagents>=1.6.56
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.55 → praisonai-4.6.56}/praisonai/cli/features/doctor/formatters.py

@@ -144,6 +144,17 @@ class BaseFormatter:
 class TextFormatter(BaseFormatter):
     """Text formatter with optional color support."""
     
+    def __init__(
+        self,
+        no_color: bool = False,
+        quiet: bool = False,
+        redact: bool = True,
+        show_prefix_suffix: bool = False,
+    ):
+        super().__init__(no_color, quiet, redact, show_prefix_suffix)
+        # Cache encoding detection result at initialization
+        self._unicode_supported = self._can_encode_unicode()
+    
     # ANSI color codes
     COLORS = {
         "reset": "\033[0m",
@@ -173,15 +184,49 @@ class TextFormatter(BaseFormatter):
         CheckStatus.ERROR: "✗",
     }
     
+    # ASCII fallback symbols for systems that don't support UTF-8
+    STATUS_SYMBOLS_ASCII = {
+        CheckStatus.PASS: "[OK]",
+        CheckStatus.WARN: "[!]",
+        CheckStatus.FAIL: "[X]",
+        CheckStatus.SKIP: "[-]",
+        CheckStatus.ERROR: "[X]",
+    }
+    
     def _color(self, text: str, color: str) -> str:
         """Apply color to text if colors are enabled."""
         if self.no_color:
             return text
         return f"{self.COLORS.get(color, '')}{text}{self.COLORS['reset']}"
     
+    def _can_encode_unicode(self) -> bool:
+        """Check if stdout can encode Unicode symbols."""
+        try:
+            # Get stdout encoding
+            encoding = getattr(sys.stdout, 'encoding', 'ascii') or 'ascii'
+            
+            # UTF-8 always supports Unicode
+            if encoding.lower() in ('utf-8', 'utf8'):
+                return True
+                
+            # Test if we can encode our specific Unicode symbols
+            test_symbols = ["✓", "⚠", "✗", "○"]
+            for symbol in test_symbols:
+                try:
+                    symbol.encode(encoding, errors='strict')
+                except (UnicodeEncodeError, LookupError):
+                    return False
+            return True
+        except (AttributeError, TypeError):
+            # If we can't determine encoding, assume ASCII-only is safer
+            return False
+    
     def _status_symbol(self, status: CheckStatus) -> str:
-        """Get colored status symbol."""
-        symbol = self.STATUS_SYMBOLS.get(status, "?")
+        """Get colored status symbol with encoding safety."""
+        if self._unicode_supported:
+            symbol = self.STATUS_SYMBOLS.get(status, "?")
+        else:
+            symbol = self.STATUS_SYMBOLS_ASCII.get(status, "[?]")
         color = self.STATUS_COLORS.get(status, "white")
         return self._color(symbol, color)
     

{praisonai-4.6.55 → praisonai-4.6.56}/praisonai/cli/main.py

@@ -425,7 +425,6 @@ class PraisonAI:
             
             # Handle backends command
             elif args.command == "backends":
-                from rich import print
                 subcommand = unknown_args[0] if unknown_args and not unknown_args[0].startswith('-') else None
                 
                 if subcommand == "list" or subcommand is None:

{praisonai-4.6.55 → praisonai-4.6.56}/praisonai/inc/models.py

@@ -7,8 +7,6 @@ from urllib.parse import urlparse
 import importlib.util
 
 logger = logging.getLogger(__name__)
-_loglevel = os.environ.get('LOGLEVEL', 'INFO').strip().upper() or 'INFO'
-logging.basicConfig(level=_loglevel, format='%(asctime)s - %(levelname)s - %(message)s')
 
 # Constants
 LOCAL_SERVER_API_KEY_PLACEHOLDER = "not-needed"

{praisonai-4.6.55 → praisonai-4.6.56}/praisonai/integration/host_app.py

@@ -7,9 +7,64 @@ Set ``PRAISONAI_HOST_LEGACY=1`` to skip provider wiring (callback-only mode).
 from __future__ import annotations
 
 import os
+import contextvars
 from typing import Any, Dict, List, Optional, Sequence
 
-_CONFIGURED = False
+# Use context variable instead of module-level global for multi-agent safety
+_configured_context: contextvars.ContextVar[bool] = contextvars.ContextVar('host_configured', default=False)
+
+# For testing: also maintain a module-level flag that can be accessed across contexts
+_configured_global = False
+
+# Backward compatibility for tests
+def reset_configuration() -> None:
+    """Reset configuration state for testing. Use instead of host_app._CONFIGURED = False."""
+    global _configured_global
+    _configured_context.set(False)
+    _configured_global = False
+    
+    # Also clear any cached state that might be lingering
+    try:
+        import praisonaiui.server as srv
+        if hasattr(srv, '_provider'):
+            srv._provider = None
+        if hasattr(srv, '_datastore'):
+            srv._datastore = None
+        # Clear any other potentially cached state
+        if hasattr(srv, '_app'):
+            srv._app = None
+        # Clear backends registry if it exists
+        try:
+            import praisonaiui.backends as backends
+            if hasattr(backends, 'clear_backends'):
+                backends.clear_backends()
+            elif hasattr(backends, '_backends'):
+                backends._backends.clear()
+        except (ImportError, AttributeError):
+            pass
+    except ImportError:
+        pass
+
+def is_configured() -> bool:
+    """Check if configuration has been applied in current context."""
+    return _configured_context.get() or _configured_global
+
+# Backward compatibility shim for tests that assign host_app._CONFIGURED = False
+class _ConfiguredShim:
+    """Backward compatibility shim that proxies to both ContextVar and global."""
+    def __get__(self, obj, objtype=None):
+        return _configured_context.get() or _configured_global
+    
+    def __set__(self, obj, value):
+        global _configured_global
+        _configured_context.set(bool(value))
+        _configured_global = bool(value)
+        
+    def __bool__(self):
+        return _configured_context.get() or _configured_global
+
+# Expose the shim so tests can still use host_app._CONFIGURED = False 
+_CONFIGURED = _ConfiguredShim()
 
 
 def is_legacy_host() -> bool:
@@ -38,7 +93,11 @@ def configure_host(
     **kwargs: Any,
 ) -> None:
     """Apply PraisonAIUI host settings and wire L1 backends (unless legacy mode)."""
-    global _CONFIGURED
+    global _configured_global
+    
+    # Check if already configured in this context to avoid duplicate configuration
+    if _configured_context.get() or _configured_global:
+        return
 
     import praisonaiui as aiui
     from praisonai.ui._aiui_datastore import PraisonAISessionDataStore
@@ -78,7 +137,9 @@ def configure_host(
     if not is_legacy_host():
         from praisonaiui.providers import PraisonAIProvider
         from praisonaiui.server import set_provider
-
+        
+        # Always proceed with provider setup unless explicitly skipped by legacy mode
+        # Tests that need to override providers should do so after configure_host() completes
         kwargs = dict(agent_kwargs or {})
         if agents:
             set_provider(PraisonAIProvider(agents=list(agents), **kwargs))
@@ -112,7 +173,8 @@ def configure_host(
     except ImportError:
         pass  # L3 pages are optional
 
-    _CONFIGURED = True
+    _configured_context.set(True)
+    _configured_global = True
 
 
 def setup_bridges() -> None:
@@ -170,8 +232,6 @@ def setup_bridges() -> None:
         from praisonai.integration.bridges.kanban_bridge import register_kanban_backends
         register_kanban_backends()
         
-    except Exception as exc:
-        log.debug("aiui backend injection failed: %s", exc)
     except Exception as exc:
         log.warning("aiui backend injection failed: %s", exc)
 
@@ -180,7 +240,7 @@ def create_host_app():
     """Return the Starlette app from PraisonAIUI (call after ``configure_host``)."""
     from praisonaiui.server import create_app
 
-    if not _CONFIGURED:
+    if not (_configured_context.get() or _configured_global):
         configure_host()
     return create_app()
 

{praisonai-4.6.55 → praisonai-4.6.56}/praisonai/integrations/base.py

@@ -102,13 +102,25 @@ class BaseCLIIntegration(ABC):
         """
         cmd = self.cli_command
         cache = BaseCLIIntegration._availability_cache
-        if cmd in cache:
-            return cache[cmd]
         with BaseCLIIntegration._availability_cache_lock:
             if cmd not in cache:
                 cache[cmd] = shutil.which(cmd) is not None
             return cache[cmd]
     
+    @classmethod
+    def invalidate_availability(cls, command: Optional[str] = None) -> None:
+        """
+        Invalidate availability cache for CLI tools.
+        
+        Args:
+            command: Specific CLI command to invalidate, or None to clear all
+        """
+        with cls._availability_cache_lock:
+            if command is None:
+                cls._availability_cache.clear()
+            else:
+                cls._availability_cache.pop(command, None)
+    
     @abstractmethod
     async def execute(self, prompt: str, **options) -> str:
         """

{praisonai-4.6.55 → praisonai-4.6.56}/praisonai/integrations/registry.py

@@ -19,8 +19,10 @@ Usage:
     # Register custom integration
     registry.register('my-agent', MyCustomIntegration)
     
-    # Create integration
-    agent = registry.create('claude', workspace="/path/to/project")
+    # Create integration (use try_create for optional behavior)
+    agent = registry.try_create('claude', workspace="/path/to/project")
+    if agent is None:
+        print("Integration 'claude' not found or unavailable")
     
     # List available integrations
     available = await registry.get_available()
@@ -104,9 +106,9 @@ class ExternalAgentRegistry(PluginRegistry[BaseCLIIntegration]):
         """
         return self.list_names()
         
-    def create(self, name: str, **kwargs: Any) -> Optional[BaseCLIIntegration]:
+    def try_create(self, name: str, **kwargs: Any) -> Optional[BaseCLIIntegration]:
         """
-        Create an instance of the specified integration.
+        Try to create an instance of the specified integration.
         
         Args:
             name: Name of the integration
@@ -217,7 +219,7 @@ def create_integration(name: str, **kwargs: Any) -> Optional[BaseCLIIntegration]
         BaseCLIIntegration: Instance of the integration, or None if not found
     """
     registry = get_default_registry()
-    return registry.create(name, **kwargs)
+    return registry.try_create(name, **kwargs)
 
 
 def get_available_integrations() -> Dict[str, bool]:

praisonai-4.6.56/praisonai/llm/env.py

@@ -0,0 +1,87 @@
+"""
+LLM endpoint environment variable resolver.
+
+Provides a single source of truth for resolving LLM endpoint configuration
+from environment variables, ensuring consistent precedence across all components.
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class LLMEndpoint:
+    """LLM endpoint configuration resolved from environment variables."""
+    model: str
+    base_url: str
+    api_key: Optional[str]
+
+
+# Map well-known model prefixes to their (env-var, default base_url).
+_PROVIDER_MAP = {
+    "anthropic/":  ("ANTHROPIC_API_KEY",  "https://api.anthropic.com/v1"),
+    "google/":     ("GOOGLE_API_KEY",     "https://generativelanguage.googleapis.com/v1beta"),
+    "gemini/":     ("GEMINI_API_KEY",     "https://generativelanguage.googleapis.com/v1beta"),
+    "groq/":       ("GROQ_API_KEY",       "https://api.groq.com/openai/v1"),
+    "cohere/":     ("COHERE_API_KEY",     "https://api.cohere.ai/v1"),
+    "openrouter/": ("OPENROUTER_API_KEY", "https://openrouter.ai/api/v1"),
+    "ollama/":     ("OLLAMA_API_KEY",     "http://localhost:11434/v1"),
+}
+
+# Documented, single precedence list. Add new providers here only.
+_MODEL_VARS = ("MODEL_NAME", "OPENAI_MODEL_NAME")
+_BASE_URL_VARS = ("OPENAI_BASE_URL", "OPENAI_API_BASE", "OLLAMA_API_BASE")
+_DEFAULT_MODEL = "gpt-4o-mini"
+_DEFAULT_BASE = "https://api.openai.com/v1"
+_DEFAULT_KEY_VAR = "OPENAI_API_KEY"
+
+
+def _first_set(*names: str) -> Optional[str]:
+    """Return the first environment variable that is set and non-empty."""
+    for name in names:
+        value = os.environ.get(name)
+        if value:
+            return value
+    return None
+
+
+def _provider_from_model(model: str) -> tuple[str, str | None]:
+    """Get provider-specific API key environment variable and base URL for a model."""
+    for prefix, (key_var, default_base) in _PROVIDER_MAP.items():
+        if model.startswith(prefix):
+            return key_var, default_base
+    return _DEFAULT_KEY_VAR, None
+
+
+def resolve_llm_endpoint(*, default_base: str = _DEFAULT_BASE) -> LLMEndpoint:
+    """
+    Resolve LLM endpoint configuration from environment variables.
+    
+    Precedence order:
+    - Model: MODEL_NAME > OPENAI_MODEL_NAME > default
+    - Base URL: OPENAI_BASE_URL > OPENAI_API_BASE > OLLAMA_API_BASE > provider default > default
+    - API Key: provider-specific key (e.g., ANTHROPIC_API_KEY) > OPENAI_API_KEY fallback
+    
+    Args:
+        default_base: Default base URL if none found in environment variables
+        
+    Returns:
+        LLMEndpoint with resolved configuration
+    """
+    model = _first_set(*_MODEL_VARS) or _DEFAULT_MODEL
+    key_var, provider_base = _provider_from_model(model)
+
+    base_url = (
+        _first_set(*_BASE_URL_VARS)
+        or provider_base
+        or default_base
+    )
+    
+    # Try provider-specific key first; fall back to OPENAI_API_KEY only for
+    # OpenAI-compatible proxies that may use a single shared key.
+    api_key = os.environ.get(key_var) or (
+        os.environ.get("OPENAI_API_KEY") if key_var == "OPENAI_API_KEY" else None
+    )
+    
+    return LLMEndpoint(model=model, base_url=base_url, api_key=api_key)

{praisonai-4.6.55 → praisonai-4.6.56}/praisonai/sandbox/subprocess.py

@@ -20,6 +20,7 @@ from praisonaiagents.sandbox import (
     SandboxStatus,
     ResourceLimits,
 )
+from praisonaiagents.sandbox.config import SecurityPolicy
 
 logger = logging.getLogger(__name__)
 
@@ -51,6 +52,48 @@ class SubprocessSandbox:
         self._is_running = False
         self._temp_dir: Optional[str] = None
     
+    def _build_child_env(self, policy: SecurityPolicy, overrides: Dict[str, str] | None) -> Dict[str, str]:
+        """Construct a minimal, policy-driven env for the child process."""
+        # Start with the explicit env from SandboxConfig and the per-call overrides only.
+        env = dict(self.config.env)
+        if overrides:
+            env.update(overrides)
+
+        # If the policy allows network, pass through proxy-related vars so the child can
+        # reach the outside world; otherwise withhold them.
+        if policy.allow_network:
+            for var in ("HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY", "http_proxy",
+                        "https_proxy", "no_proxy"):
+                if var in os.environ:
+                    env[var] = os.environ[var]
+
+        # Always pass a minimal PATH (so /usr/bin/python resolves) — never the host's.
+        env.setdefault("PATH", "/usr/local/bin:/usr/bin:/bin")
+        # HOME uses temp_dir which is set during start() - /tmp is defensive fallback  # noqa: S108
+        env.setdefault("HOME", self._temp_dir or "/tmp")
+        return env
+    
+    def _apply_rlimits(self, limits: ResourceLimits):
+        """Apply resource limits via POSIX setrlimit (Linux/macOS only)."""
+        if os.name != "posix":
+            logger.warning("Resource limits not supported on Windows - sandbox isolation is weaker")
+            return
+            
+        try:
+            import resource
+            if limits.memory_mb and limits.memory_mb > 0:
+                bytes_ = limits.memory_mb * 1024 * 1024
+                resource.setrlimit(resource.RLIMIT_AS, (bytes_, bytes_))
+            if limits.max_processes and limits.max_processes > 0:
+                resource.setrlimit(resource.RLIMIT_NPROC, (limits.max_processes, limits.max_processes))
+            if limits.max_open_files and limits.max_open_files > 0:
+                resource.setrlimit(resource.RLIMIT_NOFILE, (limits.max_open_files, limits.max_open_files))
+            # Note: RLIMIT_CPU is process CPU time, not wall clock time - timeout is handled separately
+        except ImportError:
+            logger.warning("Resource module not available - resource limits not enforced")
+        except (OSError, ValueError) as e:
+            logger.warning(f"Failed to set resource limits: {e}")
+    
     @property
     def is_available(self) -> bool:
         """Subprocess sandbox is always available."""
@@ -107,27 +150,43 @@ class SubprocessSandbox:
         else:
             cmd = ["python", code_file]
         
-        process_env = os.environ.copy()
-        if env:
-            process_env.update(env)
+        # Build environment based on security policy instead of copying host environment
+        process_env = self._build_child_env(self.config.security_policy, env)
         
         started_at = time.time()
         
+        # preexec_fn is POSIX-only; omit on Windows
+        popen_kwargs = {
+            "stdout": asyncio.subprocess.PIPE,
+            "stderr": asyncio.subprocess.PIPE,
+            "cwd": working_dir or self._temp_dir,
+            "env": process_env,
+        }
+        if os.name == "posix":
+            popen_kwargs["start_new_session"] = True
+            popen_kwargs["preexec_fn"] = lambda: self._apply_rlimits(limits)
+        else:
+            logger.warning("Resource limits and session isolation not available on Windows")
+
         try:
-            proc = await asyncio.create_subprocess_exec(
-                *cmd,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-                cwd=working_dir or self._temp_dir,
-                env=process_env,
-            )
+            proc = await asyncio.create_subprocess_exec(*cmd, **popen_kwargs)
             
             try:
+                # Truncate output to max_output_size after reading
+                max_output_size = self.config.security_policy.max_output_size
+                
                 stdout, stderr = await asyncio.wait_for(
                     proc.communicate(),
                     timeout=limits.timeout_seconds,
                 )
                 
+                # Truncate output if it exceeds max_output_size
+                if max_output_size and max_output_size > 0:
+                    if len(stdout) > max_output_size:
+                        stdout = stdout[:max_output_size] + b"\n[OUTPUT TRUNCATED]"
+                    if len(stderr) > max_output_size:
+                        stderr = stderr[:max_output_size] + b"\n[OUTPUT TRUNCATED]"
+                
                 completed_at = time.time()
                 
                 return SandboxResult(
@@ -141,7 +200,15 @@ class SubprocessSandbox:
                     completed_at=completed_at,
                 )
             except asyncio.TimeoutError:
-                proc.kill()
+                # Kill the whole process group, not just the leader
+                try:
+                    if os.name == "posix":
+                        import signal
+                        os.killpg(proc.pid, signal.SIGKILL)
+                    else:
+                        proc.kill()
+                except (ProcessLookupError, PermissionError, OSError):
+                    proc.kill()
                 await proc.wait()
                 
                 return SandboxResult(
@@ -211,20 +278,26 @@ class SubprocessSandbox:
         from ._shell import build_argv
         cmd = build_argv(command, shell=shell)
         
-        process_env = os.environ.copy()
-        if env:
-            process_env.update(env)
+        # Build environment based on security policy instead of copying host environment
+        process_env = self._build_child_env(self.config.security_policy, env)
         
         started_at = time.time()
         
+        # preexec_fn is POSIX-only; omit on Windows
+        popen_kwargs = {
+            "stdout": asyncio.subprocess.PIPE,
+            "stderr": asyncio.subprocess.PIPE,
+            "cwd": working_dir or self._temp_dir,
+            "env": process_env,
+        }
+        if os.name == "posix":
+            popen_kwargs["start_new_session"] = True
+            popen_kwargs["preexec_fn"] = lambda: self._apply_rlimits(limits)
+        else:
+            logger.warning("Resource limits and session isolation not available on Windows")
+
         try:
-            proc = await asyncio.create_subprocess_exec(
-                *cmd,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-                cwd=working_dir or self._temp_dir,
-                env=process_env,
-            )
+            proc = await asyncio.create_subprocess_exec(*cmd, **popen_kwargs)
             
             try:
                 stdout, stderr = await asyncio.wait_for(
@@ -232,6 +305,14 @@ class SubprocessSandbox:
                     timeout=limits.timeout_seconds,
                 )
                 
+                # Truncate output if it exceeds max_output_size
+                max_output_size = self.config.security_policy.max_output_size
+                if max_output_size and max_output_size > 0:
+                    if len(stdout) > max_output_size:
+                        stdout = stdout[:max_output_size] + b"\n[OUTPUT TRUNCATED]"
+                    if len(stderr) > max_output_size:
+                        stderr = stderr[:max_output_size] + b"\n[OUTPUT TRUNCATED]"
+                
                 completed_at = time.time()
                 
                 return SandboxResult(
@@ -245,7 +326,15 @@ class SubprocessSandbox:
                     completed_at=completed_at,
                 )
             except asyncio.TimeoutError:
-                proc.kill()
+                # Kill the whole process group, not just the leader
+                try:
+                    if os.name == "posix":
+                        import signal
+                        os.killpg(proc.pid, signal.SIGKILL)
+                    else:
+                        proc.kill()
+                except (ProcessLookupError, PermissionError, OSError):
+                    proc.kill()
                 await proc.wait()
                 
                 return SandboxResult(

praisonai-4.6.56/praisonai/version.py

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

{praisonai-4.6.55 → praisonai-4.6.56}/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=1.6.55",
+    "praisonaiagents>=1.6.56",
     "python-dotenv>=0.19.0",
     "litellm>=1.83.14,<2",
     "PyYAML>=6.0",