PraisonAI 4.6.38__tar.gz → 4.6.40__tar.gz

{praisonai-4.6.38 → praisonai-4.6.40}/PKG-INFO

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

{praisonai-4.6.38 → praisonai-4.6.40}/PraisonAI.egg-info/PKG-INFO

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

{praisonai-4.6.38 → praisonai-4.6.40}/PraisonAI.egg-info/requires.txt

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

{praisonai-4.6.38 → praisonai-4.6.40}/praisonai/__init__.py

@@ -36,10 +36,34 @@ __all__ = [
 _telemetry_lock = threading.Lock()
 _telemetry_initialized = False
 
+def _get_telemetry_defaults() -> dict[str, str]:
+    """Get telemetry environment defaults without mutating os.environ.
+    
+    Returns:
+        Dict of environment variable defaults for telemetry
+    """
+    import os
+    defaults = {}
+    
+    # Respect any value the user already set
+    if "OTEL_SDK_DISABLED" not in os.environ:
+        langfuse_configured = bool(
+            os.getenv("LANGFUSE_PUBLIC_KEY")
+            or os.path.exists(os.path.expanduser("~/.praisonai/langfuse.env"))
+        )
+        defaults["OTEL_SDK_DISABLED"] = "false" if langfuse_configured else "true"
+    
+    if "EC_TELEMETRY" not in os.environ:
+        defaults["EC_TELEMETRY"] = "false"
+    
+    return defaults
+
+
 def _ensure_telemetry_defaults() -> None:
     """Apply telemetry env defaults exactly once, on first observability use.
     
     Thread-safe implementation using double-checked locking pattern.
+    DEPRECATED: Use _apply_telemetry_defaults() with explicit config instead.
     """
     global _telemetry_initialized
     if _telemetry_initialized:  # fast path, OK without lock
@@ -47,18 +71,21 @@ def _ensure_telemetry_defaults() -> None:
     with _telemetry_lock:
         if _telemetry_initialized:
             return
-        import os
-        # Respect any value the user already set
-        if "OTEL_SDK_DISABLED" not in os.environ:
-            langfuse_configured = bool(
-                os.getenv("LANGFUSE_PUBLIC_KEY")
-                or os.path.exists(os.path.expanduser("~/.praisonai/langfuse.env"))
-            )
-            os.environ["OTEL_SDK_DISABLED"] = "false" if langfuse_configured else "true"
-        os.environ.setdefault("EC_TELEMETRY", "false")  # respect user overrides
+        _apply_telemetry_defaults(_get_telemetry_defaults())
         _telemetry_initialized = True
 
 
+def _apply_telemetry_defaults(env_vars: dict[str, str]) -> None:
+    """Apply telemetry defaults to os.environ.
+    
+    Args:
+        env_vars: Dict of environment variables to set
+    """
+    import os
+    for key, value in env_vars.items():
+        os.environ.setdefault(key, value)
+
+
 # Lazy loading for heavy imports
 def __getattr__(name):
     """Lazy load heavy modules to improve import time."""

{praisonai-4.6.38 → praisonai-4.6.40}/praisonai/_registry.py

@@ -24,6 +24,7 @@ class PluginRegistry(Generic[T]):
     - Built-in plugins with lazy loading
     - Entry points discovery
     - Runtime registration
+    - Alias support for alternative names
     - Thread-safe operations
     """
 
@@ -41,6 +42,7 @@ class PluginRegistry(Generic[T]):
         """
         self._entry_point_group = entry_point_group
         self._items: Dict[str, Type[T]] = {}
+        self._aliases: Dict[str, str] = {}  # alias -> canonical name
         self._lock = threading.Lock()
         
         # Load built-in plugins with error handling
@@ -76,15 +78,29 @@ class PluginRegistry(Generic[T]):
             # entry_points() might not be available in older Python versions
             logger.debug("Entry points not available for group %s", self._entry_point_group)
 
-    def register(self, name: str, cls: Type[T]) -> None:
+    def register(
+        self, 
+        name: str, 
+        cls: Type[T], 
+        *, 
+        aliases: Optional[list[str]] = None
+    ) -> None:
         """Register a plugin at runtime.
         
         Args:
             name: Plugin name
             cls: Plugin class
+            aliases: Optional list of alias names for this plugin
         """
         with self._lock:
-            self._items[name.lower()] = cls
+            canonical_name = name.lower()
+            self._items[canonical_name] = cls
+            
+            # Register aliases
+            if aliases:
+                for alias in aliases:
+                    normalized_alias = alias.lower()
+                    self._aliases[normalized_alias] = canonical_name
 
     def unregister(self, name: str) -> bool:
         """Unregister a plugin.
@@ -96,7 +112,27 @@ class PluginRegistry(Generic[T]):
             True if plugin was found and removed, False otherwise
         """
         with self._lock:
-            return self._items.pop(name.lower(), None) is not None
+            normalized_name = name.lower()
+            
+            # Check if it's an alias
+            if normalized_name in self._aliases:
+                del self._aliases[normalized_name]
+                return True
+            
+            # Check if it's a canonical name
+            if normalized_name in self._items:
+                # Remove all aliases pointing to this plugin
+                aliases_to_remove = [
+                    alias for alias, canonical in self._aliases.items()
+                    if canonical == normalized_name
+                ]
+                for alias in aliases_to_remove:
+                    del self._aliases[alias]
+                
+                del self._items[normalized_name]
+                return True
+            
+            return False
 
     def resolve(self, name: str) -> Type[T]:
         """Resolve a plugin name to its class.
@@ -111,10 +147,20 @@ class PluginRegistry(Generic[T]):
             ValueError: If plugin is not found
         """
         with self._lock:
-            cls = self._items.get(name.lower())
+            normalized_name = name.lower()
+            
+            # Resolve alias to canonical name
+            canonical_name = self._aliases.get(normalized_name, normalized_name)
+            cls = self._items.get(canonical_name)
+            
             # Capture available plugins snapshot while holding lock
             # to avoid race condition between check and error message
-            available_snapshot = sorted(self._items.keys()) if cls is None else None
+            if cls is None:
+                available_plugins = sorted(self._items.keys())
+                available_aliases = sorted(self._aliases.keys())
+                available_snapshot = available_plugins + available_aliases
+            else:
+                available_snapshot = None
         
         if cls is None:
             raise ValueError(
@@ -161,4 +207,22 @@ class PluginRegistry(Generic[T]):
             self.resolve(name)
             return True
         except ValueError:
-            return False
+            return False
+
+    def list_aliases(self) -> Dict[str, str]:
+        """List all aliases and their target plugins.
+        
+        Returns:
+            Dict mapping alias -> canonical name
+        """
+        with self._lock:
+            return dict(self._aliases)
+
+    def list_all_names(self) -> list[str]:
+        """List all names including aliases.
+        
+        Returns:
+            Sorted list of all registered names and aliases
+        """
+        with self._lock:
+            return sorted(list(self._items.keys()) + list(self._aliases.keys()))

{praisonai-4.6.38 → praisonai-4.6.40}/praisonai/agents_generator.py

@@ -1172,9 +1172,9 @@ class AgentsGenerator:
         acp_enabled = global_config.get('acp', False)
         lsp_enabled = global_config.get('lsp', False)
         interactive_runtime = None
-        interactive_loop = None
         
         if acp_enabled or lsp_enabled:
+            runtime_started = False
             try:
                 import asyncio
                 from praisonai.cli.features.interactive_runtime import InteractiveRuntime, RuntimeConfig
@@ -1190,11 +1190,12 @@ class AgentsGenerator:
                 interactive_runtime = InteractiveRuntime(runtime_config)
                 self.logger.info(f"Starting InteractiveRuntime (ACP: {acp_enabled}, LSP: {lsp_enabled})")
                 
-                # Create a scoped event loop instead of modifying process globals
-                interactive_loop = asyncio.new_event_loop()
-                
-                # Start the runtime but keep it alive for agent execution
-                interactive_loop.run_until_complete(interactive_runtime.start())
+                # Runs on the persistent background loop; safe from sync and async callers.
+                # run_sync raises RuntimeError early if called from inside a running loop
+                # so the bug is loud instead of a deadlock.
+                from ._async_bridge import run_sync
+                run_sync(interactive_runtime.start())
+                runtime_started = True
                 
                 centric_tools = create_agent_centric_tools(interactive_runtime)
                 self.logger.info(f"Loaded {len(centric_tools)} InteractiveRuntime tools")
@@ -1203,13 +1204,20 @@ class AgentsGenerator:
             except ImportError as e:
                 self.logger.warning(f"Failed to load InteractiveRuntime components: {e}")
                 interactive_runtime = None
-                interactive_loop = None
+            except RuntimeError:
+                # Don't swallow RuntimeError from run_sync - preserve fail-fast semantics
+                raise
             except Exception as e:
+                if runtime_started and interactive_runtime is not None:
+                    try:
+                        from ._async_bridge import run_sync
+                        run_sync(interactive_runtime.stop())
+                    except Exception as stop_error:
+                        self.logger.error(
+                            f"Error stopping partially started InteractiveRuntime: {stop_error}"
+                        )
                 self.logger.error(f"Error starting InteractiveRuntime: {e}")
-                if 'interactive_loop' in locals() and interactive_loop is not None:
-                    interactive_loop.close()
                 interactive_runtime = None
-                interactive_loop = None
 
         # Create agents from config
         for role, details in config['roles'].items():
@@ -1443,14 +1451,13 @@ class AgentsGenerator:
             self.logger.debug(f"Result: {response}")
             result = response if response else ""
         finally:
-            if interactive_runtime and interactive_loop:
+            if interactive_runtime:
                 try:
                     self.logger.info("Stopping InteractiveRuntime...")
-                    interactive_loop.run_until_complete(interactive_runtime.stop())
+                    from ._async_bridge import run_sync
+                    run_sync(interactive_runtime.stop())
                 except Exception as e:
                     self.logger.error(f"Error stopping InteractiveRuntime: {e}")
-                finally:
-                    interactive_loop.close()
         
         if AGENTOPS_AVAILABLE:
             import agentops

{praisonai-4.6.38 → praisonai-4.6.40}/praisonai/api/agent_invoke.py

@@ -29,14 +29,26 @@ logger = logging.getLogger(__name__)
 # Authentication
 import os
 CALL_SERVER_TOKEN = os.getenv('CALL_SERVER_TOKEN')
+_CALL_AUTH_DISABLED = os.getenv('PRAISONAI_CALL_AUTH', '').lower() == 'disabled'
+
 
 async def verify_token(
     request: Request, 
     authorization: Optional[str] = Header(None)
 ) -> None:
     """Verify API token for authentication."""
-    if not FASTAPI_AVAILABLE or not CALL_SERVER_TOKEN:
-        return  # No authentication if FastAPI unavailable or no token set
+    if not FASTAPI_AVAILABLE:
+        return
+    if _CALL_AUTH_DISABLED:
+        return
+    if not CALL_SERVER_TOKEN:
+        raise HTTPException(
+            status_code=503,
+            detail=(
+                "CALL_SERVER_TOKEN is not configured. Set CALL_SERVER_TOKEN or "
+                "PRAISONAI_CALL_AUTH=disabled to run without authentication."
+            ),
+        )
         
     token = None
     

{praisonai-4.6.38 → praisonai-4.6.40}/praisonai/auto.py

@@ -15,9 +15,8 @@ from typing import Any, Dict, List, Optional, Type, TypeVar
 import os
 import json
 import yaml
-from rich import print
 import threading
-from collections import OrderedDict
+from rich import print
 from praisonai._logging import get_logger
 
 # Type variable for Pydantic models
@@ -59,10 +58,6 @@ def _load_optional(key: str, loader):
         return _optional_cache[key]
 
 
-# Bounded LRU cache for OpenAI clients (one per (api_key, base_url) tuple)
-_OPENAI_CLIENT_CACHE_MAX = 8
-_openai_clients: "OrderedDict[tuple, object]" = OrderedDict()
-_openai_clients_lock = threading.Lock()
 
 
 # --- CrewAI lazy loading ---
@@ -199,38 +194,6 @@ def _check_openai_available() -> bool:
     return result is not None
 
 
-def _get_openai_client(api_key: str = None, base_url: str = None):
-    """Lazy load OpenAI client with bounded LRU cache (thread-safe, multi-tenant).
-
-    Multi-tenant safe: each (api_key, base_url) tuple gets its own cached client.
-    Bounded by _OPENAI_CLIENT_CACHE_MAX with proper LRU eviction.
-    """
-    key = (api_key or os.environ.get("OPENAI_API_KEY"), base_url)
-
-    with _openai_clients_lock:
-        # Check if client exists and update LRU position
-        client = _openai_clients.get(key)
-        if client is not None:
-            _openai_clients.move_to_end(key)
-            return client
-
-        # Create new client
-        try:
-            from openai import OpenAI
-        except ImportError as e:
-            raise ImportError("Install with: pip install openai") from e
-        client = OpenAI(api_key=key[0], base_url=key[1])
-        _openai_clients[key] = client
-
-        # Bound the cache; close the LRU victim
-        if len(_openai_clients) > _OPENAI_CLIENT_CACHE_MAX:
-            _, victim = _openai_clients.popitem(last=False)
-            try:
-                victim.close()
-            except Exception:
-                pass  # Best-effort cleanup
-
-        return client
 
 
 # Use namespaced logger; root logger is configured only by the CLI
@@ -478,6 +441,38 @@ class BaseAutoGenerator:
                 'api_key': ep.api_key
             }
         ]
