PraisonAI 4.7.11__tar.gz → 4.7.13__tar.gz

{praisonai-4.7.11 → praisonai-4.7.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.11
+Version: 4.7.13
 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.9
-Requires-Dist: praisonai-code>=0.1.8
-Requires-Dist: praisonai-bot>=0.1.8
-Requires-Dist: praisonai-train>=0.1.8
-Requires-Dist: praisonai-browser>=0.1.8
-Requires-Dist: praisonai-mcp>=0.1.10
-Requires-Dist: praisonai-sandbox>=0.1.8
-Requires-Dist: praisonai-deploy>=0.1.8
+Requires-Dist: praisonaiagents>=1.7.11
+Requires-Dist: praisonai-code>=0.1.10
+Requires-Dist: praisonai-bot>=0.1.10
+Requires-Dist: praisonai-train>=0.1.10
+Requires-Dist: praisonai-browser>=0.1.10
+Requires-Dist: praisonai-mcp>=0.1.12
+Requires-Dist: praisonai-sandbox>=0.1.10
+Requires-Dist: praisonai-deploy>=0.1.10
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0
@@ -182,7 +182,7 @@ Requires-Dist: psycopg2-binary>=2.9.0; extra == "postgresql"
 Provides-Extra: dynamodb
 Requires-Dist: boto3>=1.35.0; extra == "dynamodb"
 Provides-Extra: valkey
-Requires-Dist: valkey-glide-sync>=2.3.1; extra == "valkey"
+Requires-Dist: valkey-glide-sync>=2.5.2; extra == "valkey"
 Provides-Extra: neon
 Requires-Dist: psycopg2-binary>=2.9.0; extra == "neon"
 Provides-Extra: turso

{praisonai-4.7.11 → praisonai-4.7.13}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.11
+Version: 4.7.13
 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.9
-Requires-Dist: praisonai-code>=0.1.8
-Requires-Dist: praisonai-bot>=0.1.8
-Requires-Dist: praisonai-train>=0.1.8
-Requires-Dist: praisonai-browser>=0.1.8
-Requires-Dist: praisonai-mcp>=0.1.10
-Requires-Dist: praisonai-sandbox>=0.1.8
-Requires-Dist: praisonai-deploy>=0.1.8
+Requires-Dist: praisonaiagents>=1.7.11
+Requires-Dist: praisonai-code>=0.1.10
+Requires-Dist: praisonai-bot>=0.1.10
+Requires-Dist: praisonai-train>=0.1.10
+Requires-Dist: praisonai-browser>=0.1.10
+Requires-Dist: praisonai-mcp>=0.1.12
+Requires-Dist: praisonai-sandbox>=0.1.10
+Requires-Dist: praisonai-deploy>=0.1.10
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0
@@ -182,7 +182,7 @@ Requires-Dist: psycopg2-binary>=2.9.0; extra == "postgresql"
 Provides-Extra: dynamodb
 Requires-Dist: boto3>=1.35.0; extra == "dynamodb"
 Provides-Extra: valkey
-Requires-Dist: valkey-glide-sync>=2.3.1; extra == "valkey"
+Requires-Dist: valkey-glide-sync>=2.5.2; extra == "valkey"
 Provides-Extra: neon
 Requires-Dist: psycopg2-binary>=2.9.0; extra == "neon"
 Provides-Extra: turso

{praisonai-4.7.11 → praisonai-4.7.13}/PraisonAI.egg-info/SOURCES.txt

@@ -59,6 +59,7 @@ praisonai/capabilities/batches.py
 praisonai/capabilities/completions.py
 praisonai/capabilities/container_files.py
 praisonai/capabilities/containers.py
+praisonai/capabilities/decisions.py
 praisonai/capabilities/embeddings.py
 praisonai/capabilities/files.py
 praisonai/capabilities/fine_tuning.py

{praisonai-4.7.11 → praisonai-4.7.13}/PraisonAI.egg-info/requires.txt

@@ -1,14 +1,14 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.7.9
-praisonai-code>=0.1.8
-praisonai-bot>=0.1.8
-praisonai-train>=0.1.8
-praisonai-browser>=0.1.8
-praisonai-mcp>=0.1.10
-praisonai-sandbox>=0.1.8
-praisonai-deploy>=0.1.8
+praisonaiagents>=1.7.11
+praisonai-code>=0.1.10
+praisonai-bot>=0.1.10
+praisonai-train>=0.1.10
+praisonai-browser>=0.1.10
+praisonai-mcp>=0.1.12
+praisonai-sandbox>=0.1.10
+praisonai-deploy>=0.1.10
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0
@@ -249,7 +249,7 @@ libsql-experimental>=0.0.50
 aiui<0.4,>=0.3.121
 
 [valkey]
-valkey-glide-sync>=2.3.1
+valkey-glide-sync>=2.5.2
 
 [xata]
 psycopg2-binary>=2.9.0

{praisonai-4.7.11 → praisonai-4.7.13}/praisonai/_api_auth.py

@@ -15,8 +15,11 @@ def build_api_key_middleware(api_key: str, public_paths: Optional[Iterable[str]]
         api_key: The expected API key; requests must present it via a
             ``Bearer`` ``Authorization`` header or ``X-API-Key`` header.
         public_paths: Paths that bypass authentication. Any request whose path
-            is in this set, or starts with ``/__praisonai__/``, is allowed
-            through without a token.
+            is in this set, or is exactly ``/__praisonai__/discovery`` (the
+            unauthenticated capability document), is allowed through without a
+            token. The discovery path is matched exactly -- never by prefix --
+            so a server whose ``api_prefix`` happens to sit under
+            ``/__praisonai__`` does not silently expose its routes.
 
     Imports of ``hmac``/``starlette`` are kept inside this function so callers
     stay lazy-import friendly.
@@ -26,11 +29,12 @@ def build_api_key_middleware(api_key: str, public_paths: Optional[Iterable[str]]
     from starlette.responses import JSONResponse
 
     public = set(public_paths or ())
+    public.add("/__praisonai__/discovery")
 
     class _APIKeyMiddleware(BaseHTTPMiddleware):
         async def dispatch(self, request, call_next):
             path = request.url.path
-            if path in public or path.startswith("/__praisonai__/"):
+            if path in public:
                 return await call_next(request)
             auth = request.headers.get("Authorization", "")
             header_key = request.headers.get("X-API-Key", "")

{praisonai-4.7.11 → praisonai-4.7.13}/praisonai/_async_bridge.py

@@ -384,6 +384,37 @@ def run_sync(coro: Awaitable[T], *, timeout: "float | None | _Unset" = _UNSET) -
     return _default_bridge().run_sync(coro, timeout=timeout)
 
 
+def run_cli_coro(coro: Awaitable[T], *, timeout: "float | None | _Unset" = None) -> T:
+    """Preferred entry point for CLI subcommands running a coroutine.
+
+    Routes through the shared :class:`AsyncBridge` (via :func:`run_sync`) so
+    per-loop connection pools survive across calls, any embedder-installed
+    ``scoped_bridge()`` is honoured, and a fresh event loop is NOT spawned on
+    every invocation. This replaces bare ``asyncio.run(...)`` at CLI leaves,
+    which tears down the loop each call and breaks per-loop cached clients
+    (e.g. ``httpx.AsyncClient``) with ``RuntimeError: Event loop is closed``.
+
+    Timeout defaults to ``None`` (**unbounded**) to preserve the prior
+    ``asyncio.run(...)`` semantics these leaves replaced: CLI commands own their
+    own runtime (an interactive sandbox shell, a multi-artifact ``standardise``
+    run, or a long background job must not be aborted by the 300s ``run_sync``
+    default). Callers that want a deadline pass an explicit ``timeout=``.
+
+    Sync context  -> :func:`run_sync` on the shared background loop.
+    Async context -> ``RuntimeError``; the caller must ``await coro`` directly.
+    """
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return run_sync(coro, timeout=timeout)
+    with contextlib.suppress(Exception):
+        coro.close()  # type: ignore[attr-defined]
+    raise RuntimeError(
+        "run_cli_coro() cannot be called from within a running event loop; "
+        "await the coroutine directly instead."
+    )
+
+
 def run_sync_or_offload(
     coro: Awaitable[T],
     *,

{praisonai-4.7.11 → praisonai-4.7.13}/praisonai/_entrypoint.py

@@ -100,14 +100,9 @@ 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 wiring (readers/retrievers/rerankers) is single-sourced in
+    # AgentsGenerator.__init__ so every launch path (CLI, serve, eval, Python)
+    # is covered identically.
     adapter, config_list = _resolve_run_inputs(framework)
     _apply_model_override(config_list, kwargs)
     cli_config = _merge_cli_config(cli_config, kwargs)
@@ -142,11 +137,11 @@ 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.
+    # Adapter wiring (readers/retrievers/rerankers) is single-sourced in
+    # AgentsGenerator.__init__. Pre-warm it off the caller's event loop here so
+    # the (lazy-import) registration does not run on the loop when the generator
+    # is constructed synchronously below. Idempotent: __init__ then hits the fast
+    # path. Every launch path is covered identically via __init__.
     from .adapters import register_default_adapters
     await asyncio.to_thread(register_default_adapters)
 
@@ -159,7 +154,8 @@ async def arun(agent_file: str,
 
     # Own the generator's lifecycle so its lazily-allocated tool-timeout
     # executor is released once the single run completes, instead of leaking
-    # daemon threads per call in long-lived async server workers.
+    # daemon threads per call in long-lived async server workers. Adapter wiring
+    # was pre-warmed above, so __init__ hits the fast path without blocking loop.
     with AgentsGenerator(
         agent_file=agent_file,
         framework=adapter.name,

{praisonai-4.7.11 → praisonai-4.7.13}/praisonai/acp/session.py

@@ -6,6 +6,9 @@ Handles session creation, persistence, and resume functionality.
 
 import json
 import logging
+import os
+import re
+import tempfile
 import time
 import uuid
 from dataclasses import dataclass, field
@@ -14,6 +17,23 @@ from typing import Any, Dict, List, Optional
 
 logger = logging.getLogger(__name__)
 
+# Matches the ids minted by ``ACPSession.create`` (``sess_`` + 16 hex chars).
+# Allowing up to 32 hex chars keeps forward-compat if the id width grows.
+_SESSION_ID_RE = re.compile(r"^sess_[0-9a-f]{1,32}$")
+
+
+def _validate_session_id(session_id: str) -> str:
+    """Reject anything that is not a server-minted session id.
+
+    ``session_id`` arrives over JSON-RPC from an external peer and is
+    interpolated into a filesystem path, so an unvalidated value like
+    ``"../../tmp/secret"`` would let the peer read or delete arbitrary
+    ``*.json`` files. Only ids matching the ``create()`` format are allowed.
+    """
+    if not isinstance(session_id, str) or not _SESSION_ID_RE.match(session_id):
+        raise ValueError(f"invalid session_id: {session_id!r}")
+    return session_id
+
 
 @dataclass
 class ACPSession:
@@ -124,23 +144,46 @@ class SessionStore:
         self._last_session_file = self.storage_dir / ".last_session"
     
     def _session_path(self, session_id: str) -> Path:
-        """Get path for session file."""
-        return self.storage_dir / f"{session_id}.json"
-    
+        """Get path for session file (validated against traversal)."""
+        _validate_session_id(session_id)
+        # ``resolve`` anchors the path so a future id-format change can't
+        # silently re-open the traversal hole.
+        return (self.storage_dir / f"{session_id}.json").resolve()
+
+    @staticmethod
+    def _atomic_write(path: Path, text: str) -> None:
+        """Write ``text`` to ``path`` atomically via a temp file + os.replace.
+
+        A crash or Ctrl-C mid-write can never leave the target empty or
+        half-written — the old content survives until the rename succeeds.
+        """
+        path.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp = tempfile.mkstemp(prefix=".sess-", suffix=".tmp", dir=str(path.parent))
+        try:
+            with os.fdopen(fd, "w") as f:
+                f.write(text)
+                f.flush()
+                os.fsync(f.fileno())
+            os.replace(tmp, path)
+        except BaseException:
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
+            raise
+
     def save(self, session: ACPSession) -> None:
-        """Save session to disk."""
+        """Save session to disk atomically."""
         try:
             path = self._session_path(session.session_id)
-            with open(path, "w") as f:
-                json.dump(session.to_dict(), f, indent=2)
-            
-            # Update last session pointer
-            with open(self._last_session_file, "w") as f:
-                f.write(session.session_id)
-            
+            self._atomic_write(path, json.dumps(session.to_dict(), indent=2))
+
+            # Update last session pointer ONLY after the payload is durable.
+            self._atomic_write(self._last_session_file, session.session_id)
+
             logger.debug(f"Saved session {session.session_id}")
         except Exception as e:
-            logger.error(f"Failed to save session: {e}")
+            logger.error(f"Failed to save session {session.session_id}: {e}")
     
     def load(self, session_id: str) -> Optional[ACPSession]:
         """Load session from disk."""

{praisonai-4.7.11 → praisonai-4.7.13}/praisonai/agents_generator.py

@@ -373,7 +373,7 @@ def _make_timeout_proxy(inner, wrapped_run=None, wrapped__run=None):
     return proxy
 
 
-def _wrap_with_timeout(tool, timeout_seconds: float, executor_factory, on_leaked=None, owner_key=None):
+def _wrap_with_timeout(tool, timeout_seconds: float, executor_factory, on_leaked=None, owner_key=None, native_delegates_to_core=False):
     """Enforce a per-call timeout on a tool, sync or async.
 
     For async tools the underlying task is cancelled on timeout. For sync tools
@@ -387,10 +387,33 @@ def _wrap_with_timeout(tool, timeout_seconds: float, executor_factory, on_leaked
     On timeout the wrapper raises :class:`ToolTimeoutError` rather than returning
     a JSON string, so a tool's declared return-type contract is never silently
     downgraded; the framework adapter decides how to surface the timeout.
+
+    ``native_delegates_to_core``: when True, a *plain native callable* (not a
+    framework tool object) is returned unwrapped so core's own per-tool timeout
+    enforcement (``praisonaiagents`` ``agent/tool_execution.py`` /
+    ``tools/call_executor.py``, configured via the agent's ``tool_config``
+    timeout) owns it — avoiding a second, duplicated abandon-on-timeout thread
+    pool for tools that already flow through core (#5650). Framework tool
+    objects (CrewAI/AutoGen/LangChain ``BaseTool``) never reach core's executor,
+    so they are *always* wrapped here to preserve their ``args_schema``.
     """
     if timeout_seconds is None or timeout_seconds <= 0:
         return tool
 
+    # praisonai-native path: a plain callable already flows through core's tool
+    # executor, which enforces the resolved per-tool timeout. Returning it
+    # unwrapped lets core own the abandon-on-expiry semantics instead of the
+    # wrapper standing up a second thread pool with the same behaviour. Only
+    # framework tool objects (which bypass core) still need wrapper wrapping, so
+    # they fall through to the logic below.
+    if (
+        native_delegates_to_core
+        and callable(tool)
+        and not isinstance(tool, type)
+        and not _looks_like_framework_tool(tool)
+    ):
+        return tool
+
     import asyncio
     import concurrent.futures
     import functools
@@ -599,6 +622,15 @@ class AgentsGenerator:
             task_callback (callable, optional): A callback function to be executed after each tool run.
             tools (dict): A dictionary containing the tools to be used for the agents.
         """
+        # Wire the built-in readers/retrievers/rerankers into the core-SDK
+        # registries so YAML `retriever:` / `reader:` / `reranker:` declarations
+        # resolve identically on every launch path (CLI, serve, eval, Python).
+        # Single-sourced here so surfaces that construct AgentsGenerator directly
+        # (praisonai <file.yaml>, serve, eval) get the same wiring as run()/arun().
+        # Idempotent + thread-safe + register-only-if-absent; safe to call again.
+        from .adapters import register_default_adapters
+        register_default_adapters()
+
         self.agent_file = agent_file
         self.framework = framework
         self.config_list = config_list
@@ -766,14 +798,31 @@ class AgentsGenerator:
         with self._tool_timeout_executor_lock:
             self._leaked_workers += 1
 
-    def _wrap_tool_with_timeout(self, tool, timeout_seconds):
-        """Wrap a tool with this generator's instance-owned timeout executor."""
+    def _wrap_tool_with_timeout(self, tool, timeout_seconds, native_delegates_to_core=None):
+        """Wrap a tool with this generator's instance-owned timeout executor.
+
+        On the praisonai-native framework the resolved per-tool timeout is
+        enforced by core (``praisonaiagents`` ``agent/tool_execution.py``, wired
+        via the agent's ``tool_config`` timeout), so a *native* callable is left
+        unwrapped here instead of being bound to a second wrapper-owned thread
+        pool with the same abandon-on-expiry semantics (#5650). Framework tool
+        objects (CrewAI/AutoGen/LangChain ``BaseTool``) bypass core, so they are
+        still wrapped.
+
+        ``native_delegates_to_core``: callers that already know the resolved
+        framework (the per-run wrap/resolver closures) pass it explicitly;
+        otherwise it is inferred from ``self.framework`` (resolved to the chosen
+        adapter name by the time an adapter invokes a wrap closure at run time).
+        """
+        if native_delegates_to_core is None:
+            native_delegates_to_core = (getattr(self, "framework", None) or "") == "praisonai"
         return _wrap_with_timeout(
             tool,
             timeout_seconds,
             self._get_tool_timeout_executor,
             on_leaked=self._note_leaked_worker,
             owner_key=self._timeout_owner_key,
+            native_delegates_to_core=native_delegates_to_core,
         )
 
     def close(self):
@@ -964,9 +1013,23 @@ class AgentsGenerator:
         # Canonical format conversion: 'agents' -> 'roles', 'instructions' -> 'backstory'
         # Treat an empty ``roles: {}`` the same as a missing one so populated
         # ``agents:`` is still promoted instead of running with zero agents.
-        if 'agents' in config and not config.get('roles'):
-            config['roles'] = {}
+        #
+        # Promotion is *authoritative*: the shorthand ``agents:`` bucket is
+        # removed after merging into ``roles:`` so downstream validators and the
+        # executor read a single source of truth. Leaving ``agents:`` in place
+        # let validators see a merged ``{**roles, **agents}`` view the executor
+        # (which reads only ``roles:``) never runs — causing double-fired
+        # warnings, false-positive validation rejections, and silently dropped
+        # ``tool_timeout``/handoff knobs for agents that never became roles.
+        if 'agents' in config and isinstance(config['agents'], dict):
+            config.setdefault('roles', {})
+            if not isinstance(config['roles'], dict):
+                config['roles'] = {}
             for agent_name, agent_config in config['agents'].items():
+                # An entry already present under ``roles:`` is canonical and
+                # wins; only agents-only entries are promoted.
+                if agent_name in config['roles']:
+                    continue
                 role_config = dict(agent_config) if agent_config else {}
                 # Convert 'instructions' to 'backstory' if present
                 if 'instructions' in role_config and 'backstory' not in role_config:
@@ -979,6 +1042,8 @@ class AgentsGenerator:
                 if 'backstory' not in role_config:
                     role_config['backstory'] = f'You are a {role_config["role"]}'
                 config['roles'][agent_name] = role_config
+            # Drop the shorthand bucket so validators and the executor agree.
+            del config['agents']
 
         # Get workflow input: 'input' is canonical, 'topic' is alias for backward compatibility
         topic = config.get('input', config.get('topic', ''))
@@ -1055,11 +1120,35 @@ class AgentsGenerator:
         # that when the *same* generator instance is reused with a different
         # timeout layout, a stale closure from a previous run can never leak into
         # the adapters and apply the wrong budget to the current run.
+        # Resolve the chosen framework now (the same registry resolution the
+        # run prep uses) so native-vs-framework tool handling is decided BEFORE
+        # the uniform wrap is applied eagerly below — ``self.framework`` is not
+        # yet updated to the resolved adapter name at this point in the run.
+        _requested_framework = getattr(self, "framework", None) or config.get('framework')
+        registry = getattr(self, "_adapter_registry", None)
+        try:
+            resolved_framework = (
+                registry.resolve_or_default(_requested_framework)
+                if registry is not None else _requested_framework
+            )
+        except Exception:
+            resolved_framework = _requested_framework
+        native = resolved_framework == "praisonai"
+
         uniform = self._resolve_uniform_tool_timeout(config)
         wrap = None
         resolver = None
         if uniform and uniform > 0:
-            wrap = lambda t, _sec=uniform: self._wrap_tool_with_timeout(t, _sec)
+            # On the native framework a *plain callable* is left unwrapped so
+            # core enforces the budget (#5650) — the raw value is exposed below
+            # so the native adapter configures each agent's tool_config timeout.
+            # Framework tool *objects* are still wrapped here regardless, so
+            # their args_schema survives for the LLM. ``native`` is passed
+            # explicitly because ``self.framework`` is not yet resolved here.
+            wrap = (
+                lambda t, _sec=uniform, _n=native:
+                self._wrap_tool_with_timeout(t, _sec, native_delegates_to_core=_n)
+            )
             tools_dict = {name: wrap(tool) for name, tool in tools_dict.items()}
         else:
             # No single uniform timeout. If any agent declared a per-agent
@@ -1080,9 +1169,21 @@ class AgentsGenerator:
         # so adapters still read them via the same keys. Both are written every
         # time so the inactive path is cleared rather than left holding a prior
         # closure.
+        # On the native framework, plain callables are no longer wrapped by the
+        # wrapper's own executor (above) — core enforces the timeout instead
+        # (#5650). Expose the resolved per-agent timeout (float seconds) so the
+        # native adapter can configure each core Agent's ``tool_config`` timeout.
+        # ``None`` for non-native frameworks, which keep wrapper-side wrapping.
+        native_tool_timeout_resolver = None
+        if native:
+            native_tool_timeout_resolver = (
+                lambda agent_key, _cfg=config: self.resolve_agent_tool_timeout(agent_key, _cfg)
+            )
+
         self._run_ctx = {
             "_tool_timeout_wrap": wrap,
             "_agent_tool_wrap_resolver": resolver,
+            "_native_tool_timeout_resolver": native_tool_timeout_resolver,
         }
         return tools_dict
 

{praisonai-4.7.11 → praisonai-4.7.13}/praisonai/api/agent_invoke.py

@@ -697,7 +697,11 @@ if FASTAPI_AVAILABLE and APIRouter is not None:
         if hasattr(agent, 'name'):
             info["name"] = agent.name
         if hasattr(agent, 'instructions'):
-            info["instructions"] = agent.instructions[:200] + "..." if len(agent.instructions) > 200 else agent.instructions
+            instructions = agent.instructions
+            if isinstance(instructions, str) and len(instructions) > 200:
+                info["instructions"] = instructions[:200] + "..."
+            else:
+                info["instructions"] = instructions
         if hasattr(agent, 'tools') and agent.tools:
             info["tools"] = [getattr(tool, 'name', str(tool)) for tool in agent.tools[:5]]  # First 5 tools
             if len(agent.tools) > 5: