PraisonAI 4.6.54__tar.gz → 4.6.56__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.54
+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.54
+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.54 → praisonai-4.6.56}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.54
+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.54
+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.54 → 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.54 → 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.54
+praisonaiagents>=1.6.56
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.54 → praisonai-4.6.56}/praisonai/agents_generator.py

@@ -235,8 +235,9 @@ class AgentsGenerator:
         # CLI users get the process default.
         self._adapter_registry = adapter_registry or get_default_registry()
         
-        # Get framework adapter (availability already validated at CLI entry)
-        self.framework_adapter = self._get_framework_adapter(framework)
+        # Defer framework adapter creation until YAML is loaded
+        # This fixes the issue where empty framework string fails before YAML framework is read
+        self.framework_adapter = None
 
     def _get_framework_adapter(self, framework: str) -> FrameworkAdapter:
         """
@@ -281,7 +282,7 @@ class AgentsGenerator:
                 self.logger.debug(f"CLI override: lsp = {cli_config['lsp']}")
         
         # Handle agent-level overrides using unified approach
-        agent_level_fields = ['tool_timeout', 'planning_tools', 'autonomy', 'planning', 'web', 'web_fetch']
+        agent_level_fields = ['tool_timeout', 'tool_retry_policy', 'planning_tools', 'autonomy', 'planning', 'web', 'web_fetch']
         agent_overrides = {k: v for k, v in cli_config.items() if k in agent_level_fields}
         
         # Handle handoff configuration - convert CLI flags into handoff dict
@@ -377,7 +378,7 @@ class AgentsGenerator:
         
         # Select framework with AutoGen version logic
         framework = self._select_autogen_version(
-            self.framework or config.get('framework', 'crewai'),
+            self.framework or config.get('framework', 'praisonai'),
             config,
         )
         
@@ -537,8 +538,8 @@ class AgentsGenerator:
             'role', 'goal', 'instructions', 'backstory', 'tools', 'toolsets', 'tasks', 'llm',
             'function_calling_llm', 'allow_delegation', 'max_iter', 'max_rpm',
             'max_execution_time', 'verbose', 'cache', 'system_template',
-            'prompt_template', 'response_template', 'tool_timeout', 'planning_tools',
-            'planning', 'autonomy', 'guardrails', 'streaming', 'stream',
+            'prompt_template', 'response_template', 'tool_timeout', 'tool_retry_policy',
+            'planning_tools', 'planning', 'autonomy', 'guardrails', 'streaming', 'stream',
             'approval', 'skills', 'cli_backend', 'reflection', 'handoff', 'web', 'web_fetch'
         }
 

{praisonai-4.6.54 → 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.54 → 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:
@@ -1096,6 +1095,16 @@ class PraisonAI:
         parser.add_argument("--tool-timeout", type=int, default=60,
                           help="Timeout in seconds for each tool call (default: 60)")
         
+        # Tool retry policy - handle transient failures with exponential backoff
+        parser.add_argument("--tool-retry-attempts", type=int, default=3,
+                          help="Maximum retry attempts for tool failures (default: 3)")
+        parser.add_argument("--tool-retry-delay", type=int, default=1000,
+                          help="Initial retry delay in milliseconds (default: 1000)")
+        parser.add_argument("--tool-retry-backoff", type=float, default=2.0,
+                          help="Retry backoff multiplier (default: 2.0)")
+        parser.add_argument("--tool-retry-on", type=str, default="timeout,rate_limit,connection_error",
+                          help="Error types to retry (comma-separated, default: timeout,rate_limit,connection_error)")
+        
         # Tool Approval - control tool execution approval
         parser.add_argument("--trust", action="store_true", help="Auto-approve all tool executions (skip approval prompts)")
         parser.add_argument("--approve-level", type=str, choices=["low", "medium", "high", "critical"], 
@@ -4138,6 +4147,22 @@ Do NOT add any explanations or formatting."""
         tool_timeout = getattr(self.args, 'tool_timeout', None)
         if tool_timeout is not None:
             cli_config['tool_timeout'] = tool_timeout
+        
+        # Extract --tool-retry-* flags for retry policy
+        retry_attempts = getattr(self.args, 'tool_retry_attempts', 3)
+        retry_delay = getattr(self.args, 'tool_retry_delay', 1000)
+        retry_backoff = getattr(self.args, 'tool_retry_backoff', 2.0)
+        retry_on_str = getattr(self.args, 'tool_retry_on', "timeout,rate_limit,connection_error")
+        retry_on = set(error_type.strip() for error_type in retry_on_str.split(',') if error_type.strip())
+        
+        if retry_attempts > 1:  # Only create retry policy if retries are enabled
+            from praisonaiagents.tools.retry import RetryPolicy
+            cli_config['tool_retry_policy'] = RetryPolicy(
+                max_attempts=retry_attempts,
+                initial_delay_ms=retry_delay,
+                backoff_factor=retry_backoff,
+                retry_on=retry_on
+            )
             
         # Extract --planning-tools flag
         planning_tools = getattr(self.args, 'planning_tools', None)
@@ -4396,6 +4421,22 @@ Do NOT add any explanations or formatting."""
                 if tool_timeout and tool_timeout > 0:
                     agent_config["tool_timeout"] = tool_timeout
                 
+                # Tool retry policy - handle transient failures with exponential backoff
+                retry_attempts = getattr(self.args, 'tool_retry_attempts', 3)
+                retry_delay = getattr(self.args, 'tool_retry_delay', 1000)
+                retry_backoff = getattr(self.args, 'tool_retry_backoff', 2.0)
+                retry_on_str = getattr(self.args, 'tool_retry_on', "timeout,rate_limit,connection_error")
+                retry_on = set(error_type.strip() for error_type in retry_on_str.split(',') if error_type.strip())
+                
+                if retry_attempts > 1:  # Only create retry policy if retries are enabled
+                    from praisonaiagents.tools.retry import RetryPolicy
+                    agent_config["tool_retry_policy"] = RetryPolicy(
+                        max_attempts=retry_attempts,
+                        initial_delay_ms=retry_delay,
+                        backoff_factor=retry_backoff,
+                        retry_on=retry_on
+                    )
+                
                 # Memory
                 if getattr(self.args, 'memory', False):
                     memory_kwargs = {}

{praisonai-4.6.54 → 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.54 → 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.54 → 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.54 → 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)