+        self._openai_client = None  # lazy, per-instance
+        self._openai_client_lock = threading.Lock()
+        
+    def _get_openai_client(self):
+        """Get or create the OpenAI client for this instance."""
+        if self._openai_client is None:
+            with self._openai_client_lock:
+                if self._openai_client is None:
+                    try:
+                        from openai import OpenAI
+                    except ImportError as e:
+                        raise ImportError("Install with: pip install openai") from e
+                    cfg = self.config_list[0]
+                    self._openai_client = OpenAI(
+                        api_key=cfg.get("api_key") or os.environ.get("OPENAI_API_KEY"),
+                        base_url=cfg.get("base_url"),
+                    )
+        return self._openai_client
+
+    def close(self):
+        """Close the OpenAI client if it exists."""
+        if not hasattr(self, '_openai_client_lock'):
+            return  # Object was never fully initialized
+        with self._openai_client_lock:
+            client = getattr(self, '_openai_client', None)
+            self._openai_client = None
+        if client is not None:
+            client.close()
+
+    def __del__(self):
+        """Best-effort cleanup, but the canonical path is explicit close()."""
+        self.close()
     
     def _structured_completion(self, response_model: Type[T], messages: List[Dict], **kwargs) -> T:
         """
@@ -514,10 +509,7 @@ class BaseAutoGenerator:
         
         # Fallback to OpenAI SDK (uses beta.chat.completions.parse)
         if _check_openai_available():
-            client = _get_openai_client(
-                api_key=self.config_list[0].get('api_key'),
-                base_url=self.config_list[0].get('base_url')
-            )
+            client = self._get_openai_client()
             response = client.beta.chat.completions.parse(
                 model=model_name,
                 messages=messages,
@@ -1537,4 +1529,4 @@ Generate a workflow for: {self.topic}
         with open(full_path, 'w') as f:
             yaml.dump(workflow_yaml, f, default_flow_style=False, sort_keys=False)
         
-        return full_path
+        return full_path

{praisonai-4.6.38 → praisonai-4.6.40}/praisonai/capabilities/guardrails.py

@@ -86,6 +86,8 @@ Only respond with the JSON, no other text."""
         )
         
         import json
