PraisonAI 4.7.9__tar.gz → 4.7.10__tar.gz

{praisonai-4.7.9 → praisonai-4.7.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.9
+Version: 4.7.10
 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.7
-Requires-Dist: praisonai-code>=0.1.6
-Requires-Dist: praisonai-bot>=0.1.6
-Requires-Dist: praisonai-train>=0.1.6
-Requires-Dist: praisonai-browser>=0.1.6
-Requires-Dist: praisonai-mcp>=0.1.8
-Requires-Dist: praisonai-sandbox>=0.1.6
-Requires-Dist: praisonai-deploy>=0.1.6
+Requires-Dist: praisonaiagents>=1.7.8
+Requires-Dist: praisonai-code>=0.1.7
+Requires-Dist: praisonai-bot>=0.1.7
+Requires-Dist: praisonai-train>=0.1.7
+Requires-Dist: praisonai-browser>=0.1.7
+Requires-Dist: praisonai-mcp>=0.1.9
+Requires-Dist: praisonai-sandbox>=0.1.7
+Requires-Dist: praisonai-deploy>=0.1.7
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.7.9 → praisonai-4.7.10}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.9
+Version: 4.7.10
 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.7
-Requires-Dist: praisonai-code>=0.1.6
-Requires-Dist: praisonai-bot>=0.1.6
-Requires-Dist: praisonai-train>=0.1.6
-Requires-Dist: praisonai-browser>=0.1.6
-Requires-Dist: praisonai-mcp>=0.1.8
-Requires-Dist: praisonai-sandbox>=0.1.6
-Requires-Dist: praisonai-deploy>=0.1.6
+Requires-Dist: praisonaiagents>=1.7.8
+Requires-Dist: praisonai-code>=0.1.7
+Requires-Dist: praisonai-bot>=0.1.7
+Requires-Dist: praisonai-train>=0.1.7
+Requires-Dist: praisonai-browser>=0.1.7
+Requires-Dist: praisonai-mcp>=0.1.9
+Requires-Dist: praisonai-sandbox>=0.1.7
+Requires-Dist: praisonai-deploy>=0.1.7
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.7.9 → praisonai-4.7.10}/PraisonAI.egg-info/SOURCES.txt

@@ -314,6 +314,7 @@ praisonai/integration/pages/bot_health.py
 praisonai/integration/pages/workflow_runs.py
 praisonai/integrations/__init__.py
 praisonai/integrations/_cli_loaders.py
+praisonai/integrations/_managed_base.py
 praisonai/integrations/_session_info.py
 praisonai/integrations/_tool_aliases.py
 praisonai/integrations/backend_registry.py

{praisonai-4.7.9 → praisonai-4.7.10}/PraisonAI.egg-info/requires.txt

@@ -1,14 +1,14 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.7.7
-praisonai-code>=0.1.6
-praisonai-bot>=0.1.6
-praisonai-train>=0.1.6
-praisonai-browser>=0.1.6
-praisonai-mcp>=0.1.8
-praisonai-sandbox>=0.1.6
-praisonai-deploy>=0.1.6
+praisonaiagents>=1.7.8
+praisonai-code>=0.1.7
+praisonai-bot>=0.1.7
+praisonai-train>=0.1.7
+praisonai-browser>=0.1.7
+praisonai-mcp>=0.1.9
+praisonai-sandbox>=0.1.7
+praisonai-deploy>=0.1.7
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.7.9 → praisonai-4.7.10}/praisonai/_entrypoint.py

