PraisonAI 4.6.22__tar.gz → 4.6.23__tar.gz

{praisonai-4.6.22 → praisonai-4.6.23}/PKG-INFO

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

{praisonai-4.6.22 → praisonai-4.6.23}/PraisonAI.egg-info/PKG-INFO

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

{praisonai-4.6.22 → praisonai-4.6.23}/PraisonAI.egg-info/SOURCES.txt

@@ -617,6 +617,9 @@ praisonai/persistence/state/redis.py
 praisonai/persistence/state/upstash.py
 praisonai/persistence/tests/__init__.py
 praisonai/persistence/tests/test_all_backends.py
+praisonai/push/__init__.py
+praisonai/push/client.py
+praisonai/push/transports.py
 praisonai/recipe/__init__.py
 praisonai/recipe/bridge.py
 praisonai/recipe/core.py
@@ -651,6 +654,7 @@ praisonai/scheduler/agent_scheduler.py
 praisonai/scheduler/base.py
 praisonai/scheduler/daemon_manager.py
 praisonai/scheduler/executor.py
+praisonai/scheduler/shared.py
 praisonai/scheduler/state_manager.py
 praisonai/scheduler/yaml_loader.py
 praisonai/security/__init__.py

{praisonai-4.6.22 → praisonai-4.6.23}/PraisonAI.egg-info/requires.txt

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

{praisonai-4.6.22 → praisonai-4.6.23}/praisonai/__init__.py

@@ -2,16 +2,6 @@
 import logging
 logging.getLogger('crewai.cli.config').setLevel(logging.ERROR)
 
-# Disable OpenTelemetry SDK only when Langfuse is NOT configured
-# (Langfuse v4 requires OTel internally for tracing)
-import os
-_langfuse_configured = bool(os.getenv("LANGFUSE_PUBLIC_KEY") or os.path.exists(
-    os.path.expanduser("~/.praisonai/langfuse.env")
-))
-if not _langfuse_configured:
-    os.environ.setdefault("OTEL_SDK_DISABLED", "true")
-os.environ["EC_TELEMETRY"] = "false"
-
 # Version is lightweight, import directly
 from .version import __version__
 
@@ -36,10 +26,34 @@ __all__ = [
     'LocalManagedConfig',
 ]
 
+# Telemetry initialization state
+_telemetry_initialized = False
+
+def _ensure_telemetry_defaults() -> None:
+    """Apply telemetry env defaults exactly once, on first observability use."""
+    global _telemetry_initialized
+    if _telemetry_initialized:
+        return
+    import os
+    langfuse_configured = bool(
+        os.getenv("LANGFUSE_PUBLIC_KEY")
+        or os.path.exists(os.path.expanduser("~/.praisonai/langfuse.env"))
+    )
+    if langfuse_configured:
+        # Explicitly enable OTEL for Langfuse integration
+        os.environ["OTEL_SDK_DISABLED"] = "false"
+    else:
+        os.environ.setdefault("OTEL_SDK_DISABLED", "true")
+    os.environ.setdefault("EC_TELEMETRY", "false")  # respect user overrides
+    _telemetry_initialized = True
+
 
 # Lazy loading for heavy imports
 def __getattr__(name):
     """Lazy load heavy modules to improve import time."""
+    # Ensure telemetry defaults before any lazy import that may touch OTEL.
+    _ensure_telemetry_defaults()
+
     if name == 'PraisonAI':
         from .cli import PraisonAI
         return PraisonAI

{praisonai-4.6.22 → praisonai-4.6.23}/praisonai/agent_scheduler.py

@@ -29,52 +29,8 @@ from abc import ABC, abstractmethod
 logger = logging.getLogger(__name__)
 
 