+        if not response.choices or response.choices[0].message is None:
+            raise ValueError("LLM returned empty or filtered response")
         result_text = response.choices[0].message.content
         result_data = json.loads(result_text)
         
@@ -160,6 +162,8 @@ Only respond with the JSON, no other text."""
         )
         
         import json
+        if not response.choices or response.choices[0].message is None:
+            raise ValueError("LLM returned empty or filtered response")
         result_text = response.choices[0].message.content
         result_data = json.loads(result_text)
         

{praisonai-4.6.38 → praisonai-4.6.40}/praisonai/capabilities/rag.py

@@ -103,7 +103,7 @@ def rag_query(
         **kwargs
     )
     
-    answer = response.choices[0].message.content if response.choices else ""
+    answer = response.choices[0].message.content if response.choices and response.choices[0].message is not None else ""
     
     usage = None
     if hasattr(response, 'usage') and response.usage:
@@ -188,7 +188,7 @@ async def arag_query(
         **kwargs
     )
     
-    answer = response.choices[0].message.content if response.choices else ""
+    answer = response.choices[0].message.content if response.choices and response.choices[0].message is not None else ""
     
     usage = None
     if hasattr(response, 'usage') and response.usage:

{praisonai-4.6.38 → praisonai-4.6.40}/praisonai/cli_backends/registry.py

@@ -8,10 +8,36 @@ Plugin registry for CLI backend implementations following AGENTS.md patterns:
 
 import threading
 from typing import Dict, Callable, Any, Optional, Union
-
-# Thread-safe registry for CLI backend factories
-_REGISTRY: Dict[str, Callable[[], Any]] = {}
-_REGISTRY_LOCK = threading.Lock()
+from .._registry import PluginRegistry
+
+# CLI Backend Registry using canonical PluginRegistry
+def _get_builtin_cli_backend_loaders() -> Dict[str, Callable[[], Any]]:
+    """Get built-in CLI backend loaders."""
+    def claude_loader():
+        def factory():
+            from .claude import ClaudeCodeBackend
+            return ClaudeCodeBackend()
+        return factory
+    
+    return {
+        "claude-code": claude_loader
+    }
+
+# Global CLI backend registry instance
+_cli_backend_registry: Optional[PluginRegistry] = None
+_registry_lock = threading.Lock()
+
+def _get_cli_backend_registry() -> PluginRegistry:
+    """Get the CLI backend registry instance."""
+    global _cli_backend_registry
+    if _cli_backend_registry is None:
+        with _registry_lock:
+            if _cli_backend_registry is None:
+                _cli_backend_registry = PluginRegistry(
+                    entry_point_group="praisonai.cli_backends",
+                    builtins=_get_builtin_cli_backend_loaders()
+                )
+    return _cli_backend_registry
 
 
 def register_cli_backend(backend_id: str, factory: Callable[[], Any]) -> None:
@@ -21,14 +47,18 @@ def register_cli_backend(backend_id: str, factory: Callable[[], Any]) -> None:
         backend_id: Unique identifier (e.g., "claude-code", "codex-cli") 
         factory: Factory function that returns a CliBackendProtocol instance
     """
-    with _REGISTRY_LOCK:
-        _REGISTRY[backend_id] = factory
+    # Wrap factory in a loader function for PluginRegistry
+    def factory_loader():
+        return factory
+    
+    registry = _get_cli_backend_registry()
+    registry.register(backend_id, factory_loader)
 
 
 def list_cli_backends() -> list[str]:
     """List all registered CLI backend IDs."""
-    with _REGISTRY_LOCK:
-        return list(_REGISTRY.keys())
+    registry = _get_cli_backend_registry()
+    return registry.list_names()
 
 
 def resolve_cli_backend(
@@ -47,12 +77,15 @@ def resolve_cli_backend(
     Raises:
         ValueError: If backend_id is not registered
     """
-    with _REGISTRY_LOCK:
-        if backend_id not in _REGISTRY:
-            available = list(_REGISTRY.keys())
-            raise ValueError(f"Unknown CLI backend: {backend_id}. Available: {available}")
-        
-        factory = _REGISTRY[backend_id]
+    registry = _get_cli_backend_registry()
+    
+    try:
+        # Get the factory loader and create the factory
+        factory_loader = registry.resolve(backend_id)
+        factory = factory_loader()
+    except ValueError:
+        available = registry.list_names()
+        raise ValueError(f"Unknown CLI backend: {backend_id}. Available: {available}")
     
     # Create instance with factory
     backend = factory()
@@ -77,24 +110,4 @@ def resolve_cli_backend(
     return backend
 
 
-def _register_builtin_backends() -> None:
-    """Register built-in CLI backends (lazy loaded)."""
-    # Only register if not already done
-    with _REGISTRY_LOCK:
-        if "claude-code" in _REGISTRY:
-            return
-    
-    def claude_factory():
-        from .claude import ClaudeCodeBackend
-        return ClaudeCodeBackend()
-    
-    register_cli_backend("claude-code", claude_factory)
-
-
-# Auto-register built-in backends on first access
-def __getattr__(name: str):
-    """Lazy registration trigger."""
-    _register_builtin_backends()
-    raise AttributeError(f"No attribute {name}")
-
-# Registration happens lazily via __getattr__ on first attribute access
+# Built-in backends are now registered via _get_builtin_cli_backend_loaders()

{praisonai-4.6.38 → praisonai-4.6.40}/praisonai/code/tools/write_file.py

@@ -58,9 +58,10 @@ def write_file(
         >>> if result['success']:
         ...     print(f"Wrote to {result['path']}")
     """
-    # Resolve path
-    if workspace and not os.path.isabs(path):
-        abs_path = os.path.abspath(os.path.join(workspace, path))
+    # Resolve path — default workspace is cwd so relative paths cannot escape
+    effective_workspace = workspace or os.getcwd()
+    if not os.path.isabs(path):
+        abs_path = os.path.abspath(os.path.join(effective_workspace, path))
     else:
         abs_path = os.path.abspath(path)
     
@@ -73,14 +74,12 @@ def write_file(
             'path': path,
         }
 
-    # Security check - ensure path is within workspace if specified
-    if workspace:
-        if not is_path_within_directory(abs_path, workspace):
-            return {
-                'success': False,
-                'error': f"Path '{path}' is outside the workspace",
-                'path': path,
-            }
+    if not is_path_within_directory(abs_path, effective_workspace):
+        return {
+            'success': False,
+            'error': f"Path '{path}' is outside the workspace",
+            'path': path,
+        }
     
     # Process content
     processed_content = content