@@ -100,6 +100,14 @@ def run(agent_file: str,
     """
     from .agents_generator import AgentsGenerator
 
+    # Wire the built-in readers/retrievers/rerankers into the core-SDK
+    # registries so YAML/CLI declarations (e.g. `retriever: fusion`,
+    # `reranker: llm`) resolve. Idempotent + thread-safe, and register-only-if-
+    # absent: a custom adapter already registered under a built-in name (e.g. a
+    # multi-tenant host's own `fusion`) is preserved, never overwritten.
+    from .adapters import register_default_adapters
+    register_default_adapters()
+
     adapter, config_list = _resolve_run_inputs(framework)
     _apply_model_override(config_list, kwargs)
     cli_config = _merge_cli_config(cli_config, kwargs)
@@ -134,6 +142,14 @@ async def arun(agent_file: str,
 
     from .agents_generator import AgentsGenerator
 
+    # Wire the built-in readers/retrievers/rerankers into the core-SDK
+    # registries so YAML/CLI declarations resolve. Run off the event loop since
+    # registration performs lazy imports. Idempotent + thread-safe, and
+    # register-only-if-absent: a custom adapter already registered under a
+    # built-in name is preserved, never overwritten.
+    from .adapters import register_default_adapters
+    await asyncio.to_thread(register_default_adapters)
+
     # Resolve framework + build config_list off the caller's event loop so the
     # synchronous credential/config-file I/O does not block it. This is the
     # reason arun exists: a FastAPI handler awaiting arun must not stall the loop.

{praisonai-4.7.9 → praisonai-4.7.10}/praisonai/adapters/readers.py

@@ -389,25 +389,35 @@ def register_default_readers():
     from praisonaiagents.knowledge.readers import get_reader_registry
     
     registry = get_reader_registry()
-    
+
+    # Preserve any existing entry: an application (or a multi-tenant host) may
+    # have already registered a custom reader under a built-in name. Wiring the
+    # wrapper defaults must never silently replace it, so register only names
+    # that are not already present.
+    existing = set(registry.list_readers())
+
+    def _register(name, factory, extensions=None):
+        if name not in existing:
+            registry.register(name, factory, extensions)
+
     # Register text reader
-    registry.register("text", TextReader, ["txt", "text", "log"])
-    
+    _register("text", TextReader, ["txt", "text", "log"])
+
     # Register markitdown reader
-    registry.register("markitdown", MarkItDownReader, MarkItDownReader.supported_extensions)
-    
+    _register("markitdown", MarkItDownReader, MarkItDownReader.supported_extensions)
+
     # Register directory reader
-    registry.register("directory", DirectoryReader)
-    
+    _register("directory", DirectoryReader)
+
     # Register glob reader
-    registry.register("glob", GlobReader)
-    
+    _register("glob", GlobReader)
+
     # Register URL reader
-    registry.register("url", URLReader)
-    
+    _register("url", URLReader)
+
     # Register auto reader
-    registry.register("auto", AutoReader)
-    
+    _register("auto", AutoReader)
+
     logger.debug("Registered default readers")
 
 

{praisonai-4.7.9 → praisonai-4.7.10}/praisonai/adapters/rerankers.py

@@ -324,18 +324,25 @@ def register_default_rerankers():
     from praisonaiagents.knowledge.rerankers import get_reranker_registry
     
     registry = get_reranker_registry()
-    
+
+    # Preserve any existing entry: an application (or a multi-tenant host) may
+    # have already registered a custom reranker under a built-in name. Wiring
+    # the wrapper defaults must never silently replace it, so register only
+    # names that are not already present.
+    existing = set(registry.list_rerankers())
+
     # LLM reranker is always available
-    registry.register("llm", LLMReranker)
-    
+    if "llm" not in existing:
+        registry.register("llm", LLMReranker)
+
     # Cross-encoder if available
-    if _check_sentence_transformers():
+    if "cross_encoder" not in existing and _check_sentence_transformers():
         registry.register("cross_encoder", CrossEncoderReranker)
-    
+
     # Cohere if available
-    if _check_cohere():
+    if "cohere" not in existing and _check_cohere():
         registry.register("cohere", CohereReranker)
-    
+
     logger.debug("Registered default rerankers")
 
 

{praisonai-4.7.9 → praisonai-4.7.10}/praisonai/adapters/retrievers.py

@@ -595,13 +595,22 @@ def register_default_retrievers():
     from praisonaiagents.knowledge.retrieval import get_retriever_registry
     
     registry = get_retriever_registry()
-    
-    registry.register("basic", BasicRetriever)
-    registry.register("fusion", FusionRetriever)
-    registry.register("recursive", RecursiveRetriever)
-    registry.register("auto_merge", AutoMergeRetriever)
-    registry.register("hybrid", HybridRetriever)
-    
+
+    # Preserve any existing entry: an application (or a multi-tenant host) may
+    # have already registered a custom retriever under a built-in name. Wiring
+    # the wrapper defaults must never silently replace it, so register only
+    # names that are not already present.
+    existing = set(registry.list_retrievers())
+    for name, factory in (
+        ("basic", BasicRetriever),
+        ("fusion", FusionRetriever),
+        ("recursive", RecursiveRetriever),
+        ("auto_merge", AutoMergeRetriever),
+        ("hybrid", HybridRetriever),
+    ):
+        if name not in existing:
+            registry.register(name, factory)
+
     logger.debug("Registered default retrievers")
 
 

praisonai-4.7.10/praisonai/integrations/_managed_base.py

@@ -0,0 +1,87 @@
+"""Shared scaffolding for ``ManagedBackendProtocol`` implementations.
+
+``AnthropicManagedAgent`` (managed_agents.py) and ``LocalManagedAgent``
+(managed_local.py) implement the same protocol contract and historically
+re-implemented the same ``stream()`` producer/queue/sentinel scaffolding twice.
+That duplication meant the async-safety fix for ``loop.run_in_executor`` and any
+future protocol change had to be edited — and kept in sync — in two places.
+
+``ManagedBackendBase`` owns that single copy of the queue pump. Concrete
+backends implement only what actually differs:
+
+    - ``_ensure_session()``            -> return a session id (already present on
+      both concrete backends).
+    - ``_iter_events(session_id, prompt)`` -> a *synchronous* iterator of text
+      chunks. Runs on the producer thread, so blocking SDK calls are fine here.
+    - ``_after_stream(full)`` [optional] -> post-stream bookkeeping (e.g. the
+      local backend persists the assembled assistant turn + usage). Default is a
+      no-op.
+
+A third managed backend then implements two methods rather than copying the
+whole streaming loop.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import queue
+import threading
+from typing import AsyncIterator, Iterator, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class ManagedBackendBase:
+    """Mixin providing the shared ``stream()`` queue pump.
+
+    Subclasses supply the session provider and the (synchronous) event source;
+    this class turns them into an async generator without each backend shipping
+    its own copy of the producer-thread + sentinel-queue plumbing.
+    """
+
+    def _ensure_session(self) -> str:  # pragma: no cover - implemented by subclass
+        raise NotImplementedError
+
+    def _iter_events(self, session_id: str, prompt: str) -> Iterator[str]:  # pragma: no cover
+        """Yield text chunks for ``prompt`` on ``session_id`` (runs on a thread)."""
+        raise NotImplementedError
+
+    def _after_stream(self, full: str) -> None:
+        """Hook for post-stream bookkeeping. Default: no-op."""
+
+    async def stream(self, prompt: str, **kwargs) -> AsyncIterator[str]:
+        """Yield text chunks as the managed agent produces them.
+
+        The synchronous ``_iter_events`` producer runs on a daemon thread and
+        feeds a sentinel-terminated queue; the event loop is never blocked.
+        """
+        loop = asyncio.get_running_loop()
+        q: "queue.Queue[Optional[str]]" = queue.Queue()
+
+        def _producer() -> None:
+            full = ""
+            try:
+                session_id = self._ensure_session()
+                for chunk in self._iter_events(session_id, prompt):
+                    if chunk:
+                        text = str(chunk)
+                        q.put(text)
+                        full += text
+            except Exception as e:  # noqa: BLE001 - surface, don't crash the loop
+                logger.error("[managed] stream error: %s", e)
+            finally:
+                try:
+                    self._after_stream(full)
+                except Exception as e:  # noqa: BLE001
+                    logger.error("[managed] post-stream hook error: %s", e)
+                q.put(None)  # sentinel
+
+        thread = threading.Thread(target=_producer, daemon=True)
+        thread.start()
+
+        while True:
+            chunk = await loop.run_in_executor(None, q.get)
+            if chunk is None:
+                break
+            yield chunk

praisonai-4.7.10/praisonai/integrations/backend_registry.py

@@ -0,0 +1,129 @@
+"""Registry of managed agent-runtime backends.
+
+This moves provider -> backend resolution off the hardcoded ``if provider !=
+"anthropic"`` switch in :mod:`hosted_agent` and onto the same plugin-registry
+primitive used for framework adapters. A third-party package can register a
+``praisonai.managed_backends`` entry point and have ``HostedAgent(provider=...)``
+resolve it with no core change.
+
+Builtins:
+    - ``anthropic`` -> :class:`AnthropicManagedAgent`
+
+Future entry-point backends (e.g. ``e2b``, ``modal``, ``flyio``) register
+themselves under the ``praisonai.managed_backends`` group.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+from typing import Type
+
+from .._registry import PluginRegistry
+
+logger = logging.getLogger(__name__)
+
+
+def _anthropic_loader() -> Type:
+    from .managed_agents import AnthropicManagedAgent
+    return AnthropicManagedAgent
+
+
+# Compute places that cannot host a whole agent loop, so they are never
+# registered as managed backends: `ssh` needs an object rather than a name;
+# `local`/`native`/`subprocess` would run the agent in your own shell (which is
+# what you get by passing nothing); `sandlock` isolates tools rather than
+# hosting a runtime.
+_COMPUTE_SKIP = {"ssh", "local", "native", "subprocess", "sandlock"}
+
+
+_BUILTIN_BACKENDS = {
+    "anthropic": _anthropic_loader,
+    # Compute-backed loaders (docker + every other compute place able to host a
+    # whole agent loop) are registered lazily inside the registry -- see
+    # ``_ensure_compute_registered`` -- so a bare import of this module pays
+    # nothing: no entry-point walk, no core-SDK import, no closure minting.
+}
+
+
+class ManagedBackendRegistry(PluginRegistry):
+    """Registry for managed agent-runtime backends with entry-point support."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            entry_point_group="praisonai.managed_backends",
+            builtins=_BUILTIN_BACKENDS,
+        )
+        self._compute_registered = False
+        self._compute_lock = threading.Lock()
+
+    def _ensure_compute_registered(self) -> None:
+        """Discover compute-backed backends on first lookup, not at import.
+
+        ``run_on=`` accepted two names while ``tools_run_on=`` accepted twelve,
+        which was an implementation detail leaking into the vocabulary: a place
+        that can run a command can run the agent loop, which is just one more
+        command. One generic backend covers them all. `docker` used to be
+        excluded here in favour of a bespoke backend, but that named its
+        containers in a shape ``DockerCompute``'s lookup did not recognise, so
+        the generic path is used for reclaim.
+
+        The probe (an entry-point walk plus a core-SDK import) runs at most once
+        and only when a backend is actually requested by name.
+        """
+        if self._compute_registered:
+            return
+        with self._compute_lock:
+            if self._compute_registered:
+                return
+            try:
+                from .compute_managed_agent import make_loader
+                from praisonaiagents.managed._compute_bridge import (
+                    available_providers,
+                )
+
+                for name in available_providers():
+                    if name in _COMPUTE_SKIP or name in _BUILTIN_BACKENDS:
+                        continue
+                    # Never clobber a name an entry-point plugin already claimed.
+                    # A third-party ``praisonai.managed_backends`` plugin using a
+                    # compute-provider name (e.g. ``docker``, ``modal``, ``e2b``)
+                    # is loaded when the registry is constructed; the generic
+                    # compute loader must not replace it on first lookup. Use the
+                    # base membership check (``PluginRegistry.has``) rather than
+                    # our own overridden ``has``, which would re-enter
+                    # ``_ensure_compute_registered`` and deadlock on the
+                    # (non-reentrant) compute lock.
+                    if super().has(name):
+                        logger.debug(
+                            "compute provider %r already registered (entry-point "
+                            "plugin or builtin); keeping the existing backend",
+                            name,
+                        )
+                        continue
+                    self._add_loader(name, make_loader(name))
+            except Exception:
+                # A broken/absent compute plugin must not be silently invisible.
+                logger.debug(
+                    "compute backend discovery failed; falling back to the "
+                    "anthropic-only registry",
+                    exc_info=True,
+                )
+            self._compute_registered = True
+
+    def resolve(self, name: str) -> Type:
+        self._ensure_compute_registered()
+        return super().resolve(name)
+
+    def list_names(self) -> list[str]:
+        self._ensure_compute_registered()
+        return super().list_names()
+
+    def has(self, name: str) -> bool:
+        self._ensure_compute_registered()
+        return super().has(name)
+
+
+def get_backend_registry() -> "ManagedBackendRegistry":
+    """Return the process-default managed-backend registry."""
+    return ManagedBackendRegistry.default()

