PraisonAI 4.7.0__tar.gz → 4.7.1__tar.gz

{praisonai-4.7.0 → praisonai-4.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.0
+Version: 4.7.1
 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.0
-Requires-Dist: praisonai-code>=0.1.0
-Requires-Dist: praisonai-bot>=0.1.0
-Requires-Dist: praisonai-train>=0.1.0
-Requires-Dist: praisonai-browser>=0.1.0
-Requires-Dist: praisonai-mcp>=0.1.0
-Requires-Dist: praisonai-sandbox>=0.1.0
-Requires-Dist: praisonai-deploy>=0.1.0
+Requires-Dist: praisonaiagents>=1.7.1
+Requires-Dist: praisonai-code>=0.1.1
+Requires-Dist: praisonai-bot>=0.1.1
+Requires-Dist: praisonai-train>=0.1.1
+Requires-Dist: praisonai-browser>=0.1.1
+Requires-Dist: praisonai-mcp>=0.1.3
+Requires-Dist: praisonai-sandbox>=0.1.1
+Requires-Dist: praisonai-deploy>=0.1.1
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.7.0 → praisonai-4.7.1}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.0
+Version: 4.7.1
 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.0
-Requires-Dist: praisonai-code>=0.1.0
-Requires-Dist: praisonai-bot>=0.1.0
-Requires-Dist: praisonai-train>=0.1.0
-Requires-Dist: praisonai-browser>=0.1.0
-Requires-Dist: praisonai-mcp>=0.1.0
-Requires-Dist: praisonai-sandbox>=0.1.0
-Requires-Dist: praisonai-deploy>=0.1.0
+Requires-Dist: praisonaiagents>=1.7.1
+Requires-Dist: praisonai-code>=0.1.1
+Requires-Dist: praisonai-bot>=0.1.1
+Requires-Dist: praisonai-train>=0.1.1
+Requires-Dist: praisonai-browser>=0.1.1
+Requires-Dist: praisonai-mcp>=0.1.3
+Requires-Dist: praisonai-sandbox>=0.1.1
+Requires-Dist: praisonai-deploy>=0.1.1
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.7.0 → praisonai-4.7.1}/PraisonAI.egg-info/requires.txt

@@ -1,14 +1,14 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.7.0
-praisonai-code>=0.1.0
-praisonai-bot>=0.1.0
-praisonai-train>=0.1.0
-praisonai-browser>=0.1.0
-praisonai-mcp>=0.1.0
-praisonai-sandbox>=0.1.0
-praisonai-deploy>=0.1.0
+praisonaiagents>=1.7.1
+praisonai-code>=0.1.1
+praisonai-bot>=0.1.1
+praisonai-train>=0.1.1
+praisonai-browser>=0.1.1
+praisonai-mcp>=0.1.3
+praisonai-sandbox>=0.1.1
+praisonai-deploy>=0.1.1
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.7.0 → praisonai-4.7.1}/praisonai/_async_bridge.py

