PraisonAI 4.7.6__tar.gz → 4.7.7__tar.gz

{praisonai-4.7.6 → praisonai-4.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.6
+Version: 4.7.7
 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,14 +11,14 @@ 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.7.4
-Requires-Dist: praisonai-code>=0.1.3
-Requires-Dist: praisonai-bot>=0.1.3
-Requires-Dist: praisonai-train>=0.1.3
-Requires-Dist: praisonai-browser>=0.1.3
-Requires-Dist: praisonai-mcp>=0.1.5
-Requires-Dist: praisonai-sandbox>=0.1.3
-Requires-Dist: praisonai-deploy>=0.1.3
+Requires-Dist: praisonaiagents>=1.7.5
+Requires-Dist: praisonai-code>=0.1.4
+Requires-Dist: praisonai-bot>=0.1.4
+Requires-Dist: praisonai-train>=0.1.4
+Requires-Dist: praisonai-browser>=0.1.4
+Requires-Dist: praisonai-mcp>=0.1.6
+Requires-Dist: praisonai-sandbox>=0.1.4
+Requires-Dist: praisonai-deploy>=0.1.4
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0
@@ -129,7 +129,8 @@ Provides-Extra: agno
 Requires-Dist: praisonai-frameworks[agno]>=0.1.8; extra == "agno"
 Requires-Dist: praisonai-tools>=0.1.0; extra == "agno"
 Provides-Extra: google-adk
-Requires-Dist: praisonai-frameworks[google-adk]>=0.1.8; extra == "google-adk"
+Requires-Dist: praisonai-frameworks>=0.1.8; extra == "google-adk"
+Requires-Dist: google-adk[extensions]<3,>=2.5; extra == "google-adk"
 Requires-Dist: praisonai-tools>=0.1.0; extra == "google-adk"
 Provides-Extra: pydantic-ai
 Requires-Dist: praisonai-frameworks[pydantic-ai]>=0.1.9; extra == "pydantic-ai"

{praisonai-4.7.6 → praisonai-4.7.7}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.6
+Version: 4.7.7
 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,14 +11,14 @@ 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.7.4
-Requires-Dist: praisonai-code>=0.1.3
-Requires-Dist: praisonai-bot>=0.1.3
-Requires-Dist: praisonai-train>=0.1.3
-Requires-Dist: praisonai-browser>=0.1.3
-Requires-Dist: praisonai-mcp>=0.1.5
-Requires-Dist: praisonai-sandbox>=0.1.3
-Requires-Dist: praisonai-deploy>=0.1.3
+Requires-Dist: praisonaiagents>=1.7.5
+Requires-Dist: praisonai-code>=0.1.4
+Requires-Dist: praisonai-bot>=0.1.4
+Requires-Dist: praisonai-train>=0.1.4
+Requires-Dist: praisonai-browser>=0.1.4
+Requires-Dist: praisonai-mcp>=0.1.6
+Requires-Dist: praisonai-sandbox>=0.1.4
+Requires-Dist: praisonai-deploy>=0.1.4
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0
@@ -129,7 +129,8 @@ Provides-Extra: agno
 Requires-Dist: praisonai-frameworks[agno]>=0.1.8; extra == "agno"
 Requires-Dist: praisonai-tools>=0.1.0; extra == "agno"
 Provides-Extra: google-adk
-Requires-Dist: praisonai-frameworks[google-adk]>=0.1.8; extra == "google-adk"
+Requires-Dist: praisonai-frameworks>=0.1.8; extra == "google-adk"
+Requires-Dist: google-adk[extensions]<3,>=2.5; extra == "google-adk"
 Requires-Dist: praisonai-tools>=0.1.0; extra == "google-adk"
 Provides-Extra: pydantic-ai
 Requires-Dist: praisonai-frameworks[pydantic-ai]>=0.1.9; extra == "pydantic-ai"

{praisonai-4.7.6 → praisonai-4.7.7}/PraisonAI.egg-info/SOURCES.txt

@@ -486,7 +486,6 @@ praisonai/standardise/discovery.py
 praisonai/standardise/drift.py
 praisonai/standardise/engine.py
 praisonai/standardise/example_verifier.py
-praisonai/standardise/manifest.py
 praisonai/standardise/models.py
 praisonai/standardise/reports.py
 praisonai/standardise/templates.py

{praisonai-4.7.6 → praisonai-4.7.7}/PraisonAI.egg-info/requires.txt

@@ -1,14 +1,14 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.7.4
-praisonai-code>=0.1.3
-praisonai-bot>=0.1.3
-praisonai-train>=0.1.3
-praisonai-browser>=0.1.3
-praisonai-mcp>=0.1.5
-praisonai-sandbox>=0.1.3
-praisonai-deploy>=0.1.3
+praisonaiagents>=1.7.5
+praisonai-code>=0.1.4
+praisonai-bot>=0.1.4
+praisonai-train>=0.1.4
+praisonai-browser>=0.1.4
+praisonai-mcp>=0.1.6
+praisonai-sandbox>=0.1.4
+praisonai-deploy>=0.1.4
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0
@@ -158,7 +158,8 @@ requests>=2.31.0
 praisonai-bot[gateway]
 
 [google-adk]
-praisonai-frameworks[google-adk]>=0.1.8
+praisonai-frameworks>=0.1.8
+google-adk[extensions]<3,>=2.5
 praisonai-tools>=0.1.0
 
 [gradio]

{praisonai-4.7.6 → praisonai-4.7.7}/praisonai/_async_bridge.py

@@ -9,15 +9,66 @@ import asyncio
 import atexit
 import contextlib
 import contextvars
+import enum
+import inspect
+import logging
 import os
 import threading
+import weakref
 import concurrent.futures
 from concurrent.futures import CancelledError as FutureCancelledError, Future
-from typing import Awaitable, Iterator, Optional, TypeVar
+from typing import Any, Awaitable, Iterator, Optional, TypeVar
+
+logger = logging.getLogger(__name__)
 
 T = TypeVar("T")
 
-_DEFAULT_TIMEOUT = float(os.environ.get("PRAISONAI_RUN_SYNC_TIMEOUT", "300"))
+
+class _Unset:
+    """Sentinel for an *omitted* timeout argument.
+
+    Distinguishes "caller did not pass a timeout" (resolve the configured
+    default via :func:`_default_timeout`) from an explicit ``timeout=None``
+    (an intentional request for an *unbounded* wait). The scheduler bridges
+    (``integration/bridges/schedules_runner.py``, ``cli/commands/schedule.py``)
+    rely on the latter so a long-running claimed job is never cancelled after
+    the 300s default.
+    """
+
+    __slots__ = ()
+
+    def __repr__(self) -> str:  # pragma: no cover - debug aid only
+        return "<unset>"
+
+
+_UNSET = _Unset()
+
+
+def _resolve_timeout(timeout: "float | None | _Unset") -> Optional[float]:
+    """Map an omitted timeout to the configured default, preserving explicit None.
+
+    - ``_UNSET`` (argument omitted) → :func:`_default_timeout` (e.g. 300s).
+    - explicit ``None`` → ``None`` (unbounded wait; caller opted in).
+    - a number → itself.
+    """
+    if isinstance(timeout, _Unset):
+        return _default_timeout()
+    return timeout
+
+
+def _default_timeout() -> float:
+    """Resolve the default run_sync timeout lazily, per call.
+
+    Read at call time (not import time) so a malformed ``PRAISONAI_RUN_SYNC_TIMEOUT``
+    cannot crash ``import praisonai`` with an unrelated ``ValueError``, and so a
+    value set after import (dotenv loaded late, per-request reconfig) is honoured.
+    Falls back to 300s on a malformed value.
+    """
+    raw = os.environ.get("PRAISONAI_RUN_SYNC_TIMEOUT", "300")
+    try:
+        return float(raw)
+    except ValueError:
+        return 300.0
 
 class AsyncBridge:
     """Per-instance async runner. The module-level `run_sync()` keeps the
@@ -38,6 +89,9 @@ class AsyncBridge:
         # lock by ``get()``/``submit()`` so ``_spawn_locked()`` can verify the
         # *caller* (not merely *someone*) owns the lock.
         self._lock_owner: int | None = None
+        # The shared default registers its atexit teardown lazily, on first use,
+        # so a bare ``import praisonai`` installs no process-wide hook.
+        self._atexit_registered = False
 
     def _spawn_locked(self) -> asyncio.AbstractEventLoop:
         """Create the loop+thread; caller must hold ``self._lock``.
@@ -74,6 +128,13 @@ class AsyncBridge:
                 daemon=True,
             )
             self._thread.start()