{praisonai-4.7.9 → praisonai-4.7.10}/praisonai/integrations/managed_agents.py

@@ -35,6 +35,8 @@ from dataclasses import dataclass, field
 from typing import AsyncIterator, Callable, Dict, Any, Optional, List, Union
 from enum import Enum
 
+from ._managed_base import ManagedBackendBase
+
 logger = logging.getLogger(__name__)
 
 
@@ -235,7 +237,7 @@ class ManagedConfig:
     vault_ids: List[str] = field(default_factory=list)
 
 
-class AnthropicManagedAgent:
+class AnthropicManagedAgent(ManagedBackendBase):
     """Anthropic Managed Agents backend for PraisonAI.
 
     Satisfies ``ManagedBackendProtocol`` (Core SDK).  All heavy SDK usage
@@ -783,48 +785,32 @@ class AnthropicManagedAgent:
                 emitter.agent_end(agent_name)
 
     # ------------------------------------------------------------------
-    # stream() — ManagedBackendProtocol
+    # stream() — ManagedBackendProtocol (via ManagedBackendBase)
     # ------------------------------------------------------------------
-    async def stream(self, prompt: str, **kwargs) -> AsyncIterator[str]:
-        """Yield text chunks as the managed agent produces them."""
-        loop = asyncio.get_running_loop()
-        import queue
-        import threading
+    def _iter_events(self, session_id: str, prompt: str):
+        """Yield agent-message text chunks off the Anthropic SSE stream.
 
