PraisonAI 4.6.108__tar.gz → 4.6.111__tar.gz

{praisonai-4.6.108 → praisonai-4.6.111}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.108
+Version: 4.6.111
 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,8 +11,8 @@ 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.108
-Requires-Dist: praisonai-code>=0.0.6
+Requires-Dist: praisonaiagents>=1.6.111
+Requires-Dist: praisonai-code>=0.0.9
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.108 → praisonai-4.6.111}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.108
+Version: 4.6.111
 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,8 +11,8 @@ 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.108
-Requires-Dist: praisonai-code>=0.0.6
+Requires-Dist: praisonaiagents>=1.6.111
+Requires-Dist: praisonai-code>=0.0.9
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.108 → praisonai-4.6.111}/PraisonAI.egg-info/SOURCES.txt

@@ -74,6 +74,7 @@ praisonai/bots/_dead_targets.py
 praisonai/bots/_debounce.py
 praisonai/bots/_defaults.py
 praisonai/bots/_delivery.py
+praisonai/bots/_delivery_control_store.py
 praisonai/bots/_discord_approval.py
 praisonai/bots/_dlq.py
 praisonai/bots/_durable_adapter.py

{praisonai-4.6.108 → praisonai-4.6.111}/PraisonAI.egg-info/requires.txt

@@ -1,8 +1,8 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.108
-praisonai-code>=0.0.6
+praisonaiagents>=1.6.111
+praisonai-code>=0.0.9
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.108 → praisonai-4.6.111}/praisonai/agent.py

@@ -40,8 +40,13 @@ class Agent(CoreAgent):
         super().__init__(*args, cli_backend=cli_backend, **kwargs)
     
     def _is_protocol_instance(self, obj) -> bool:
-        """Check if object appears to be a protocol instance (duck typing)."""
-        return callable(obj) or hasattr(obj, 'process_turn')
+        """Check if object is a pre-resolved CliBackendProtocol instance (duck typing).
+
+        A CliBackendProtocol instance exposes both ``execute()`` and ``stream()``.
+        Factory callables are intentionally NOT treated as protocol instances here
+        so that wrapper-level normalization in ``resolve_cli_backend_config`` runs.
+        """
+        return hasattr(obj, "execute") and hasattr(obj, "stream")
 
 
 # Export the wrapper Agent as the default for import from praisonai

{praisonai-4.6.108 → praisonai-4.6.111}/praisonai/api/call.py

@@ -235,23 +235,26 @@ async def handle_media_stream(websocket: WebSocket):
                     if openai_ws.open:
                         await openai_ws.close()
 
-        async def send_to_twilio():
-            """Receive events from the OpenAI Realtime API, send audio back to Twilio."""
-            nonlocal stream_sid
-            try:
+            async def send_to_twilio():
+                """Receive events from the OpenAI Realtime API, send audio back to Twilio."""
+                nonlocal stream_sid
                 async for openai_message in openai_ws:
-                    response = json.loads(openai_message)
-                    if response['type'] in LOG_EVENT_TYPES:
-                        print(f"Received event: {response['type']}", response)
-                    if response['type'] == 'session.updated':
-                        print("Session updated successfully:", response)
-                    
-                    if response['type'] == 'response.done':
-                        await handle_response_done(response, openai_ws)
-                    
-                    if response['type'] == 'response.audio.delta' and response.get('delta'):
-                        # Audio from OpenAI
-                        try:
+                    # Isolate per-event failures: a malformed message or an
+                    # error handling a single event must not escape into
+                    # asyncio.gather() and cancel the sibling Twilio task,
+                    # which would drop the live call. Log and keep streaming.
+                    try:
+                        response = json.loads(openai_message)
+                        if response['type'] in LOG_EVENT_TYPES:
+                            print(f"Received event: {response['type']}", response)
+                        if response['type'] == 'session.updated':
+                            print("Session updated successfully:", response)
+
+                        if response['type'] == 'response.done':
+                            await handle_response_done(response, openai_ws)
+
+                        if response['type'] == 'response.audio.delta' and response.get('delta'):
+                            # Audio from OpenAI
                             audio_payload = base64.b64encode(base64.b64decode(response['delta'])).decode('utf-8')
                             audio_delta = {
                                 "event": "media",
@@ -261,12 +264,10 @@ async def handle_media_stream(websocket: WebSocket):
                                 }
                             }
                             await websocket.send_json(audio_delta)
-                        except Exception as e:
-                            print(f"Error processing audio data: {e}")
-            except Exception as e:
-                print(f"Error in Sending to Phone: {e}")
+                    except Exception:
+                        logger.exception("Error processing OpenAI event; continuing stream")
 
-        await asyncio.gather(receive_from_twilio(), send_to_twilio())
+            await asyncio.gather(receive_from_twilio(), send_to_twilio())
     finally:
         active_connections -= 1
 

{praisonai-4.6.108 → praisonai-4.6.111}/praisonai/bots/__init__.py

@@ -31,6 +31,7 @@ if TYPE_CHECKING:
     from ._streaming import StreamingConfig, StreamingMode, DraftStreamer
     from ._outbox import OutboundQueue, OutboundEntry
     from ._approval_store import ApprovalStore
+    from ._delivery_control_store import DeliveryControlStore
     from ._delivery import DurableDelivery, deliver_with_retry
     from ._durable_adapter import DurableAdapterMixin
     from ._outbound_resilience import OutboundResilienceMixin
@@ -141,6 +142,9 @@ def __getattr__(name: str):
     if name == "ApprovalStore":
         from ._approval_store import ApprovalStore
         return ApprovalStore
+    if name == "DeliveryControlStore":
+        from ._delivery_control_store import DeliveryControlStore
+        return DeliveryControlStore
     if name == "DurableDelivery":
         from ._delivery import DurableDelivery
         return DurableDelivery
@@ -188,6 +192,7 @@ __all__ = [
     "InboundJournal", "JournalEntry",
     "OutboundQueue", "OutboundEntry",
     "ApprovalStore",
+    "DeliveryControlStore",
     "DurableDelivery", "deliver_with_retry", "deliver_chunked",
     "DurableAdapterMixin",
     "OutboundResilienceMixin",

{praisonai-4.6.108 → praisonai-4.6.111}/praisonai/bots/_approval_base.py

@@ -11,7 +11,7 @@ This is an internal module — end users import the concrete classes.
 from __future__ import annotations
 
 import logging
-from typing import Set
+from typing import Iterable, Optional, Set, Union
 
 logger = logging.getLogger(__name__)
 
@@ -33,6 +33,51 @@ def classify_keyword(text: str) -> str | None:
     return None
 
 
+def normalize_approvers(
+    allowed_approvers: Optional[Union[Iterable[str], str]],
+) -> Optional[Set[str]]:
+    """Normalise an allowed-approver allowlist to a ``set`` of ``str`` IDs.
+
+    Returns ``None`` when *allowed_approvers* is ``None`` (no restriction —
+    legacy behaviour). Otherwise returns a set of stringified IDs so
+    cross-platform user IDs (int Telegram ids, str Slack/Discord ids) compare
+    consistently.
+    """
+    if allowed_approvers is None:
+        return None
+    if isinstance(allowed_approvers, str):
+        allowed_approvers = allowed_approvers.split(",")
+    return {str(a).strip() for a in allowed_approvers if str(a).strip()}
+
+
+def is_authorized_actor(
+    actor: Optional[str],
+    allowed_approvers: Optional[Set[str]],
+) -> bool:
+    """Return whether *actor* may resolve an approval.
+
+    This is the security boundary for chat-native (inline button / keyword
+    reply) approvals: when an allowlist is configured, only an actor in it may
+    approve or deny a gated tool, so an unauthorised group member's tap/reply
+    can never resolve the request.
+
+    Args:
+        actor: The resolving user's ID (may be ``None`` if the channel could
+            not determine it).
+        allowed_approvers: Normalised allowlist (see :func:`normalize_approvers`).
+            ``None`` means no restriction (any actor allowed — legacy
+            behaviour). An empty set denies everyone.
+
+    Returns:
+        ``True`` when there is no restriction, or *actor* is in the allowlist;
+        ``False`` otherwise (including when *actor* is ``None`` but an
+        allowlist is configured).
+    """
+    if allowed_approvers is None:
+        return True
+    return actor is not None and str(actor) in allowed_approvers
+
+
 async def classify_with_llm(
     text: str,
     tool_name: str,

{praisonai-4.6.108 → praisonai-4.6.111}/praisonai/bots/_config_schema.py

@@ -362,6 +362,15 @@ class GatewayConfigSchema(BaseModel):
     # Routing and daemon config
     routing: Optional[RoutingConfigSchema] = None
     daemon: Optional[DaemonConfigSchema] = None
+
+    # Gateway server settings (host/port, drain_timeout, admission control,
+    # etc.) and inbound trigger hooks. These are read by
+    # ``gateway/server.py::load_gateway_config`` / ``_apply_hooks_from_config``
+    # rather than modelled field-by-field here; kept permissive so a real
+    # ``gateway.yaml`` with a top-level ``gateway:``/``hooks:`` block validates
+    # through this single schema instead of being rejected. See issue #2585.
+    gateway: Optional[Dict[str, Any]] = None
+    hooks: Optional[List[Dict[str, Any]]] = None
     
     @model_validator(mode="after")
     def normalize_and_validate(self):
@@ -390,8 +399,29 @@ class GatewayConfigSchema(BaseModel):
                 "(telegram, discord, slack, whatsapp) to your config"
             )
             
-        # Validate platform names
-        valid_platforms = {"telegram", "discord", "slack", "whatsapp", "email", "agentmail", "linear"}
+        # Validate platform names against the platform registry (single source
+        # of truth). This includes built-in platforms, entry-point discovered
+        # channels (``praisonai.channels`` / ``praisonai.bots``), and any
+        # channel registered at runtime via ``register_platform()``.
+        try:
+            from ._registry import list_platforms
+            valid_platforms = set(list_platforms())
+        except Exception:
+            import logging
+            logging.getLogger(__name__).debug(
+                "Platform registry unavailable; falling back to built-in "
+                "platform list.", exc_info=True
+            )
+            # Fall back to the built-in set (single source of truth) if the
+            # registry is unavailable.
+            try:
+                from ._registry import _BUILTIN_PLATFORMS
+                valid_platforms = set(_BUILTIN_PLATFORMS)
+            except Exception:
+                valid_platforms = {
+                    "telegram", "discord", "slack", "whatsapp",
+                    "email", "agentmail", "linear",
+                }
         for name, channel in self.channels.items():
             platform = (channel.platform or name).lower()
             if platform not in valid_platforms:

{praisonai-4.6.108 → praisonai-4.6.111}/praisonai/bots/_dead_targets.py

@@ -43,7 +43,10 @@ import threading
 import time
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
+
+if TYPE_CHECKING:
+    from ._delivery_control_store import DeliveryControlStore
 
 logger = logging.getLogger(__name__)
 
@@ -100,17 +103,33 @@ class DeadTargetRegistry:
         max_size: int = _DEFAULT_MAX_SIZE,
         ttl_seconds: int = _DEFAULT_TTL_SECONDS,
         reprobe_seconds: int = _DEFAULT_REPROBE_SECONDS,
+        store: Optional["DeliveryControlStore"] = None,
     ) -> None:
         state_dir = Path.home() / ".praisonai" / "state"
-        self._persist_path = Path(
-            persist_path or (state_dir / "dead_targets.json")
-        ).expanduser()
         self.max_size = int(max_size)
         self.ttl_seconds = int(ttl_seconds)
         self.reprobe_seconds = int(reprobe_seconds)
         self._lock = threading.Lock()
         # (platform, channel_id) -> DeadTarget
         self._dead: Dict[Tuple[str, str], DeadTarget] = {}
+        # Shared SQLite store: when provided, dead targets are stored as rows
+        # (atomic upsert) that survive restart and are correct across workers,
+        # instead of the per-process in-memory dict + whole-file JSON rewrite
+        # (issue #2579). Single-process gateways keep the JSON path (default).
+        self._store = store
+        if store is not None:
+            # The store's dead-target TTL/bound sweeps are table-wide, so every
+            # registry sharing one store must agree on ``ttl_seconds`` /
+            # ``max_size``. Register this registry's bounds; a later registry
+            # attaching to the same store with divergent settings fails loudly
+            # instead of silently pruning this registry's suppressions
+            # (Greptile P1, issue #2579).
+            store.register_dead_config(self.ttl_seconds, self.max_size)
+            self._persist_path = None
+            return
+        self._persist_path = Path(
+            persist_path or (state_dir / "dead_targets.json")
+        ).expanduser()
         self._load()
 
     # ── Helpers ─────────────────────────────────────────────────────
@@ -197,6 +216,14 @@ class DeadTargetRegistry:
     def is_dead(self, platform: str, channel_id: str) -> bool:
         """Return True if the target is currently suppressed as dead."""
         key = self._key(platform, channel_id)
+        if self._store is not None:
+            ts = self._store.dead_get_ts(key[0], key[1])
+            if ts is None:
+                return False
+            if self.ttl_seconds > 0 and ts < time.time() - self.ttl_seconds:
+                self._store.dead_clear(key[0], key[1])
+                return False
+            return True
         with self._lock:
             entry = self._dead.get(key)
             if entry is None:
@@ -221,6 +248,11 @@ class DeadTargetRegistry:
         if self.reprobe_seconds <= 0:
             return False
         key = self._key(platform, channel_id)
+        if self._store is not None:
+            ts = self._store.dead_get_ts(key[0], key[1])
+            if ts is None:
+                return False
+            return ts < time.time() - self.reprobe_seconds
         with self._lock:
             entry = self._dead.get(key)
             if entry is None:
@@ -230,6 +262,18 @@ class DeadTargetRegistry:
     def mark_dead(self, platform: str, channel_id: str, reason: str) -> None:
         """Record a confirmed-permanent failure, suppressing future sends."""
         key = self._key(platform, channel_id)
+        if self._store is not None:
+            already = self._store.dead_get_ts(key[0], key[1]) is not None
+            self._store.dead_mark(key[0], key[1], str(reason))
+            self._store.dead_enforce_bound(self.max_size)
+            if not already:
+                logger.warning(
+                    "DeadTargetRegistry: suppressing dead target %s:%s (%s)",
+                    key[0],
+                    key[1],
+                    reason,
+                )
+            return
         with self._lock:
             already = key in self._dead
             self._dead[key] = DeadTarget(
@@ -248,6 +292,16 @@ class DeadTargetRegistry:
     def clear(self, platform: str, channel_id: str) -> None:
         """Un-suppress a target. Called on every successful send (self-healing)."""
         key = self._key(platform, channel_id)
+        if self._store is not None:
+            if self._store.dead_get_ts(key[0], key[1]) is None:
+                return
+            self._store.dead_clear(key[0], key[1])
+            logger.info(
+                "DeadTargetRegistry: target %s:%s recovered — suppression cleared",
+                key[0],
+                key[1],
+            )
+            return
         with self._lock:
             if key not in self._dead:
                 return
@@ -261,6 +315,13 @@ class DeadTargetRegistry:
 
     def list_dead(self) -> List[DeadTarget]:
         """Return a snapshot of currently-dead targets (expired ones pruned)."""
+        if self._store is not None:
+            if self.ttl_seconds > 0:
+                self._store.dead_expire(time.time() - self.ttl_seconds)
+            return [
+                DeadTarget(platform=p, channel_id=c, reason=r, ts=t)
+                for (p, c, r, t) in self._store.dead_list()
+            ]
         with self._lock:
             if self._evict_expired_locked():
                 self._save_locked()
@@ -268,6 +329,10 @@ class DeadTargetRegistry:
 
     def size(self) -> int:
         """Number of currently-suppressed targets (expired ones pruned)."""
+        if self._store is not None:
+            if self.ttl_seconds > 0:
+                self._store.dead_expire(time.time() - self.ttl_seconds)
+            return self._store.dead_count()
         with self._lock:
             if self._evict_expired_locked():
                 self._save_locked()