+            # Register the process-exit teardown lazily and only for the shared
+            # default. Doing it here (first real use) rather than at import keeps
+            # ``import praisonai`` free of an unrequested atexit hook that would
+            # compete with hosts like Django/Airflow/Streamlit for shutdown order.
+            if not self._atexit_registered and self is globals().get("_BG"):
+                atexit.register(self.shutdown)
+                self._atexit_registered = True
         return self._loop
 
     def get(self) -> asyncio.AbstractEventLoop:
@@ -94,7 +155,11 @@ class AsyncBridge:
             finally:
                 self._lock_owner = None
 
-    def run_sync(self, coro: Awaitable[T], *, timeout: float | None = _DEFAULT_TIMEOUT) -> T:
+    def run_sync(
+        self, coro: Awaitable[T], *, timeout: "float | None | _Unset" = _UNSET
+    ) -> T:
+        # Omitted → configured default; explicit ``None`` → unbounded wait.
+        timeout = _resolve_timeout(timeout)
         try:
             asyncio.get_running_loop()
         except RuntimeError:
@@ -245,19 +310,18 @@ def scoped_bridge(bridge: Optional[AsyncBridge] = None) -> Iterator[AsyncBridge]
 def _shutdown_default() -> None:
     """Private process-exit hook: tear down the shared default bridge.
 
-    Registered with :mod:`atexit`. This is the ONLY sanctioned way the shared
-    default is shut down; it is deliberately absent from the public module
-    surface so a single caller cannot terminate async work for the whole
-    process. Embedders needing explicit lifecycle control own their own
-    :class:`AsyncBridge` instance.
+    Registered with :mod:`atexit` lazily (on the shared default's first real use
+    in :meth:`AsyncBridge._spawn_locked`), not at import, so a bare
+    ``import praisonai`` installs no process-wide hook. This is the ONLY
+    sanctioned way the shared default is shut down; it is deliberately absent
+    from the public module surface so a single caller cannot terminate async
+    work for the whole process. Embedders needing explicit lifecycle control own
+    their own :class:`AsyncBridge` instance.
     """
     _BG.shutdown()
 
 
-atexit.register(_shutdown_default)
-
-
-def run_sync(coro: Awaitable[T], *, timeout: float | None = _DEFAULT_TIMEOUT) -> T:
+def run_sync(coro: Awaitable[T], *, timeout: "float | None | _Unset" = _UNSET) -> T:
     """
     Run a coroutine synchronously using the background loop.
     
@@ -282,7 +346,7 @@ def run_sync(coro: Awaitable[T], *, timeout: float | None = _DEFAULT_TIMEOUT) ->
 def run_sync_or_offload(
     coro: Awaitable[T],
     *,
-    timeout: float | None = _DEFAULT_TIMEOUT,
+    timeout: "float | None | _Unset" = _UNSET,
     thread_name: str = "praisonai-sync-offload",
 ) -> T:
     """Run ``coro`` to completion from *any* calling context.
@@ -303,6 +367,8 @@ def run_sync_or_offload(
     (it fails loudly inside a loop). Async callers should ``await``
     :func:`arun_sync_or_offload`, which never blocks the loop.
     """
+    # Omitted → configured default; explicit ``None`` → unbounded wait.
+    timeout = _resolve_timeout(timeout)
     try:
         asyncio.get_running_loop()
     except RuntimeError:
@@ -383,7 +449,7 @@ def run_sync_or_offload(
 async def arun_sync_or_offload(
     coro: Awaitable[T],
     *,
-    timeout: float | None = _DEFAULT_TIMEOUT,
+    timeout: "float | None | _Unset" = _UNSET,
 ) -> T:
     """Awaitable sibling of :func:`run_sync_or_offload` for async callers.
 
@@ -397,6 +463,9 @@ async def arun_sync_or_offload(
     ``asyncio.new_event_loop()``), so a caller-installed :func:`scoped_bridge`
     binding still wins and per-loop connection pools are preserved.
     """
+    # Omitted → configured default; explicit ``None`` → unbounded wait
+    # (``asyncio.wait_for(..., timeout=None)`` waits indefinitely).
+    timeout = _resolve_timeout(timeout)
     fut = _default_bridge().submit(coro)
     wrapped = asyncio.wrap_future(fut)
     try:
@@ -404,3 +473,72 @@ async def arun_sync_or_offload(
     except (asyncio.TimeoutError, asyncio.CancelledError):
         fut.cancel()
         raise
+
+
+class DispatchKind(str, enum.Enum):
+    """How a sync caller consumes the result of a (possibly async) store op.
+
+    Making read-vs-write intent explicit at the *call site* removes the need for
+    a name-string allow-list (the old ``_READ_OPS`` frozenset) that silently
+    dropped a new read-shaped method's return value under a running loop.
+    """
+
+    READ = "read"    #: caller consumes the returned value (never fire-and-forget)
+    WRITE = "write"  #: caller only cares that it eventually completes
+
+
+def dispatch_maybe_awaitable(
+    value: Any,
+    *,
+    kind: DispatchKind,
+    tracker: "weakref.WeakSet | None" = None,
+    tracker_lock: "threading.Lock | None" = None,
+    op_name: str = "op",
+) -> Any:
+    """Single owner of "a sync call may return a coroutine; run it correctly".
+
+    This consolidates the submit/track/callback scaffolding that lifecycle hooks
+    would otherwise hand-roll per op. Behaviour:
+
+    - **Not awaitable**: returned as-is.
+    - **No running loop**: block on the shared bridge via :func:`run_sync`.
+    - **Running loop + READ**: route through :func:`run_sync_or_offload`, which
+      returns the value on a sync path and fails loudly inside a loop instead of
+      corrupting a read-modify-write with a silent ``None``.
+    - **Running loop + WRITE**: submit to the active bridge as tracked
+      fire-and-forget (uuid-keyed store writes are idempotent, so completing them
+      slightly later is safe), attach a warning done-callback, and return
+      ``None``.
+
+    Args:
+        value: The result of calling the store method (may be a coroutine).
+        kind: :class:`DispatchKind.READ` or :class:`DispatchKind.WRITE`.
+        tracker: Optional ``WeakSet`` of in-flight futures so a ``close()`` path
+            can flush them; only used on the running-loop WRITE branch.
+        tracker_lock: Lock guarding ``tracker``.
+        op_name: Human-readable op name for log/thread naming.
+    """
+    if not inspect.isawaitable(value):
+        return value
+
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return run_sync(value)
+
+    if kind is DispatchKind.READ:
+        return run_sync_or_offload(value, thread_name=f"praisonai-db-read-{op_name}")
+
+    fut = current_bridge().submit(value)
+    if tracker is not None and tracker_lock is not None:
+        with tracker_lock:
+            tracker.add(fut)
+
+    def _on_done(f, name=op_name):
+        try:
+            f.result()
+        except Exception:
+            logger.warning("Deferred %s failed", name, exc_info=True)
+
+    fut.add_done_callback(_on_done)
+    return None

praisonai-4.7.7/praisonai/_lazy_cache.py

@@ -0,0 +1,95 @@
+"""Single source of truth for thread-safe lazy loading of optional deps."""
+import threading
+import time
+from typing import Callable, Dict, Optional, Tuple, Type, TypeVar
+
+T = TypeVar("T")
+
+#: Failures we treat as *transient* — an environment blip that may resolve on
+#: its own (a keyring read racing a plugin install, a half-installed optional
+#: dep, a one-shot config error on first import). These get a cool-down window
+#: before the loader is retried, instead of being memoised for the process
+#: lifetime. Structural failures (``ImportError``/``ValueError``/…) still fail
+#: fast and stay cached.
+_TRANSIENT_EXCEPTIONS: Tuple[Type[BaseException], ...] = (
+    OSError,
+    ConnectionError,
+    TimeoutError,
+)
+
+
+class LazyCache:
+    """Thread-safe double-checked lazy cache. Caches and re-raises terminal loader failures.
+
+    Structural loader failures are cached permanently so a broken optional dep
+    fails fast. Transient failures (see :data:`_TRANSIENT_EXCEPTIONS`) are cached
+    only for ``retry_cooldown`` seconds so a long-lived process (``praisonai
+    serve``) recovers automatically once the underlying condition clears, mirror-
+    ing the cool-down ``PraisonAIDB._init_stores`` already uses. See #4945.
+
+    Prefer constructing a scoped instance for multi-tenant callers instead of
+    sharing the module-level singleton.
+    """
+
+    def __init__(self, retry_cooldown: float = 30.0) -> None:
+        self._cache: Dict[str, object] = {}
+        self._error_ts: Dict[str, float] = {}
+        self._retry_cooldown = retry_cooldown
+        self._lock = threading.Lock()
+
+    def _raise_if_valid_cached_error(self, key: str, cached: BaseException) -> bool:
+        """Re-raise a cached error unless its transient cool-down has expired.
+
+        Returns ``True`` when the cool-down expired and the loader should be
+        retried; otherwise raises the cached error.
+        """
+        if isinstance(cached, _TRANSIENT_EXCEPTIONS):
+            if time.monotonic() - self._error_ts.get(key, 0.0) < self._retry_cooldown:
+                raise cached
+            return True  # cool-down expired: retry
+        raise cached
+
+    def get(self, key: str, loader: Callable[[], T]) -> Optional[T]:
+        cached = self._cache.get(key, _MISSING)
+        if cached is not _MISSING:
+            if isinstance(cached, BaseException):
+                self._raise_if_valid_cached_error(key, cached)  # may raise
+            else:
+                return cached  # type: ignore[return-value]
+        with self._lock:
+            cached = self._cache.get(key, _MISSING)
+            if cached is not _MISSING:
+                if isinstance(cached, BaseException):
+                    self._raise_if_valid_cached_error(key, cached)  # may raise
+                else:
+                    return cached  # type: ignore[return-value]
+            try:
+                value: object = loader()
+            except (KeyboardInterrupt, SystemExit):
+                # Control-flow exceptions must propagate cleanly, never memoised.
+                raise
+            except BaseException as e:
+                # Cache terminal loader failures so a broken optional dep fails
+                # fast. Transient failures are timestamped so they expire.
+                self._cache[key] = e
+                self._error_ts[key] = time.monotonic()
+                raise
+            self._cache[key] = value
+            self._error_ts.pop(key, None)
+            return value  # type: ignore[return-value]
+
+    def reset(self, key: Optional[str] = None) -> None:
+        with self._lock:
+            if key is None:
+                self._cache.clear()
+                self._error_ts.clear()
+            else:
+                self._cache.pop(key, None)
+                self._error_ts.pop(key, None)
+
+
+_MISSING = object()
+
+_GLOBAL = LazyCache()
+lazy_get = _GLOBAL.get
+lazy_reset = _GLOBAL.reset

{praisonai-4.7.6 → praisonai-4.7.7}/praisonai/agents_generator.py

@@ -1389,19 +1389,26 @@ class AgentsGenerator:
         self.logger.info(f"Using framework: {prep['adapter'].name}")
         # Own the observability lifecycle here so init and finalize are always
         # paired for every adapter (the CM finalizes on success and error alike).
+        from ._async_bridge import scoped_bridge
         with observability_session(prep['adapter'].name):
             # Run setup INSIDE the session so setup events and any setup/import
             # failure are recorded and finalized, not dropped outside observability.
             self._run_adapter_setup(prep['adapter'])
-            return prep['adapter'].run(
-                prep['config'],
-                self.config_list,
-                prep['topic'],
-                tools_dict=prep['tools_dict'],
-                agent_callback=getattr(self, 'agent_callback', None),
-                task_callback=getattr(self, 'task_callback', None),
-                cli_config=getattr(self, 'cli_config', None),
-            )
+            # Isolate this sync run's sync→async work (adapter internals call
+            # run_sync) onto its own loop+thread so a stuck coroutine in one
+            # agent/tenant does not park the shared default loop for the rest.
+            # Async callers use agenerate_crew_and_kickoff (awaits arun directly)
+            # and are intentionally not wrapped here.
+            with scoped_bridge():
+                return prep['adapter'].run(
+                    prep['config'],
+                    self.config_list,
+                    prep['topic'],
+                    tools_dict=prep['tools_dict'],
+                    agent_callback=getattr(self, 'agent_callback', None),
+                    task_callback=getattr(self, 'task_callback', None),
+                    cli_config=getattr(self, 'cli_config', None),
+                )
 
     async def _aload_config(self):
         """Async-safe config loading (blocking file I/O off the event loop)."""