-        q: queue.Queue[Optional[str]] = queue.Queue()
-
-        def _producer():
-            try:
-                client = self._get_client()
-                session_id = self._ensure_session()
-                with client.beta.sessions.events.stream(session_id) as s:
-                    client.beta.sessions.events.send(
-                        session_id,
-                        events=[{
-                            "type": "user.message",
-                            "content": [{"type": "text", "text": prompt}],
-                        }],
-                    )
-                    for event in s:
-                        etype = getattr(event, "type", None)
-                        if etype == "agent.message":
-                            for block in getattr(event, "content", []):
-                                text = getattr(block, "text", None)
-                                if text:
-                                    q.put(text)
-                        elif etype == "session.status_idle":
-                            break
-            finally:
-                q.put(None)  # sentinel
-
-        thread = threading.Thread(target=_producer, daemon=True)
-        thread.start()
-
-        while True:
-            chunk = await loop.run_in_executor(None, q.get)
-            if chunk is None:
-                break
-            yield chunk
+        Runs on ``ManagedBackendBase.stream``'s producer thread, so the blocking
+        SDK stream context is fine here.
+        """
+        client = self._get_client()
+        with client.beta.sessions.events.stream(session_id) as s:
+            client.beta.sessions.events.send(
+                session_id,
+                events=[{
+                    "type": "user.message",
+                    "content": [{"type": "text", "text": prompt}],
+                }],
+            )
+            for event in s:
+                etype = getattr(event, "type", None)
+                if etype == "agent.message":
+                    for block in getattr(event, "content", []):
+                        text = getattr(block, "text", None)
+                        if text:
+                            yield text
+                elif etype == "session.status_idle":
+                    return
 
     # ------------------------------------------------------------------
     # Session management — ManagedBackendProtocol

{praisonai-4.7.9 → praisonai-4.7.10}/praisonai/integrations/managed_local.py

@@ -57,6 +57,7 @@ _DEFAULT_TOOLS = [
     "search_web",
 ]
 
+from ._managed_base import ManagedBackendBase
 from ._tool_aliases import TOOL_ALIAS_MAP
 
 
@@ -198,7 +199,7 @@ def _build_custom_tool_fn(
     return _custom_fn
 
 
-class LocalManagedAgent:
+class LocalManagedAgent(ManagedBackendBase):
     """Provider-agnostic local managed agent backend.
 
     Satisfies ``ManagedBackendProtocol`` (Core SDK).  Uses PraisonAI's own
