PraisonAI 4.5.0__tar.gz → 4.5.2__tar.gz

{praisonai-4.5.0 → praisonai-4.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.5.0
+Version: 4.5.2
 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.5.0
+Requires-Dist: praisonaiagents>=1.5.2
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm>=1.81.0
 Requires-Dist: PyYAML>=6.0

{praisonai-4.5.0 → praisonai-4.5.2}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.5.0
+Version: 4.5.2
 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.5.0
+Requires-Dist: praisonaiagents>=1.5.2
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm>=1.81.0
 Requires-Dist: PyYAML>=6.0

{praisonai-4.5.0 → praisonai-4.5.2}/PraisonAI.egg-info/SOURCES.txt

@@ -51,10 +51,22 @@ praisonai/app/agentos.py
 praisonai/audit/__init__.py
 praisonai/audit/agent_centric.py
 praisonai/bots/__init__.py
+praisonai/bots/_ack.py
+praisonai/bots/_approval.py
+praisonai/bots/_approval_base.py
+praisonai/bots/_chunk.py
 praisonai/bots/_commands.py
+praisonai/bots/_config_schema.py
+praisonai/bots/_debounce.py
+praisonai/bots/_discord_approval.py
+praisonai/bots/_http_approval.py
 praisonai/bots/_protocol_mixin.py
 praisonai/bots/_registry.py
+praisonai/bots/_resilience.py
 praisonai/bots/_session.py
+praisonai/bots/_slack_approval.py
+praisonai/bots/_telegram_approval.py
+praisonai/bots/_webhook_approval.py
 praisonai/bots/_whatsapp_web_adapter.py
 praisonai/bots/bot.py
 praisonai/bots/botos.py
@@ -246,6 +258,7 @@ praisonai/cli/features/migration_spec.py
 praisonai/cli/features/n8n.py
 praisonai/cli/features/observability.py
 praisonai/cli/features/ollama.py
+praisonai/cli/features/onboard.py
 praisonai/cli/features/output_modes.py
 praisonai/cli/features/output_style.py
 praisonai/cli/features/package.py
@@ -286,6 +299,7 @@ praisonai/cli/features/doctor/models.py
 praisonai/cli/features/doctor/registry.py
 praisonai/cli/features/doctor/checks/__init__.py
 praisonai/cli/features/doctor/checks/acp_checks.py
+praisonai/cli/features/doctor/checks/bot_checks.py
 praisonai/cli/features/doctor/checks/config_checks.py
 praisonai/cli/features/doctor/checks/db_checks.py
 praisonai/cli/features/doctor/checks/env_checks.py
@@ -380,6 +394,9 @@ praisonai/context/history_store.py
 praisonai/context/queue.py
 praisonai/context/setup.py
 praisonai/context/terminal_logger.py
+praisonai/daemon/__init__.py
+praisonai/daemon/launchd.py
+praisonai/daemon/systemd.py
 praisonai/db/__init__.py
 praisonai/db/adapter.py
 praisonai/deploy/__init__.py

{praisonai-4.5.0 → praisonai-4.5.2}/PraisonAI.egg-info/requires.txt

@@ -1,7 +1,7 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.5.0
+praisonaiagents>=1.5.2
 python-dotenv>=0.19.0
 litellm>=1.81.0
 PyYAML>=6.0

{praisonai-4.5.0 → praisonai-4.5.2}/praisonai/bots/__init__.py

@@ -14,6 +14,11 @@ if TYPE_CHECKING:
     from .whatsapp import WhatsAppBot
     from .bot import Bot
     from .botos import BotOS
+    from ._slack_approval import SlackApproval
+    from ._telegram_approval import TelegramApproval
+    from ._discord_approval import DiscordApproval
+    from ._webhook_approval import WebhookApproval
+    from ._http_approval import HTTPApproval
 
 def __getattr__(name: str):
     """Lazy loading of bot components."""
@@ -35,9 +40,26 @@ def __getattr__(name: str):
     if name == "BotOS":
         from .botos import BotOS
         return BotOS
+    if name == "SlackApproval":
+        from ._slack_approval import SlackApproval
+        return SlackApproval
+    if name == "TelegramApproval":
+        from ._telegram_approval import TelegramApproval
+        return TelegramApproval
+    if name == "DiscordApproval":
+        from ._discord_approval import DiscordApproval
+        return DiscordApproval
+    if name == "WebhookApproval":
+        from ._webhook_approval import WebhookApproval
+        return WebhookApproval
+    if name == "HTTPApproval":
+        from ._http_approval import HTTPApproval
+        return HTTPApproval
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 __all__ = [
     "TelegramBot", "DiscordBot", "SlackBot", "WhatsAppBot",
     "Bot", "BotOS",
+    "SlackApproval", "TelegramApproval", "DiscordApproval",
+    "WebhookApproval", "HTTPApproval",
 ]

praisonai-4.5.2/praisonai/bots/_ack.py

@@ -0,0 +1,99 @@
+"""
+Ack reaction helpers for PraisonAI bots.
+
+Reacts to inbound messages with a configurable emoji (e.g. ⏳) to
+acknowledge receipt, then swaps to a "done" emoji (e.g. ✅) when
+the agent response is sent.  Inspired by OpenClaw's ack-reactions.ts.
+
+Usage::
+
+    ack = AckReactor(ack_emoji="⏳", done_emoji="✅")
+    ctx = await ack.ack(channel_id, message_id, react_fn)
+    # ... process message ...
+    await ack.done(ctx, channel_id, message_id, react_fn, unreact_fn)
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Any, Callable, Coroutine, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AckContext:
+    """Tracks state for a single ack-reaction lifecycle."""
+    acked: bool = False
+    emoji: str = ""
+
+
+class AckReactor:
+    """Lightweight ack-reaction manager.
+
+    Args:
+        ack_emoji: Emoji to react with on message receipt (empty = disabled).
+        done_emoji: Emoji to react with on completion (default "✅").
+    """
+
+    def __init__(self, ack_emoji: str = "", done_emoji: str = "✅") -> None:
+        self._ack_emoji = ack_emoji
+        self._done_emoji = done_emoji
+
+    @property
+    def enabled(self) -> bool:
+        return bool(self._ack_emoji)
+
+    async def ack(
+        self,
+        react_fn: Callable[..., Coroutine],
+        **kwargs: Any,
+    ) -> AckContext:
+        """React with ack emoji.  Returns context for later ``done()``.
+
+        Args:
+            react_fn: Platform-specific async function to add a reaction.
+                Called as ``await react_fn(emoji=self._ack_emoji, **kwargs)``.
+            **kwargs: Extra args forwarded to react_fn (chat_id, message_id, etc).
+        """
+        ctx = AckContext()
+        if not self.enabled:
+            return ctx
+        try:
+            await react_fn(emoji=self._ack_emoji, **kwargs)
+            ctx.acked = True
+            ctx.emoji = self._ack_emoji
+        except Exception as e:
+            logger.debug(f"AckReactor: failed to ack: {e}")
+        return ctx
+
+    async def done(
+        self,
+        ctx: AckContext,
+        react_fn: Callable[..., Coroutine],
+        unreact_fn: Optional[Callable[..., Coroutine]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Swap ack emoji for done emoji.
+
+        Args:
+            ctx: AckContext returned from ``ack()``.
+            react_fn: Async function to add a reaction.
+            unreact_fn: Async function to remove a reaction (optional).
+            **kwargs: Extra args forwarded to react/unreact fns.
+        """
+        if not ctx.acked:
+            return
+        # Remove ack emoji
+        if unreact_fn:
+            try:
+                await unreact_fn(emoji=ctx.emoji, **kwargs)
+            except Exception as e:
+                logger.debug(f"AckReactor: failed to remove ack: {e}")
+        # Add done emoji
+        if self._done_emoji:
+            try:
+                await react_fn(emoji=self._done_emoji, **kwargs)
+            except Exception as e:
+                logger.debug(f"AckReactor: failed to add done: {e}")

praisonai-4.5.2/praisonai/bots/_approval.py

@@ -0,0 +1,149 @@
+"""
+Bot Approval Backend for PraisonAI.
+
+Sends tool execution approval requests as in-platform messages
+(e.g., inline keyboard on Telegram) and waits for user reply.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+# Default timeout for approval requests (seconds)
+DEFAULT_APPROVAL_TIMEOUT = 120
+
+
+class BotApprovalBackend:
+    """In-chat approval backend for bot tool execution.
+    
+    Sends an approval request message to the user in-chat and waits
+    for their reply (yes/no) with a configurable timeout.
+    
+    Default behavior: deny on timeout (safe by default).
+    
+    Usage:
+        approval = BotApprovalBackend(bot_adapter, timeout=60)
+        approved = await approval.request_approval(
+            user_id="123",
+            channel_id="456",
+            tool_name="execute_command",
+            tool_args={"command": "ls -la"},
+        )
+    """
+    
+    def __init__(
+        self,
+        adapter: Any = None,
+        timeout: float = DEFAULT_APPROVAL_TIMEOUT,
+        default_on_timeout: bool = False,
+    ):
+        self._adapter = adapter
+        self._timeout = timeout
+        self._default_on_timeout = default_on_timeout
+        self._pending: Dict[str, asyncio.Future] = {}
+    
+    async def request_approval(
+        self,
+        user_id: str,
+        channel_id: str,
+        tool_name: str,
+        tool_args: Dict[str, Any],
+        description: str = "",
+    ) -> bool:
+        """Send an approval request and wait for user response.
+        
+        Args:
+            user_id: User to ask for approval
+            channel_id: Channel to send the request in
+            tool_name: Name of the tool requesting approval
+            tool_args: Arguments the tool wants to execute with
+            description: Human-readable description of the action
+            
+        Returns:
+            True if approved, False if denied or timed out
+        """
+        request_id = f"approval_{user_id}_{int(time.time() * 1000)}"
+        
+        # Format the approval message
+        args_preview = str(tool_args)[:200]
+        if description:
+            msg = f"🔐 Approval required:\n\n{description}\n\nTool: {tool_name}\nArgs: {args_preview}\n\nReply 'yes' to approve or 'no' to deny."
+        else:
+            msg = f"🔐 Approval required:\n\nTool: {tool_name}\nArgs: {args_preview}\n\nReply 'yes' to approve or 'no' to deny."
+        
+        # Create a future to wait for the response
+        loop = asyncio.get_event_loop()
+        future: asyncio.Future = loop.create_future()
+        self._pending[request_id] = future
+        
+        # Send the message
+        if self._adapter and hasattr(self._adapter, 'send_message'):
+            try:
+                await self._adapter.send_message(channel_id, msg)
+            except Exception as e:
+                logger.error(f"Failed to send approval request: {e}")
+                self._pending.pop(request_id, None)
+                return self._default_on_timeout
+        
+        # Wait for response with timeout
+        try:
+            result = await asyncio.wait_for(future, timeout=self._timeout)
+            return result
+        except asyncio.TimeoutError:
+            logger.info(
+                f"Approval request timed out for {tool_name} "
+                f"(user={user_id}, default={'approve' if self._default_on_timeout else 'deny'})"
+            )
+            return self._default_on_timeout
+        finally:
+            self._pending.pop(request_id, None)
+    
+    def resolve(self, request_id: str, approved: bool) -> bool:
+        """Resolve a pending approval request.
+        
+        Args:
+            request_id: The approval request ID
+            approved: Whether the request is approved
+            
+        Returns:
+            True if the request was found and resolved
+        """
+        future = self._pending.get(request_id)
+        if future and not future.done():
+            future.set_result(approved)
+            return True
+        return False
+    
+    def resolve_by_user_reply(self, user_id: str, reply_text: str) -> bool:
+        """Resolve the most recent pending approval for a user based on reply text.
+        
+        Args:
+            user_id: The user who replied
+            reply_text: The reply text (checked for yes/no)
+            
+        Returns:
+            True if a pending request was resolved
+        """
+        reply_lower = reply_text.strip().lower()
+        approved = reply_lower in ("yes", "y", "approve", "ok", "confirm", "1", "true")
+        denied = reply_lower in ("no", "n", "deny", "reject", "cancel", "0", "false")
+        
+        if not approved and not denied:
+            return False  # Not an approval response
+        
+        # Find most recent pending request for this user
+        for request_id in reversed(list(self._pending.keys())):
+            if f"_{user_id}_" in request_id:
+                return self.resolve(request_id, approved)
+        
+        return False
+    
+    @property
+    def pending_count(self) -> int:
+        """Number of pending approval requests."""
+        return len(self._pending)

praisonai-4.5.2/praisonai/bots/_approval_base.py

@@ -0,0 +1,50 @@
+"""
+Shared base class for messaging-platform approval backends.
+
+Extracts the common sync-wrapper, timeout, poll_interval, and keyword
+matching logic so that SlackApproval, TelegramApproval, and DiscordApproval
+only need to implement the platform-specific bits.
+
+This is an internal module — end users import the concrete classes.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Set
+
+logger = logging.getLogger(__name__)
+
+APPROVE_KEYWORDS: Set[str] = {
+    "yes", "y", "approve", "approved", "ok", "allow", "go", "proceed", "confirm",
+}
+DENY_KEYWORDS: Set[str] = {
+    "no", "n", "deny", "denied", "reject", "block", "stop", "cancel", "refuse",
+}
+
+
+def classify_keyword(text: str) -> str | None:
+    """Classify *text* as ``'approve'``, ``'deny'``, or ``None``."""
+    t = text.strip().lower()
+    if t in APPROVE_KEYWORDS:
+        return "approve"
+    if t in DENY_KEYWORDS:
+        return "deny"
+    return None
+
+
+def sync_wrapper(async_fn, timeout: float):
+    """Run *async_fn* (a coroutine) synchronously, handling nested loops."""
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = None
+
+    if loop and loop.is_running():
+        import concurrent.futures
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+            future = pool.submit(asyncio.run, async_fn)
+            return future.result(timeout=timeout + 10)
+    else:
+        return asyncio.run(async_fn)

praisonai-4.5.2/praisonai/bots/_chunk.py

@@ -0,0 +1,127 @@
+"""
+Markdown-aware message chunking for PraisonAI bots.
+
+Splits long bot responses at paragraph boundaries while preserving
+code fences and markdown structure.  Inspired by OpenClaw's chunk.ts
+but kept minimal (~120 lines).
+
+Usage::
+
+    from praisonai.bots._chunk import chunk_message
+
+    chunks = chunk_message(text, max_length=4096, preserve_fences=True)
+    for chunk in chunks:
+        await bot.send_message(channel_id, chunk)
+"""
+
+from __future__ import annotations
+
+import re
+from typing import List
+
+
+def chunk_message(
+    text: str,
+    max_length: int = 4096,
+    preserve_fences: bool = True,
+) -> List[str]:
+    """Split *text* into chunks of at most *max_length* characters.
+
+    Splitting strategy (in priority order):
+    1. **Paragraph boundaries** (blank lines ``\\n\\n``)
+    2. **Sentence boundaries** (``. `` followed by uppercase or newline)
+    3. **Hard split** at *max_length* (last resort)
+
+    When *preserve_fences* is True, code fence blocks are never split
+    even if they exceed *max_length*.
+
+    Args:
+        text: The message text to split.
+        max_length: Maximum characters per chunk.
+        preserve_fences: Keep code fences intact (default True).
+
+    Returns:
+        List of text chunks.
+    """
+    if not text:
+        return [""]
+
+    if len(text) <= max_length:
+        return [text]
+
+    # Split into paragraphs (double newline)
+    paragraphs = re.split(r"\n\n", text)
+
+    chunks: List[str] = []
+    current = ""
+
+    for para in paragraphs:
+        candidate = (current + "\n\n" + para) if current else para
+
+        # Check if this paragraph is inside a fence span
+        # If the candidate is small enough, accumulate
+        if len(candidate) <= max_length:
+            current = candidate
+            continue
+
+        # Candidate too long — flush current first
+        if current:
+            chunks.append(current.strip())
+            current = ""
+
+        # Now handle the paragraph itself
+        if len(para) <= max_length:
+            current = para
+        elif preserve_fences and _is_fence_block(para):
+            # Code fence block — keep intact even if over limit
+            chunks.append(para.strip())
+        else:
+            # Paragraph too long — split at sentences or hard-split
+            sub_chunks = _split_long_paragraph(para, max_length)
+            chunks.extend(sub_chunks[:-1])
+            current = sub_chunks[-1] if sub_chunks else ""
+
+    if current.strip():
+        chunks.append(current.strip())
+
+    return chunks if chunks else [""]
+
+
+def _is_fence_block(text: str) -> bool:
+    """Check if text is (or contains) a code fence block."""
+    stripped = text.strip()
+    return stripped.startswith("```")
+
+
+def _split_long_paragraph(text: str, max_length: int) -> List[str]:
+    """Split a long paragraph at sentence boundaries, then hard-split."""
+    # Try sentence boundaries first
+    sentences = re.split(r"(?<=[.!?])\s+", text)
+
+    if len(sentences) > 1:
+        chunks: List[str] = []
+        current = ""
+        for sentence in sentences:
+            candidate = (current + " " + sentence) if current else sentence
+            if len(candidate) <= max_length:
+                current = candidate
+            else:
+                if current:
+                    chunks.append(current.strip())
+                if len(sentence) <= max_length:
+                    current = sentence
+                else:
+                    # Sentence itself too long — hard split
+                    chunks.extend(_hard_split(sentence, max_length))
+                    current = ""
+        if current.strip():
+            chunks.append(current.strip())
+        return chunks if chunks else [""]
+
+    # No sentence boundaries — hard split
+    return _hard_split(text, max_length)
+
+
+def _hard_split(text: str, max_length: int) -> List[str]:
+    """Last-resort character-level split."""
+    return [text[i:i + max_length] for i in range(0, len(text), max_length)]