@@ -291,22 +291,45 @@ def run_sync_or_offload(
       :class:`AsyncBridge` via :func:`run_sync`, sharing its background loop and
       connection pools.
     - Called from inside a running loop (FastAPI handler, Jupyter, async test):
-      copies the caller's ContextVars onto a worker thread that hands the
-      coroutine to the SAME bridge (never a fresh ``asyncio.new_event_loop()``),
-      so a caller-installed :func:`scoped_bridge` binding still wins and
-      LiteLLM/HTTPX per-loop connection pools are preserved. Exceptions are
-      re-raised on the caller thread.
+      by default this raises ``RuntimeError`` rather than blocking the loop,
+      pointing callers at the awaitable siblings (:func:`arun_sync_or_offload`,
+      ``adapter.arun``, ``praisonai.arun``). Set
+      ``PRAISONAI_ALLOW_LOOP_BLOCKING=true`` to opt into the legacy behaviour
+      that copies the caller's ContextVars onto a worker thread handing the
+      coroutine to the SAME bridge (never a fresh ``asyncio.new_event_loop()``)
+      and joins it — which pins the loop for up to ``timeout`` seconds.
 
     Callers who *know* they are on a sync-only path should use :func:`run_sync`
-    (it fails loudly inside a loop). Everything that participates in the 3-way
-    surface (CLI + YAML + Python) should use this helper so the correct
-    running-loop handling lives in one place instead of being re-implemented.
+    (it fails loudly inside a loop). Async callers should ``await``
+    :func:`arun_sync_or_offload`, which never blocks the loop.
     """
     try:
         asyncio.get_running_loop()
     except RuntimeError:
         return run_sync(coro, timeout=timeout)
 
+    # Strict path (default): never block a running event loop. Joining the
+    # worker thread from the loop thread pins the loop for up to ``timeout``
+    # seconds — exactly the "async-safe" pathology this project forbids. Steer
+    # callers to the awaitable siblings that never block the loop.
+    if os.environ.get("PRAISONAI_ALLOW_LOOP_BLOCKING", "").lower() not in (
+        "1",
+        "true",
+    ):
+        # Close the coroutine we are refusing to run so it does not leak as a
+        # "coroutine was never awaited" warning.
+        with contextlib.suppress(Exception):
+            coro.close()  # type: ignore[attr-defined]
+        raise RuntimeError(
+            "run_sync_or_offload() would block the running event loop for up to "
+            f"{timeout}s. From an async context, await one of:\n"
+            "  - praisonai.arun(...)\n"
+            "  - adapter.arun(...)\n"
+            "  - praisonai._async_bridge.arun_sync_or_offload(coro)\n"
+            "Set PRAISONAI_ALLOW_LOOP_BLOCKING=true to opt into the legacy "
+            "blocking behaviour."
+        )
+
     result: list[T] = []
     error: list[BaseException] = []
     # Hold the concurrent.futures.Future for the in-flight coroutine so the

{praisonai-4.7.0 → praisonai-4.7.1}/praisonai/_lazy_cache.py

@@ -6,7 +6,7 @@ T = TypeVar("T")
 
 
 class LazyCache:
-    """Thread-safe double-checked lazy cache. Caches and re-raises ImportError exceptions."""
+    """Thread-safe double-checked lazy cache. Caches and re-raises terminal loader failures."""
 
     def __init__(self) -> None:
         self._cache: Dict[str, object] = {}
@@ -16,19 +16,23 @@ class LazyCache:
         if key in self._cache:
             cached = self._cache[key]
             # Re-raise cached exception
-            if isinstance(cached, ImportError):
+            if isinstance(cached, BaseException):
                 raise cached
             return cached  # type: ignore[return-value]
         with self._lock:
             if key in self._cache:
                 cached = self._cache[key]
-                if isinstance(cached, ImportError):
+                if isinstance(cached, BaseException):
                     raise cached
                 return cached  # type: ignore[return-value]
             try:
                 value: object = loader()
-            except ImportError as e:
-                # Cache the exception and re-raise
+            except (KeyboardInterrupt, SystemExit):
+                # Control-flow exceptions must propagate cleanly, never memoised.
+                raise
+            except BaseException as e:
+                # Cache every terminal loader failure so a broken optional dep
+                # fails fast instead of re-running the import/probe every call.
                 self._cache[key] = e
                 raise
             self._cache[key] = value

{praisonai-4.7.0 → praisonai-4.7.1}/praisonai/agents_generator.py

@@ -1527,21 +1527,23 @@ class AgentsGenerator:
 def safe_format(template, **kwargs):
     """
     Safe string formatting that preserves JSON/dict literals while substituting variables.
-    
+
     This function only substitutes placeholders that look like identifiers (e.g., {topic})
     while preserving JSON structures like {"level": 2}.
-    
+
+    Delegates to the single source of truth,
+    ``BaseFrameworkAdapter._format_template`` in the core SDK, so the wrapper
+    and core cannot drift (non-string short-circuit, regex, missing-key
+    handling). ``_format_template`` is stateless; a fresh instance is free.
+
     Args:
         template (str): Template string with placeholders
         **kwargs: Values to substitute
-        
+
     Returns:
         str: Formatted string with safe substitutions
     """
-    # Use the same regex-based substitution logic as BaseFrameworkAdapter._format_template
-    def replace_placeholder(match):
-        placeholder = match.group(1)
-        return str(kwargs.get(placeholder, match.group(0)))
-    
-    # Only replace placeholders that look like identifiers
-    return re.sub(r'\{([a-zA-Z_][a-zA-Z0-9_]*)\}', replace_placeholder, template)
+    from praisonaiagents.frameworks.base import BaseFrameworkAdapter
+    return BaseFrameworkAdapter._format_template(
+        BaseFrameworkAdapter(), template, **kwargs
+    )

{praisonai-4.7.0 → praisonai-4.7.1}/praisonai/api/call.py

@@ -4,14 +4,6 @@ import base64
 import hmac
 import secrets
 import asyncio
-import websockets
-from fastapi import FastAPI, WebSocket, Request
-from fastapi.responses import HTMLResponse
-from fastapi.websockets import WebSocketDisconnect
-from twilio.twiml.voice_response import VoiceResponse, Connect
-import uvicorn
-from pyngrok import ngrok, conf
-from rich import print
 import argparse
 import logging
 import importlib.util
@@ -19,6 +11,12 @@ import time
 from typing import Optional
 from collections import defaultdict
 
+# Heavy, optional dependencies (websockets, fastapi, twilio, uvicorn, pyngrok,
+# rich) are imported lazily inside the functions that need them. Importing this
+# module must stay cheap: ``import praisonai.api.call`` (reachable from unrelated
+# code paths) should not pay the transitive cost of the voice/serve stack or
+# fail on minimal containers where those native deps are absent.
+
 
 def _maybe_load_dotenv() -> None:
     """Load a ``.env`` file only when explicitly opted in.
@@ -170,25 +168,16 @@ def _refresh_env_globals() -> None:
         pass
 
 
-app = FastAPI()
-
 # Set up logging
 logger = logging.getLogger(__name__)
 log_level = os.getenv("LOGLEVEL", "INFO").upper()
 logger.handlers.clear()
 
-# Include agent invoke router for n8n integration
-try:
-    from .agent_invoke import router as agent_invoke_router
-    app.include_router(agent_invoke_router)
-    logger.debug("Agent invoke router added for n8n integration")
-except ImportError as e:
-    logger.warning(f"Could not load agent invoke router: {e}")
-
-# Try to import tools from the root directory
+# Tool registry populated only when a server verb explicitly loads local tools
+# (see ``_load_local_tools`` / ``build_call_app``). It is NEVER populated as an
+# import-time side effect.
 tools = []
-tools_path = os.path.join(os.getcwd(), 'tools.py')
-logger.debug(f"Tools path: {tools_path}")
+
 
 def import_tools_from_file(file_path):
     """Import tools from file with PRAISONAI_ALLOW_LOCAL_TOOLS opt-in.
@@ -211,34 +200,122 @@ def import_tools_from_file(file_path):
         logger.error("Failed to import tools from %s", file_path, exc_info=True)
         raise ValueError(f"Failed to import tools from {file_path}") from e
 
-try:
-    # Security: Require explicit opt-in for local tools loading
-    if os.environ.get("PRAISONAI_ALLOW_LOCAL_TOOLS", "").lower() != "true":
-        logger.debug("Local tools loading disabled. Set PRAISONAI_ALLOW_LOCAL_TOOLS=true to enable.")
-        custom_tools_module = None
-    elif os.path.exists(tools_path):
-        # tools.py exists in the root directory, import from file
-        custom_tools_module = import_tools_from_file(tools_path)
-        logger.debug("Successfully imported custom tools from root tools.py")
-    else:
-        logger.debug("No custom tools.py file found in the root directory")
-        custom_tools_module = None
 
-    if custom_tools_module:
-        # Update the tools list with custom tools
-        if hasattr(custom_tools_module, 'tools') and isinstance(custom_tools_module.tools, list):
-            tools.extend(custom_tools_module.tools)
+def _load_local_tools():
+    """Load ``./tools.py`` into the module ``tools`` registry, if opted in.
+
+    Runs user code, so it is gated behind ``PRAISONAI_ALLOW_LOCAL_TOOLS=true``
+    and only invoked by a server entry point (``build_call_app``/``main``) — never
+    at import time. Importing ``praisonai.api.call`` therefore has no filesystem
+    scan and never executes a neighbouring ``tools.py``.
+
+    Idempotent: the shared ``tools`` registry is rebuilt from scratch on each
+    call. Building the app more than once in a process (e.g. two
+    ``build_call_app(load_local_tools=True)`` calls) therefore does not
+    accumulate duplicate tool definitions — which would otherwise send the same
+    tool multiple times in every realtime ``session.update`` and grow the
+    registry unbounded across builds.
+    """
+    tools_path = os.path.join(os.getcwd(), 'tools.py')
+    logger.debug(f"Tools path: {tools_path}")
+    try:
+        if os.environ.get("PRAISONAI_ALLOW_LOCAL_TOOLS", "").lower() != "true":
+            logger.debug("Local tools loading disabled. Set PRAISONAI_ALLOW_LOCAL_TOOLS=true to enable.")
+            custom_tools_module = None
+        elif os.path.exists(tools_path):
+            custom_tools_module = import_tools_from_file(tools_path)
+            logger.debug("Successfully imported custom tools from root tools.py")
         else:
-            for name, obj in custom_tools_module.__dict__.items():
-                if callable(obj) and not name.startswith("__"):
-                    tool_definition = getattr(obj, 'definition', None)
-                    if tool_definition:
-                        tools.append(tool_definition)
+            logger.debug("No custom tools.py file found in the root directory")
+            custom_tools_module = None
+
+        if custom_tools_module:
+            # Reset in place (keep the same list object other modules may hold a
+            # reference to) so a re-load replaces rather than appends.
+            tools.clear()
+            if hasattr(custom_tools_module, 'tools') and isinstance(custom_tools_module.tools, list):
+                tools.extend(custom_tools_module.tools)
+            else:
+                for name, obj in custom_tools_module.__dict__.items():
+                    if callable(obj) and not name.startswith("__"):
+                        tool_definition = getattr(obj, 'definition', None)
+                        if tool_definition:
+                            tools.append(tool_definition)
+    except Exception as e:
+        logger.warning(f"Error importing custom tools: {str(e)}. Continuing without custom tools.")
+
+
+def build_call_app(*, load_local_tools: bool = False):
+    """Build a fresh FastAPI app with the call routes registered.
+
+    Heavy deps (FastAPI, the agent-invoke router) are imported here, not at
+    module import time. When ``load_local_tools`` is true and the env opt-in is
+    set, ``./tools.py`` is loaded into the shared ``tools`` registry.
+    """
+    from fastapi import FastAPI
+
+    app = FastAPI()
+
+    try:
+        from .agent_invoke import router as agent_invoke_router
+        app.include_router(agent_invoke_router)
+        logger.debug("Agent invoke router added for n8n integration")
+    except ImportError as e:
+        logger.warning(f"Could not load agent invoke router: {e}")
+
+    _register_routes(app)
+
+    if load_local_tools:
+        _load_local_tools()
+
+    return app
+
+
+_app = None
+
+
+def __getattr__(name):
+    """Lazily construct the module-level ``app`` on first access.
+
+    Preserves the ``praisonai.api.call.app`` attribute for third parties that
+    import the name directly, without building a FastAPI app (and pulling its
+    transitive deps) merely because the module was imported.
+    """
+    if name == "app":
+        global _app
+        if _app is None:
+            _app = build_call_app()
+        return _app
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def _register_routes(app):
+    """Register the voice-call HTTP/WebSocket routes on ``app``.
+
+    Handlers are defined at module scope (below) and attached here so the app is
+    built lazily by :func:`build_call_app` without any import-time app object.
+
+    The handlers are annotation-free at module scope to keep ``import
+    praisonai.api.call`` free of a top-level ``fastapi`` dependency. FastAPI
+    resolves framework objects (``Request``/``WebSocket``) by *annotation*, not
+    by parameter name, so the real classes are stamped onto the handlers here —
+    at build time, where ``fastapi`` is already imported — before registration.
+    Without this, an unannotated ``request`` parameter is treated as a required
+    query parameter and the ``/`` route 422s.
+    """
+    from fastapi import Request, WebSocket
+    from fastapi.responses import HTMLResponse
+
+    handle_incoming_call.__annotations__["request"] = Request
+    handle_media_stream.__annotations__["websocket"] = WebSocket
+
+    app.add_api_route(
+        "/status", index_page, methods=["GET"], response_class=HTMLResponse
+    )
+    app.add_api_route("/", handle_incoming_call, methods=["GET", "POST"])
+    app.add_api_websocket_route("/media-stream", handle_media_stream)
 
-except Exception as e:
-    logger.warning(f"Error importing custom tools: {str(e)}. Continuing without custom tools.")
 
-@app.get("/status", response_class=HTMLResponse)
 async def index_page():
     return """
     <html>
@@ -251,11 +328,13 @@ async def index_page():
     </html>
     """
 
-from fastapi import HTTPException, status
 
-@app.api_route("/", methods=["GET", "POST"])
-async def handle_incoming_call(request: Request):
+async def handle_incoming_call(request):
     """Handle incoming call and return TwiML response to connect to Media Stream."""
+    from fastapi import HTTPException, status
+    from fastapi.responses import HTMLResponse
+    from twilio.twiml.voice_response import VoiceResponse, Connect
+
     if not CALL_SERVER_TOKEN:
         raise HTTPException(
             status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
@@ -298,9 +377,11 @@ async def handle_incoming_call(request: Request):
     response.append(connect)
     return HTMLResponse(content=str(response), media_type="application/xml")
 
-@app.websocket("/media-stream")
-async def handle_media_stream(websocket: WebSocket):
+async def handle_media_stream(websocket):
     """Handle WebSocket connections between Twilio and OpenAI."""
+    import websockets
+    from fastapi.websockets import WebSocketDisconnect
+
     global active_connections
     
     # 1. Authentication — accept a one-shot, per-connection session token
@@ -498,6 +579,8 @@ async def send_session_update(openai_ws):
     await openai_ws.send(json.dumps(session_update))
 
 def setup_public_url(port):
+    from pyngrok import ngrok, conf
+
     if NGROK_AUTH_TOKEN:
         conf.get_default().auth_token = NGROK_AUTH_TOKEN
     public_url = ngrok.connect(addr=str(port)).public_url
@@ -506,6 +589,8 @@ def setup_public_url(port):
 
 def run_server(port: int, host: str = "127.0.0.1", use_public: bool = False):
     """Run the FastAPI server using uvicorn."""
+    import uvicorn
+
     if not OPENAI_API_KEY:
         raise ValueError('Missing the OpenAI API key. Please set it in the .env file or configure it through the GUI.')
     
@@ -522,6 +607,9 @@ def run_server(port: int, host: str = "127.0.0.1", use_public: bool = False):
 
     os.environ["PRAISONAI_CALL_BIND_HOST"] = host
 
+    # Build the app here (server entry point) — this is the only place local
+    # tools.py is loaded, and only when PRAISONAI_ALLOW_LOCAL_TOOLS is set.
+    app = build_call_app(load_local_tools=True)
     uvicorn.run(app, host=host, port=port, log_level="warning")
 
 def main(args=None):

{praisonai-4.7.0 → praisonai-4.7.1}/praisonai/cli/_shim.py

@@ -33,10 +33,14 @@ the moved package.
 from __future__ import annotations
 
 import importlib
+import logging
+import os
 import pkgutil
 import sys
 from importlib.machinery import ModuleSpec
 
+_logger = logging.getLogger(__name__)
+
 
 class _RedirectLoader:
     """Loader that returns an already-imported module without re-executing it."""
@@ -75,25 +79,35 @@ class _AliasFinder:
 
 
 def _register_submodules(old_name: str, new_name: str, module) -> None:
-    """Eagerly import the moved subtree and alias each submodule.
+    """Alias the moved subtree under the old dotted name.
 
     Registering each moved submodule under its old dotted name in
     ``sys.modules`` guarantees that a later ``import old_name.sub`` finds the
     identical object immediately, never re-executing the file (which would
-    create duplicate class/enum objects). Modules that fail to import eagerly
-    (e.g. optional heavy dependencies not installed) are skipped and resolved
-    lazily by :class:`_AliasFinder` on first successful use.
-
-    Eager pre-registration is required for correctness, not just startup speed:
-    if the alias for ``old_name.sub`` is *absent* when a combined statement such
-    as ``from old_name.sub import Symbol`` runs, CPython imports the parent
-    shim, then resolves ``.sub`` through :class:`_AliasFinder.find_spec`, which
-    calls ``import_module`` re-entrantly *inside* the parent's in-progress
-    import. Under the import lock that re-entrancy loads the moved file twice,
+    create duplicate class/enum objects).
+
+    Eager pre-registration is required for **correctness**, not merely startup
+    speed. If the alias for ``old_name.sub`` is *absent* when a statement such as
+    ``from old_name.sub import Symbol`` (or ``import old_name.sub``) runs first,
+    CPython imports the parent shim, then resolves ``.sub`` through
+    :class:`_AliasFinder.find_spec`, which calls ``import_module`` re-entrantly.
+    Under the import lock that re-entrancy can load the moved file *twice*,
     producing two distinct module objects (duplicate classes) and breaking
-    module identity (guarantee #1). Pre-stamping ``sys.modules[old_name.sub]``
-    here means ``_find_and_load`` returns the single canonical object directly
-    and never re-enters the finder.
+    module identity — so ``old_name.sub is new_name.sub`` becomes ``False`` and
+    ``unittest.mock.patch("old_name.sub.attr")`` no longer patches the object the
+    running code (importing via the new name) actually uses.
+
+    Pre-stamping ``sys.modules[old_name.sub]`` here means ``_find_and_load``
+    returns the single canonical object directly and never re-enters the finder.
+    Modules that fail to import eagerly (optional heavy deps not installed) are
+    logged and left for :class:`_AliasFinder` to resolve lazily on first use, so
+    a partial install still starts cleanly.
+
+    Set ``PRAISONAI_SHIM_LAZY=1`` to opt *out* of the eager subtree walk (pure
+    lazy resolution). This trades the module-identity guarantee above for not
+    importing the moved subtree at shim-install time; only use it when nothing in
+    the process relies on ``old_name.sub is new_name.sub`` (e.g. no ``mock.patch``
+    against the old dotted path).
     """
     new_prefix = new_name + "."
 
@@ -109,6 +123,12 @@ def _register_submodules(old_name: str, new_name: str, module) -> None:
             old_equiv = old_name + mod_name[len(new_name):]
             sys.modules.setdefault(old_equiv, mod)
 
+    if os.environ.get("PRAISONAI_SHIM_LAZY", "").lower() in ("1", "true"):
+        # Explicit opt-out: rely solely on _AliasFinder for on-demand
+        # resolution. Callers choosing this must not depend on module identity
+        # across the old/new dotted paths (see docstring).
+        return
+
     search_path = getattr(module, "__path__", None)
     if not search_path:
         return
@@ -120,7 +140,22 @@ def _register_submodules(old_name: str, new_name: str, module) -> None:
             try:
                 sub = importlib.import_module(info.name)
             except Exception:
+                # Do not swallow silently: a downstream AttributeError on the
+                # alias with no traceback pointing here is the opposite of
+                # "safe by default". Log and let _AliasFinder retry lazily.
+                _logger.warning(
+                    "shim: eager import of %s failed; will be resolved lazily",
+                    info.name,
+                    exc_info=True,
+                )
                 continue
+        # ``sys.modules[info.name]`` may be a ``None`` placeholder (CPython
+        # records known-absent submodules that way). Aliasing one would poison
+        # the old dotted name so ``import old_name.sub`` raises "None in
+        # sys.modules" before _AliasFinder can resolve it lazily — mirror the
+        # guard in the already-imported pass above.
+        if sub is None:
+            continue
         old_equiv = old_name + info.name[len(new_name):]
         sys.modules.setdefault(old_equiv, sub)
 

{praisonai-4.7.0 → praisonai-4.7.1}/praisonai/db/adapter.py

@@ -889,7 +889,7 @@ class PraisonAIDB:
             await self._dispatch_async(
                 self._state_store,
                 "set",
-                "aset",
+                "async_set",
                 f"agent:{session_id}",
                 {
                     "agent_name": agent_name,
@@ -1039,7 +1039,7 @@ class PraisonAIDB:
             # instead of overwriting it with a disconnected "ended" record.
             agent_key = f"agent:{session_id}"
             agent_data = await self._dispatch_async(
-                self._state_store, "get", "aget", agent_key
+                self._state_store, "get", "async_get", agent_key
             ) or {}
             agent_data.update({
                 "status": "ended",
@@ -1047,7 +1047,7 @@ class PraisonAIDB:
                 "metadata": {**agent_data.get("metadata", {}), **(metadata or {})},
             })
             await self._dispatch_async(
-                self._state_store, "set", "aset", agent_key, agent_data
+                self._state_store, "set", "async_set", agent_key, agent_data
             )
 
     async def aon_run_start(
@@ -1065,7 +1065,7 @@ class PraisonAIDB:
             await self._dispatch_async(
                 self._state_store,
                 "set",
-                "aset",
+                "async_set",
                 run_key,
                 {
                     "run_id": run_id,
@@ -1092,7 +1092,7 @@ class PraisonAIDB:
         if self._state_store:
             run_key = f"run:{session_id}:{run_id}"
             run_data = await self._dispatch_async(
-                self._state_store, "get", "aget", run_key
+                self._state_store, "get", "async_get", run_key
             ) or {}
             run_data.update({
                 "ended_at": time.time(),
@@ -1102,7 +1102,7 @@ class PraisonAIDB:
                 "metadata": {**run_data.get("metadata", {}), **(metadata or {})},
             })
             await self._dispatch_async(
-                self._state_store, "set", "aset", run_key, run_data
+                self._state_store, "set", "async_set", run_key, run_data
             )
 
     async def aclose(self) -> None: