PraisonAI 4.6.30__tar.gz → 4.6.31__tar.gz

{praisonai-4.6.30 → praisonai-4.6.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.30
+Version: 4.6.31
 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.30
+Requires-Dist: praisonaiagents>=1.6.31
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<=1.82.6,>=1.81.0
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.30 → praisonai-4.6.31}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.30
+Version: 4.6.31
 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.30
+Requires-Dist: praisonaiagents>=1.6.31
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<=1.82.6,>=1.81.0
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.30 → praisonai-4.6.31}/PraisonAI.egg-info/requires.txt

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

{praisonai-4.6.30 → praisonai-4.6.31}/praisonai/__main__.py

@@ -72,6 +72,16 @@ def _find_first_command(argv):
 
 def _run_typer(argv):
     """Dispatch to the Typer CLI app."""
+    import os
+    
+    # Set up safer encoding for Windows legacy terminals
+    if sys.platform == "win32" and hasattr(sys.stdout, 'encoding'):
+        encoding = getattr(sys.stdout, 'encoding', '').lower()
+        if encoding in ('cp1252', 'cp1251', 'cp850', 'ascii') or ('cp' in encoding and encoding != 'cp65001'):
+            # Force UTF-8 mode for subprocess safety
+            if 'PYTHONIOENCODING' not in os.environ:
+                os.environ['PYTHONIOENCODING'] = 'utf-8'
+    
     from praisonai.cli.app import app, register_commands
     register_commands()  # idempotent
 
@@ -79,6 +89,11 @@ def _run_typer(argv):
     sys.argv = ["praisonai"] + list(argv)
     try:
         app()
+    except UnicodeEncodeError as e:
+        # Handle Unicode encoding errors gracefully
+        print("Error: Unable to display help due to terminal encoding limitations.", file=sys.stderr)
+        print("Try setting: $env:PYTHONIOENCODING='utf-8' (PowerShell) or set PYTHONIOENCODING=utf-8 (cmd)", file=sys.stderr)
+        sys.exit(0)
     except SystemExit as e:
         sys.exit(e.code if isinstance(e.code, int) else 0)
     finally:

{praisonai-4.6.30 → praisonai-4.6.31}/praisonai/cli/output/console.py

@@ -40,7 +40,36 @@ def _get_console():
     global _console
     if _console is None and _get_rich_available():
         from rich.console import Console
-        _console = Console()
+        import sys
+        import os
+        
+        # Detect Windows legacy encoding (CP1252) and use safe fallback
+        if sys.platform == "win32" and hasattr(sys.stdout, 'encoding'):
+            encoding = getattr(sys.stdout, 'encoding', '').lower()
+            # Check for Windows legacy code pages that can't handle Unicode
+            if encoding in ('cp1252', 'cp1251', 'cp850', 'ascii') or ('cp' in encoding and encoding != 'cp65001'):
+                # Force UTF-8 mode or create console with safe encoding handling
+                try:
+                    # Set PYTHONIOENCODING to utf-8 for subprocess safety (won't affect current process)
+                    if 'PYTHONIOENCODING' not in os.environ:
+                        os.environ['PYTHONIOENCODING'] = 'utf-8'
+                    
+                    # Create console with safe encoding options
+                    _console = Console(
+                        force_terminal=True,
+                        legacy_windows=True,  # Use legacy Windows mode
+                        safe_box=True,        # Use safe box characters
+                        emoji=False,          # Disable emojis on Windows legacy
+                        color_system='standard',  # Use basic colors
+                        _environ=os.environ   # Pass updated environment
+                    )
+                except Exception:
+                    # Fallback to basic console if Rich options fail
+                    _console = Console(force_terminal=False, no_color=True)
+            else:
+                _console = Console()
+        else:
+            _console = Console()
     return _console
 
 
@@ -137,6 +166,19 @@ class OutputController:
         """Check if in screen reader mode."""
         return self.mode == OutputMode.SCREEN_READER
     
+    def _safe_console_print(self, *args, **kwargs) -> None:
+        """Safely print to console with UnicodeEncodeError protection."""
+        if self.console:
+            try:
+                self.console.print(*args, **kwargs)
+            except UnicodeEncodeError:
+                # Fallback to plain text if Rich can't handle the encoding
+                message = str(args[0]) if args else ""
+                print(message.encode('ascii', 'replace').decode('ascii'))
+        else:
+            message = str(args[0]) if args else ""
+            print(message)
+    
     def print(self, message: str, style: Optional[str] = None, **kwargs) -> None:
         """Print a message respecting the current mode."""
         if self.is_quiet:
@@ -150,11 +192,8 @@ class OutputController:
             # Plain text output
             print(message)
         else:
-            # Rich formatted output
-            if self.console:
-                self.console.print(message, style=style, **kwargs)
-            else:
-                print(message)
+            # Rich formatted output with encoding safety
+            self._safe_console_print(message, style=style, **kwargs)
     
     def print_error(self, message: str, code: Optional[str] = None, remediation: Optional[str] = None) -> None:
         """Print an error message with optional remediation."""
@@ -187,10 +226,16 @@ class OutputController:
             if remediation:
                 content.append(f"\n💡 Fix: {remediation}", style="yellow")
             
-            if self.console:
-                self.console.print(Panel(content, title="Error", border_style="red"))
-            else:
+            try:
+                if self.console:
+                    self.console.print(Panel(content, title="Error", border_style="red"))
+                else:
+                    print(f"ERROR: {message}", file=sys.stderr)
+            except UnicodeEncodeError:
+                # Fallback to plain text if emoji rendering fails
                 print(f"ERROR: {message}", file=sys.stderr)
+                if remediation:
+                    print(f"FIX: {remediation}", file=sys.stderr)
     
     def print_success(self, message: str, data: Optional[Dict[str, Any]] = None) -> None:
         """Print a success message."""
@@ -214,7 +259,10 @@ class OutputController:
         if self.is_screen_reader or self.no_color or not _get_rich_available():
             print(f"SUCCESS: {message}")
         else:
-            self.print(f"✅ {message}", style="bold green")
+            try:
+                self.print(f"✅ {message}", style="bold green")
+            except UnicodeEncodeError:
+                print(f"SUCCESS: {message}")
     
     def print_warning(self, message: str) -> None:
         """Print a warning message."""
@@ -224,7 +272,10 @@ class OutputController:
         if self.is_screen_reader or self.no_color or not _get_rich_available():
             print(f"WARNING: {message}")
         else:
-            self.print(f"⚠️  {message}", style="bold yellow")
+            try:
+                self.print(f"⚠️  {message}", style="bold yellow")
+            except UnicodeEncodeError:
+                print(f"WARNING: {message}")
     
     def print_info(self, message: str) -> None:
         """Print an info message."""
@@ -234,7 +285,10 @@ class OutputController:
         if self.is_screen_reader or self.no_color or not _get_rich_available():
             print(f"INFO: {message}")
         else:
-            self.print(f"ℹ️  {message}", style="bold blue")
+            try:
+                self.print(f"ℹ️  {message}", style="bold blue")
+            except UnicodeEncodeError:
+                print(f"INFO: {message}")
     
     def print_debug(self, message: str) -> None:
         """Print a debug message (only in verbose mode)."""
@@ -244,7 +298,10 @@ class OutputController:
         if self.is_screen_reader or self.no_color or not _get_rich_available():
             print(f"DEBUG: {message}")
         else:
-            self.print(f"🔍 {message}", style="dim")
+            try:
+                self.print(f"🔍 {message}", style="dim")
+            except UnicodeEncodeError:
+                print(f"DEBUG: {message}")
     
     def emit_event(self, event_type: str, message: Optional[str] = None, data: Optional[Dict[str, Any]] = None, agent_id: Optional[str] = None) -> None:
         """Emit a stream event (for stream-json mode)."""
@@ -321,7 +378,28 @@ class OutputController:
                 table.add_row(*[str(cell) for cell in row])
             
             if self.console:
-                self.console.print(table)
+                try:
+                    self.console.print(table)
+                except UnicodeEncodeError:
+                    # Fallback to plain text table if Rich fails
+                    if title:
+                        print(f"\n{title}")
+                        print("-" * len(title))
+                    
+                    # Calculate column widths
+                    widths = [len(h) for h in headers]
+                    for row in rows:
+                        for i, cell in enumerate(row):
+                            widths[i] = max(widths[i], len(str(cell)))
+                    
+                    # Print header
+                    header_line = " | ".join(h.ljust(widths[i]) for i, h in enumerate(headers))
+                    print(header_line)
+                    print("-" * len(header_line))
+                    
+                    # Print rows
+                    for row in rows:
+                        print(" | ".join(str(cell).ljust(widths[i]) for i, cell in enumerate(row)))
     
     def print_panel(self, content: str, title: Optional[str] = None, style: str = "cyan") -> None:
         """Print a panel."""
@@ -338,7 +416,15 @@ class OutputController:
             from rich.panel import Panel
             
             if self.console:
-                self.console.print(Panel(content, title=title, border_style=style))
+                try:
+                    self.console.print(Panel(content, title=title, border_style=style))
+                except UnicodeEncodeError:
+                    # Fallback to plain text if panel rendering fails
+                    if title:
+                        print(f"\n=== {title} ===")
+                    print(content)
+                    if title:
+                        print("=" * (len(title) + 8))
     
     def get_events(self) -> List[Dict[str, Any]]:
         """Get all collected events."""

{praisonai-4.6.30 → praisonai-4.6.31}/praisonai/deploy.py

@@ -57,7 +57,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==4.6.30 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==4.6.31 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

{praisonai-4.6.30 → praisonai-4.6.31}/praisonai/inc/models.py