-class ScheduleParser:
-    """Parse schedule expressions into intervals."""
-    
-    @staticmethod
-    def parse(schedule_expr: str) -> int:
-        """
-        Parse schedule expression and return interval in seconds.
-        
-        Supported formats:
-        - "daily" -> 86400 seconds
-        - "hourly" -> 3600 seconds
-        - "*/30m" -> 1800 seconds (every 30 minutes)
-        - "*/1h" -> 3600 seconds (every 1 hour)
-        - "60" -> 60 seconds (plain number)
-        
-        Args:
-            schedule_expr: Schedule expression string
-            
-        Returns:
-            Interval in seconds
-            
-        Raises:
-            ValueError: If schedule format is not supported
-        """
-        schedule_expr = schedule_expr.strip().lower()
-        
-        if schedule_expr == "daily":
-            return 86400
-        elif schedule_expr == "hourly":
-            return 3600
-        elif schedule_expr.isdigit():
-            return int(schedule_expr)
-        elif schedule_expr.startswith("*/"):
-            interval_part = schedule_expr[2:]
-            if interval_part.endswith("m"):
-                minutes = int(interval_part[:-1])
-                return minutes * 60
-            elif interval_part.endswith("h"):
-                hours = int(interval_part[:-1])
-                return hours * 3600
-            elif interval_part.endswith("s"):
-                return int(interval_part[:-1])
-            else:
-                return int(interval_part)
-        else:
-            raise ValueError(f"Unsupported schedule format: {schedule_expr}")
+# Import shared schedule parser
+from .scheduler.shared import ScheduleParser, backoff_delay, safe_call
 
 
 class AgentExecutorInterface(ABC):
@@ -268,8 +224,8 @@ class AgentScheduler:
     def _execute_with_retry(self, max_retries: int):
         """Execute agent with retry logic."""
         self._execution_count += 1
-        success = False
         
+        last_exc: Optional[Exception] = None
         for attempt in range(max_retries):
             try:
                 logger.info(f"Attempt {attempt + 1}/{max_retries}")
@@ -279,27 +235,25 @@ class AgentScheduler:
                 logger.info(f"Result: {result}")
                 
                 self._success_count += 1
-                success = True
-                
-                if self.on_success:
-                    self.on_success(result)
-                    
-                break
+                safe_call(self.on_success, result)
+                return
                 
             except Exception as e:
+                last_exc = e
                 logger.error(f"Agent execution failed on attempt {attempt + 1}: {e}")
                 
                 if attempt < max_retries - 1:
-                    wait_time = 30 * (attempt + 1)  # Exponential backoff
+                    wait_time = backoff_delay(attempt)
                     logger.info(f"Waiting {wait_time}s before retry...")
                     time.sleep(wait_time)
         