@@ -756,9 +757,18 @@ class LocalManagedAgent:
         return self._inner_agent
 
     def _ensure_session(self) -> str:
-        """Create a session ID if not set."""
+        """Create a session ID if not set.
+
+        Creates the inner agent *before* persisting the session so ``agent_id``
+        and ``environment_id`` are populated in the first persisted snapshot.
+        The shared ``ManagedBackendBase.stream`` calls ``_ensure_session`` ahead
+        of ``_iter_events``; without this the local backend would persist an
+        orphaned session with null IDs, and a subsequent ``_ensure_agent``
+        failure would leave that incomplete state behind.
+        """
         if self._session_id:
             return self._session_id
+        self._ensure_agent()
         self._session_id = f"session_{uuid.uuid4().hex[:12]}"
         self._session_history.append({
             "id": self._session_id,
@@ -852,51 +862,30 @@ class LocalManagedAgent:
                 emitter.agent_end(agent_name)
 
     # ------------------------------------------------------------------
-    # stream() — ManagedBackendProtocol
+    # stream() — ManagedBackendProtocol (via ManagedBackendBase)
     # ------------------------------------------------------------------
-    async def stream(self, prompt: str, **kwargs) -> AsyncIterator[str]:
-        """Yield text chunks as the agent produces them."""
-        import queue
-        import threading
-
-        loop = asyncio.get_running_loop()
-        q: queue.Queue[Optional[str]] = queue.Queue()
+    def _iter_events(self, session_id: str, prompt: str):
+        """Yield text chunks from the local ``Agent.chat`` loop.
 
-        def _producer():
-            full = ""
-            try:
-                agent = self._ensure_agent()
-                self._ensure_session()
-                self._persist_message("user", prompt)
-                gen = agent.chat(prompt, stream=True)
-                if hasattr(gen, '__iter__'):
-                    for chunk in gen:
-                        if chunk:
-                            text = str(chunk)
-                            q.put(text)
-                            full += text
-                else:
-                    if gen:
-                        text = str(gen)
-                        q.put(text)
-                        full = text
-            except Exception as e:
-                logger.error("[local_managed] stream error: %s", e)
-            finally:
-                if full:
-                    self._persist_message("assistant", full)
-                self._sync_usage()
-                self._persist_state()
-                q.put(None)
-
-        thread = threading.Thread(target=_producer, daemon=True)
-        thread.start()
-
-        while True:
-            chunk = await loop.run_in_executor(None, q.get)
-            if chunk is None:
-                break
-            yield chunk
+        Runs on ``ManagedBackendBase.stream``'s producer thread. Ensures the
+        inner agent exists and persists the user turn before streaming.
+        """
+        agent = self._ensure_agent()
+        self._persist_message("user", prompt)
+        gen = agent.chat(prompt, stream=True)
+        if hasattr(gen, '__iter__'):
+            for chunk in gen:
+                if chunk:
+                    yield str(chunk)
+        elif gen:
+            yield str(gen)
+
+    def _after_stream(self, full: str) -> None:
+        """Persist the assembled assistant turn + usage after streaming."""
+        if full:
+            self._persist_message("assistant", full)
+        self._sync_usage()
+        self._persist_state()
 
     # ------------------------------------------------------------------
     # Session management — ManagedBackendProtocol

praisonai-4.7.10/praisonai/version.py

@@ -0,0 +1 @@
+__version__ = "4.7.10"