@@ -13,12 +13,24 @@ logging.basicConfig(level=_loglevel, format='%(asctime)s - %(levelname)s - %(mes
 # Constants
 LOCAL_SERVER_API_KEY_PLACEHOLDER = "not-needed"
 
+def _is_module_available(module_name: str) -> bool:
+    """Safely check if a module spec is importable.
+
+    Guards against missing parent packages (e.g. `google.generativeai`
+    when the `google` namespace is absent) so test collection in a
+    base install does not fail.
+    """
+    try:
+        return importlib.util.find_spec(module_name) is not None
+    except (ImportError, AttributeError, ValueError):
+        return False
+
 # Use find_spec for fast availability checks (no actual import)
 # This avoids the ~3200ms langchain_openai import at module load
-OPENAI_AVAILABLE = importlib.util.find_spec("openai") is not None
-GOOGLE_GENAI_AVAILABLE = importlib.util.find_spec("google.generativeai") is not None
-ANTHROPIC_AVAILABLE = importlib.util.find_spec("anthropic") is not None
-COHERE_AVAILABLE = importlib.util.find_spec("cohere") is not None
+OPENAI_AVAILABLE = _is_module_available("openai")
+GOOGLE_GENAI_AVAILABLE = _is_module_available("google.generativeai")
+ANTHROPIC_AVAILABLE = _is_module_available("anthropic")
+COHERE_AVAILABLE = _is_module_available("cohere")
 
 # Lazy import helpers for provider SDKs
 def _get_openai_client():

praisonai-4.6.31/praisonai/ui/_aiui_datastore.py

@@ -0,0 +1,141 @@
+"""Bridge praisonaiagents SessionStore → aiui BaseDataStore.
+
+Allows any SessionStoreProtocol implementation (file/Redis/Mongo) to back
+the aiui dashboard's Sessions page. No Chainlit required.
+"""
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+# Module-level cached implementation class
+_impl_cls = None
+
+
+def _build_impl_cls():
+    """Build the implementation class with BaseDataStore inheritance.
+    
+    Thread-safe lazy class factory that imports BaseDataStore and creates
+    a proper subclass. This avoids runtime __bases__ mutation and ensures
+    BaseDataStore.__init__ is properly called.
+    """
+    global _impl_cls
+    if _impl_cls is not None:
+        return _impl_cls
+    
+    try:
+        from praisonaiui.datastore import BaseDataStore
+    except ImportError as e:
+        raise ImportError(
+            "praisonaiui is required for PraisonAISessionDataStore. "
+            "Install with: pip install 'praisonai[ui]'"
+        ) from e
+    
+    try:
+        from praisonaiagents.session import get_hierarchical_session_store
+    except ImportError as e:
+        raise ImportError(
+            "praisonaiagents is required for PraisonAISessionDataStore. "
+            "Install with: pip install praisonaiagents"
+        ) from e
+
+    class _PraisonAISessionDataStoreImpl(BaseDataStore):
+        """Implementation class that properly inherits from BaseDataStore."""
+        
+        def __init__(self, store: Optional[Any] = None):
+            """Initialize with an optional session store, defaults to hierarchical store.
+            
+            Args:
+                store: Optional SessionStoreProtocol implementation
+            """
+            super().__init__()  # Properly call BaseDataStore.__init__()
+            self._store = store or get_hierarchical_session_store()
+
+        def _new_id(self) -> str:
+            """Generate a new session ID."""
+            return str(uuid.uuid4())
+
+        async def list_sessions(self) -> list[dict[str, Any]]:
+            """List all available sessions."""
+            # Check if store supports listing (DefaultSessionStore/HierarchicalSessionStore do)
+            list_fn = getattr(self._store, "list_sessions", None)
+            if list_fn is None:
+                return []  # Protocol implementation doesn't support listing
+            
+            try:
+                # DefaultSessionStore/HierarchicalSessionStore return list[dict]
+                return list_fn(limit=50) or []
+            except Exception:
+                logger.exception("Failed to list sessions")
+                return []
+
+        async def get_session(self, session_id: str) -> Optional[dict[str, Any]]:
+            """Get a specific session by ID."""
+            if not self._store.session_exists(session_id):
+                return None
+            
+            try:
+                chat_history = self._store.get_chat_history(session_id)
+                return {
+                    "id": session_id,
+                    "messages": chat_history or [],
+                }
+            except Exception:
+                logger.exception("Failed to load session %s", session_id)
+                return None
+
+        async def create_session(self, session_id: Optional[str] = None) -> dict[str, Any]:
+            """Create a new session."""
+            sid = session_id or self._new_id()
+            # Sessions are created lazily on first add_message
+            return {
+                "id": sid,
+                "messages": []
+            }
+
+        async def delete_session(self, session_id: str) -> bool:
+            """Delete a session and return success status."""
+            try:
+                return self._store.delete_session(session_id)
+            except Exception:
+                logger.exception("Failed to delete session %s", session_id)
+                return False
+
+        async def add_message(self, session_id: str, message: dict[str, Any]):
+            """Add a message to a session."""
+            self._store.add_message(
+                session_id=session_id,
+                role=message.get("role", "user"),
+                content=message.get("content", ""),
+                metadata=message.get("metadata")
+            )
+
+        async def get_messages(self, session_id: str) -> list[dict[str, Any]]:
+            """Get all messages for a session."""
+            if not self._store.session_exists(session_id):
+                return []
+            
+            try:
+                return self._store.get_chat_history(session_id) or []
+            except Exception:
+                logger.exception("Failed to load messages for session %s", session_id)
+                return []
+
+    _impl_cls = _PraisonAISessionDataStoreImpl
+    return _impl_cls
+
+
+class PraisonAISessionDataStore:
+    """Adapter that bridges PraisonAI SessionStoreProtocol to aiui BaseDataStore.
+    
+    Dependency imports are deferred until instantiation to allow test
+    collection without optional modules installed.
+    """
+    
+    def __new__(cls, store: Optional[Any] = None):
+        """Factory method that returns a properly configured implementation instance."""
+        impl_cls = _build_impl_cls()
+        return impl_cls(store)

praisonai-4.6.31/praisonai/version.py

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

{praisonai-4.6.30 → praisonai-4.6.31}/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=1.6.30",
+    "praisonaiagents>=1.6.31",
     "python-dotenv>=0.19.0",
     "litellm>=1.81.0,<=1.82.6",
     "PyYAML>=6.0",

praisonai-4.6.30/praisonai/ui/_aiui_datastore.py

@@ -1,108 +0,0 @@
-"""Bridge praisonaiagents SessionStore → aiui BaseDataStore.
-
-Allows any SessionStoreProtocol implementation (file/Redis/Mongo) to back
-the aiui dashboard's Sessions page. No Chainlit required.
-"""
-from __future__ import annotations
-
-import logging
-import uuid
-from typing import Any, Optional
-
-logger = logging.getLogger(__name__)
-
-# Fail loudly on missing optional dependencies per AGENTS.md §4.2
-try:
-    from praisonaiui.datastore import BaseDataStore
-except ImportError as e:
-    raise ImportError(
-        "praisonaiui is required for PraisonAISessionDataStore. "
-        "Install with: pip install 'praisonai[ui]'"
-    ) from e
-
-try:
-    from praisonaiagents.session import SessionStoreProtocol
-    from praisonaiagents.session import get_hierarchical_session_store
-except ImportError as e:
-    raise ImportError(
-        "praisonaiagents is required for PraisonAISessionDataStore. "
-        "Install with: pip install praisonaiagents"
-    ) from e
-
-
-class PraisonAISessionDataStore(BaseDataStore):
-    """Adapter that bridges PraisonAI SessionStoreProtocol to aiui BaseDataStore."""
-    
-    def __init__(self, store: Optional[SessionStoreProtocol] = None):
-        """Initialize with an optional session store, defaults to hierarchical store."""
-        self._store = store or get_hierarchical_session_store()
-
-    def _new_id(self) -> str:
-        """Generate a new session ID."""
-        return str(uuid.uuid4())
-
-    async def list_sessions(self) -> list[dict[str, Any]]:
-        """List all available sessions."""
-        # Check if store supports listing (DefaultSessionStore/HierarchicalSessionStore do)
-        list_fn = getattr(self._store, "list_sessions", None)
-        if list_fn is None:
-            return []  # Protocol implementation doesn't support listing
-        
-        try:
-            # DefaultSessionStore/HierarchicalSessionStore return list[dict]
-            return list_fn(limit=50) or []
-        except Exception:
-            logger.exception("Failed to list sessions")
-            return []
-
-    async def get_session(self, session_id: str) -> Optional[dict[str, Any]]:
-        """Get a specific session by ID."""
-        if not self._store.session_exists(session_id):
-            return None
-        
-        try:
-            chat_history = self._store.get_chat_history(session_id)
-            return {
-                "id": session_id,
-                "messages": chat_history or [],
-            }
-        except Exception:
-            logger.exception("Failed to load session %s", session_id)
-            return None
-
-    async def create_session(self, session_id: Optional[str] = None) -> dict[str, Any]:
-        """Create a new session."""
-        sid = session_id or self._new_id()
-        # Sessions are created lazily on first add_message
-        return {
-            "id": sid,
-            "messages": []
-        }
-
-    async def delete_session(self, session_id: str) -> bool:
-        """Delete a session and return success status."""
-        try:
-            return self._store.delete_session(session_id)
-        except Exception:
-            logger.exception("Failed to delete session %s", session_id)
-            return False
-
-    async def add_message(self, session_id: str, message: dict[str, Any]):
-        """Add a message to a session."""
-        self._store.add_message(
-            session_id=session_id,
-            role=message.get("role", "user"),
-            content=message.get("content", ""),
-            metadata=message.get("metadata")
-        )
-
-    async def get_messages(self, session_id: str) -> list[dict[str, Any]]:
-        """Get all messages for a session."""
-        if not self._store.session_exists(session_id):
-            return []
-        
-        try:
-            return self._store.get_chat_history(session_id) or []
-        except Exception:
-            logger.exception("Failed to load messages for session %s", session_id)
-            return []

praisonai-4.6.30/praisonai/version.py

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