-        if not success:
-            self._failure_count += 1
-            logger.error(f"Agent execution failed after {max_retries} attempts")
-            
-            if self.on_failure:
-                self.on_failure(f"Failed after {max_retries} attempts")
+        self._failure_count += 1
+        logger.error(f"Agent execution failed after {max_retries} attempts")
+        safe_call(
+            self.on_failure,
+            last_exc if last_exc is not None
+            else RuntimeError(f"Failed after {max_retries} attempts")
+        )
     
     def execute_once(self) -> Any:
         """

{praisonai-4.6.22 → praisonai-4.6.23}/praisonai/async_agent_scheduler.py

@@ -11,55 +11,10 @@ from datetime import datetime
 from typing import Optional, Dict, Any, Callable, Union
 from abc import ABC, abstractmethod
 
-logger = logging.getLogger(__name__)
-
+# Import shared schedule parser
+from .scheduler.shared import ScheduleParser, backoff_delay, safe_call
 
-class AsyncScheduleParser:
-    """Parse schedule expressions into intervals for async execution."""
-    
-    @staticmethod
-    def parse(schedule_expr: str) -> int:
-        """
-        Parse schedule expression and return interval in seconds.
-        
-        Supported formats:
-        - "daily" -> 86400 seconds
-        - "hourly" -> 3600 seconds
-        - "*/30m" -> 1800 seconds (every 30 minutes)
-        - "*/1h" -> 3600 seconds (every 1 hour)
-        - "60" -> 60 seconds (plain number)
-        
-        Args:
-            schedule_expr: Schedule expression string
-            
-        Returns:
-            Interval in seconds
-            
-        Raises:
-            ValueError: If schedule format is not supported
-        """
-        schedule_expr = schedule_expr.strip().lower()
-        
-        if schedule_expr == "daily":
-            return 86400
-        elif schedule_expr == "hourly":
-            return 3600
-        elif schedule_expr.isdigit():
-            return int(schedule_expr)
-        elif schedule_expr.startswith("*/"):
-            interval_part = schedule_expr[2:]
-            if interval_part.endswith("m"):
-                minutes = int(interval_part[:-1])
-                return minutes * 60
-            elif interval_part.endswith("h"):
-                hours = int(interval_part[:-1])
-                return hours * 3600
-            elif interval_part.endswith("s"):
-                return int(interval_part[:-1])
-            else:
-                return int(interval_part)
-        else:
-            raise ValueError(f"Unsupported schedule format: {schedule_expr}")
+logger = logging.getLogger(__name__)
 
 
 class AsyncAgentExecutorInterface(ABC):
@@ -143,15 +98,24 @@ class AsyncAgentScheduler:
         self.on_failure = on_failure
         
         self._is_running = False
-        self._cancel_event = asyncio.Event()
         self._task_handle: Optional[asyncio.Task] = None
         self._executor = AsyncPraisonAgentExecutor(agent)
         
-        # Thread-safe counters using asyncio.Lock
+        # Counters
         self._execution_count = 0
         self._success_count = 0  
         self._failure_count = 0
-        self._stats_lock = asyncio.Lock()
+        
+        # Created lazily on first async entry — binds to the caller's loop
+        self._cancel_event: Optional[asyncio.Event] = None
+        self._stats_lock: Optional[asyncio.Lock] = None
+        
+    def _ensure_async_primitives(self) -> None:
+        """Create async primitives if they don't exist yet."""
+        if self._cancel_event is None:
+            self._cancel_event = asyncio.Event()
+        if self._stats_lock is None:
+            self._stats_lock = asyncio.Lock()
         
     async def start(
         self,
@@ -164,7 +128,8 @@ class AsyncAgentScheduler:
         
         Args:
             schedule_expr: Schedule expression (e.g., "hourly", "*/1h", "3600")
-            max_retries: Maximum retry attempts on failure
+            max_retries: Maximum total execution attempts (including the first).
+                A value of 3 means 1 initial attempt + up to 2 retries.
             run_immediately: If True, run agent immediately before starting schedule
             
         Returns:
@@ -174,8 +139,10 @@ class AsyncAgentScheduler:
             logger.warning("Scheduler is already running")
             return False
             
+        self._ensure_async_primitives()
+        
         try:
-            interval = AsyncScheduleParser.parse(schedule_expr)
+            interval = ScheduleParser.parse(schedule_expr)
             self._is_running = True
             self._cancel_event.clear()
             
@@ -244,6 +211,7 @@ class AsyncAgentScheduler:
         Returns:
             Dictionary with execution stats
         """
+        self._ensure_async_primitives()
         async with self._stats_lock:
             return {
                 "is_running": self._is_running,
@@ -296,20 +264,16 @@ class AsyncAgentScheduler:
         async with self._stats_lock:
             self._execution_count += 1
             
-        for attempt in range(max_retries + 1):
+        last_exc: Optional[Exception] = None
+        for attempt in range(max_retries):
             try:
-                logger.info(f"Executing agent task (attempt {attempt + 1}/{max_retries + 1})")
+                logger.info(f"Executing agent task (attempt {attempt + 1}/{max_retries})")
                 result = await self._executor.execute(self.task)
                 
                 async with self._stats_lock:
                     self._success_count += 1
                     
-                if self.on_success:
-                    try:
-                        self.on_success(result)
-                    except Exception as e:
-                        logger.error(f"Error in success callback: {e}")
-                        
+                safe_call(self.on_success, result)
                 logger.info("Agent task executed successfully")
                 return
                 
@@ -317,27 +281,27 @@ class AsyncAgentScheduler:
                 logger.info("Agent execution cancelled")
                 raise
             except Exception as e:
+                last_exc = e
                 logger.error(f"Agent execution failed on attempt {attempt + 1}: {e}")
-                if attempt == max_retries:
-                    # Final attempt failed
-                    async with self._stats_lock:
-                        self._failure_count += 1
-                        
-                    if self.on_failure:
-                        try:
-                            self.on_failure(e)
-                        except Exception as callback_error:
-                            logger.error(f"Error in failure callback: {callback_error}")
-                    break
-                else:
+                if attempt < max_retries - 1:
                     # Wait before retry (with cancellation support)
                     try:
                         await asyncio.wait_for(
                             self._cancel_event.wait(), 
-                            timeout=min(2 ** attempt, 60)  # Exponential backoff, max 60s
+                            timeout=backoff_delay(attempt)
                         )
                         # If we get here, cancellation was requested
                         raise asyncio.CancelledError()
                     except asyncio.TimeoutError:
                         # Timeout is expected - continue to retry
-                        continue
+                        continue
+        
+        # Final attempt failed
+        async with self._stats_lock:
+            self._failure_count += 1
+            
+        safe_call(
+            self.on_failure,
+            last_exc if last_exc is not None
+            else RuntimeError(f"Failed after {max_retries} attempts")
+        )

{praisonai-4.6.22 → praisonai-4.6.23}/praisonai/capabilities/skills.py

@@ -132,3 +132,64 @@ async def askill_load(
         metadata=metadata,
         **kwargs
     )
+
+
+def tool_from_skill(path: str):
+    """Convert a skill to a tool function for direct tool registry integration.
+    
+    This adapter allows users who prefer "skill = tool" ergonomics to
+    drop a SKILL.md into an existing tool registry without refactoring.
+    
+    Args:
+        path: Path to the skill directory containing SKILL.md
+        
+    Returns:
+        A function decorated with @tool that renders the skill body
+        
+    Example:
+        # Convert a skill to a tool
+        pdf_tool = tool_from_skill("./skills/pdf-processing")
+        
+        # Add to existing tool registry
+        agent = Agent(tools=[pdf_tool, other_tools])
+    """
+    from pathlib import Path
+    try:
+        from praisonaiagents.skills import load_skill, render_skill_body
+        from praisonaiagents.tools import tool
+        
+        # Load the skill
+        skill_name = Path(path).name
+        skill_dirs = [str(Path(path).parent)]
+        loaded = load_skill(skill_name, skill_dirs)
+        
+        if loaded is None:
+            raise ValueError(f"Skill not found at path: {path}")
+        
+        # Create the tool function with proper metadata and argument handling
+        safe_name = skill_name.replace('-', '_').replace(' ', '_')
+        description = loaded.properties.description or f"Execute {skill_name} skill"
+
+        def _skill_tool(arguments: str = "") -> str:
+            """Execute skill with provided arguments."""
+            if loaded.instructions is None:
+                return f"Skill '{skill_name}' has no instructions"
+
+            # Return the skill instructions with argument substitution
+            return render_skill_body(loaded.instructions, arguments)
+
+        # Set dunder metadata BEFORE decoration so @tool / schema generators
+        # and test consumers both see the final identity.
+        _skill_tool.__name__ = f"skill_{safe_name}"
+        _skill_tool.__qualname__ = _skill_tool.__name__
+        _skill_tool.__doc__ = description
+
+        return tool(
+            name=f"skill_{safe_name}",
+            description=description,
+        )(_skill_tool)
+        
+    except ImportError:
+        def _dummy_tool(arguments: str = "") -> str:
+            return "Skills not available (praisonaiagents not installed)"
+        return _dummy_tool

{praisonai-4.6.22 → praisonai-4.6.23}/praisonai/db/adapter.py

@@ -7,6 +7,7 @@ and the wrapper's persistence layer (PersistenceOrchestrator).
 
 import time
 import logging
+import threading
 from typing import Any, Dict, List, Optional
 
 logger = logging.getLogger(__name__)
@@ -61,41 +62,46 @@ class PraisonAIDB:
         self._state_store = None
         self._knowledge_store = None
         self._initialized = False
+        self._init_lock = threading.Lock()
     
     def _init_stores(self):
         """Lazily initialize stores on first use."""
         if self._initialized:
             return
         
-        # Import persistence layer
-        from ..persistence.factory import (
-            create_conversation_store,
-            create_state_store,
-            create_knowledge_store,
-        )
-        
-        # Initialize conversation store
-        if self._database_url:
-            backend = self._detect_backend(self._database_url)
-            self._conversation_store = create_conversation_store(
-                backend, url=self._database_url, **self._options
-            )
-        
-        # Initialize state store
-        if self._state_url:
-            backend = self._detect_backend(self._state_url)
-            self._state_store = create_state_store(
-                backend, url=self._state_url, **self._options
+        with self._init_lock:
+            if self._initialized:  # Double-check inside lock
+                return
+            
+            # Import persistence layer
+            from ..persistence.factory import (
+                create_conversation_store,
+                create_state_store,
+                create_knowledge_store,
             )
-        
-        # Initialize knowledge store
-        if self._knowledge_url:
-            backend = self._detect_backend(self._knowledge_url)
-            self._knowledge_store = create_knowledge_store(
-                backend, url=self._knowledge_url, **self._options
-            )
-        
-        self._initialized = True
+            
+            # Initialize conversation store
+            if self._database_url:
+                backend = self._detect_backend(self._database_url)
+                self._conversation_store = create_conversation_store(
+                    backend, url=self._database_url, **self._options
+                )
+            
+            # Initialize state store
+            if self._state_url:
+                backend = self._detect_backend(self._state_url)
+                self._state_store = create_state_store(
+                    backend, url=self._state_url, **self._options
+                )
+            
+            # Initialize knowledge store
+            if self._knowledge_url:
+                backend = self._detect_backend(self._knowledge_url)
+                self._knowledge_store = create_knowledge_store(
+                    backend, url=self._knowledge_url, **self._options
+                )
+            
+            self._initialized = True
     
     def _detect_backend(self, url: str) -> str:
         """Detect backend type from URL.

{praisonai-4.6.22 → praisonai-4.6.23}/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.22 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==4.6.23 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

{praisonai-4.6.22 → praisonai-4.6.23}/praisonai/gateway/server.py

@@ -1806,87 +1806,3 @@ class WebSocketGateway:
             if self._scheduler_task:
                 self._scheduler_task.cancel()
             await self.stop_channels()
-                except (OSError, ValueError):
-                    pass
-
-        try:
-            await _run_all()
-        finally:
-            if self._config_watch_task:
-                self._config_watch_task.cancel()
-            if self._scheduler_task:
-                self._scheduler_task.cancel()
-            await self.stop_channels()
-        loop = asyncio.get_event_loop()
-        for sig in (signal.SIGINT, signal.SIGTERM):
-            try:
-                loop.add_signal_handler(sig, _request_shutdown)
-            except (NotImplementedError, OSError, ValueError):
-                # Fallback for platforms where add_signal_handler is unavailable
-                try:
-                    signal.signal(sig, lambda s, f: _request_shutdown())
-                except (OSError, ValueError):
-                    pass
-
-        try:
-            await _run_all()
-        finally:
-            if self._config_watch_task:
-                self._config_watch_task.cancel()
-            if self._scheduler_task:
-                self._scheduler_task.cancel()
-            await self.stop_channels()
-
-        try:
-            await _run_all()
-        finally:
-            if self._config_watch_task:
-                self._config_watch_task.cancel()
-            if self._scheduler_task:
-                self._scheduler_task.cancel()
-            await self.stop_channels()
-                loop.add_signal_handler(sig, _request_shutdown)
-            except (NotImplementedError, OSError, ValueError):
-                # Fallback for platforms where add_signal_handler is unavailable
-                try:
-                    signal.signal(sig, lambda s, f: _request_shutdown())
-                except (OSError, ValueError):
-                    pass
-
-        try:
-            await _run_all()
-        finally:
-            if self._config_watch_task:
-                self._config_watch_task.cancel()
-            if self._scheduler_task:
-                self._scheduler_task.cancel()
-            await self.stop_channels()
-                self._config_watch_task.cancel()
-            if self._scheduler_task:
-                self._scheduler_task.cancel()
-            await self.stop_channels()
-
-        def _request_shutdown():
-            logger.info("Received shutdown signal, stopping gateway...")
-            if self._server:
-                self._server.should_exit = True
-
-        loop = asyncio.get_event_loop()
-        for sig in (signal.SIGINT, signal.SIGTERM):
-            try:
-                loop.add_signal_handler(sig, _request_shutdown)
-            except (NotImplementedError, OSError, ValueError):
-                # Fallback for platforms where add_signal_handler is unavailable
-                try:
-                    signal.signal(sig, lambda s, f: _request_shutdown())
-                except (OSError, ValueError):
-                    pass
-
-        try:
-            await _run_all()
-        finally:
-            if self._config_watch_task:
-                self._config_watch_task.cancel()
-            if self._scheduler_task:
-                self._scheduler_task.cancel()
-            await self.stop_channels()