PraisonAI 4.7.0__tar.gz → 4.7.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.0
+Version: 4.7.4
 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.2
+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.4}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.0
+Version: 4.7.4
 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.2
+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.4}/PraisonAI.egg-info/SOURCES.txt

@@ -436,10 +436,6 @@ praisonai/persistence/state/mongodb.py
 praisonai/persistence/state/redis.py
 praisonai/persistence/state/upstash.py
 praisonai/persistence/state/valkey.py
-praisonai/persistence/tests/__init__.py
-praisonai/persistence/tests/test_all_backends.py
-praisonai/persistence/tests/test_registry_lazy.py
-praisonai/persistence/tests/test_valkey_backends.py
 praisonai/push/__init__.py
 praisonai/push/client.py
 praisonai/push/transports.py
@@ -501,7 +497,6 @@ praisonai/standardise/dedupe.py
 praisonai/standardise/discovery.py
 praisonai/standardise/drift.py
 praisonai/standardise/engine.py
-praisonai/standardise/enhanced_templates.py
 praisonai/standardise/example_verifier.py
 praisonai/standardise/manifest.py
 praisonai/standardise/models.py

{praisonai-4.7.0 → praisonai-4.7.4}/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.2
+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.4}/praisonai/__main__.py

@@ -23,6 +23,44 @@ import threading
 _typer_commands_cache = None
 _typer_commands_lock = threading.Lock()
 
+# Cache for the legacy dispatcher's implemented-verb set. ``None`` means "not yet
+# computed"; a frozenset once derived. Populated lazily from the legacy
+# argparse builder's authoritative ``LEGACY_SPECIAL_COMMANDS`` oracle so the
+# unified dispatcher never reclassifies an *implemented* verb as free text and
+# bills it to an LLM (#4327).
+_legacy_verbs_cache = None
+_legacy_verbs_lock = threading.Lock()
+
+# Fail-closed fallback for :func:`_get_legacy_verbs`. If importing the
+# authoritative ``LEGACY_SPECIAL_COMMANDS`` oracle ever fails, we must NOT return
+# an empty set — that would let an *implemented* verb (``thinking status`` etc.)
+# fall through to the bare-prompt rule and be billed to an LLM, reintroducing the
+# #4327 regression. This static mirror keeps the routing guard functional so such
+# verbs still reach the legacy handler even when discovery is degraded. It only
+# needs to stay a *superset-safe* copy of the oracle; drift merely means a newly
+# added verb isn't recognised until the oracle import recovers, never a bill.
+_LEGACY_VERBS_FALLBACK = frozenset({
+    'chat', 'code', 'call', 'realtime', 'train', 'ui', 'context', 'research',
+    'memory', 'rules', 'workflow', 'hooks', 'knowledge', 'session', 'tools',
+    'todo', 'docs', 'mcp', 'commit', 'serve', 'schedule', 'skills', 'profile',
+    'eval', 'agents', 'run', 'thinking', 'compaction', 'output', 'deploy',
+    'templates', 'recipe', 'endpoints', 'audio', 'embed', 'embedding', 'images',
+    'moderate', 'files', 'batches', 'vector-stores', 'rerank', 'ocr',
+    'assistants', 'fine-tuning', 'completions', 'messages', 'guardrails', 'rag',
+    'videos', 'a2a', 'containers', 'passthrough', 'responses', 'search',
+    'realtime-api', 'doctor', 'registry', 'package', 'install', 'uninstall',
+    'acp', 'debug', 'lsp', 'diag', 'browser', 'replay', 'bot', 'gateway',
+    'sandbox', 'wizard', 'migrate', 'security', 'persistence', 'paths', 'claw',
+    'github', 'managed', 'flow', 'dashboard', 'backends', 'audit',
+})
+
+# Verbs excluded from the "route implemented verbs to legacy" guard. ``containers``
+# and ``vector-stores`` reach a capability that fabricates a success with zero
+# network (#4322); restoring their routing would promote that fabrication from
+# unreachable to user-visible, so they are held back until #4322 lands. They keep
+# their current behaviour rather than being rerouted here.
+_LEGACY_VERB_ROUTING_EXCLUSIONS = frozenset({"containers", "vector-stores"})
+
 # Cache for the run command's supported option names. ``None`` means "not yet
 # computed"; a tuple ``(all_opts, value_opts)`` once derived; ``False`` marks a
 # discovery failure so the conservative legacy fallback is used without retrying
@@ -263,6 +301,64 @@ def _get_typer_commands():
         return _typer_commands_cache
 
 
+def _get_legacy_verbs():
+    """Auto-discover the legacy dispatcher's implemented-verb set.
+
+    Sourced from the legacy argparse builder's authoritative
+    ``LEGACY_SPECIAL_COMMANDS`` oracle so this stays in lockstep with the verbs
+    legacy actually handles.
+
+    Fails *closed*: if the oracle import raises, return the static
+    :data:`_LEGACY_VERBS_FALLBACK` mirror rather than an empty set. An empty set
+    would let an implemented verb fall through to the bare-prompt rule and be
+    billed to an LLM — the #4327 regression this guard exists to prevent. The
+    fallback is *not* cached so a later caller can still pick up the authoritative
+    oracle once the transient import failure clears.
+    """
+    global _legacy_verbs_cache
+
+    if _legacy_verbs_cache is not None:
+        return _legacy_verbs_cache
+
+    with _legacy_verbs_lock:
+        if _legacy_verbs_cache is not None:  # Double-check
+            return _legacy_verbs_cache
+
+        try:
+            from praisonai.cli.legacy.dispatch.argparse_builder import (
+                LEGACY_SPECIAL_COMMANDS,
+            )
+            verbs = frozenset(LEGACY_SPECIAL_COMMANDS)
+        except Exception:
+            import logging
+            logging.getLogger("praisonai.__main__").warning(
+                "Legacy verb discovery failed; using static fallback registry so "
+                "implemented verbs still route to their handler (not the LLM).",
+                exc_info=True,
+            )
+            # Fail closed: recognise implemented verbs from the static mirror.
+            # Do NOT poison the cache — a later caller can still load the oracle.
+            return _LEGACY_VERBS_FALLBACK
+
+        _legacy_verbs_cache = verbs
+        return _legacy_verbs_cache
+
+
+def _is_implemented_legacy_verb(first_cmd):
+    """True when ``first_cmd`` is a verb the legacy dispatcher implements.
+
+    Such a token is an *implemented command*, not free text — it must reach its
+    handler on the legacy path, never be joined/quoted and billed to an LLM by
+    the modern ``run`` forwarder (#4327). A small exclusion set
+    (:data:`_LEGACY_VERB_ROUTING_EXCLUSIONS`) is withheld pending #4322.
+    """
+    if not first_cmd:
+        return False
+    if first_cmd in _LEGACY_VERB_ROUTING_EXCLUSIONS:
+        return False
+    return first_cmd in _get_legacy_verbs()
+
+
 def _iter_argv_tokens(argv, value_opts=None):
     """Classify each ``argv`` token, yielding ``(arg, name, kind)``.
 
@@ -610,6 +706,15 @@ def main():
         _run_typer(argv)
         return
 
+    # A verb the legacy dispatcher implements is a *command*, not free text.
+    # Without this guard it falls through to the bare-prompt rule below and is
+    # joined/quoted into a modern ``run`` prompt and billed to an LLM (#4327):
+    # ``praisonai thinking status`` costs ~2.5k tokens and exits 0 instead of
+    # reaching its handler. Route it to legacy, which owns the handler.
+    if _is_implemented_legacy_verb(first_cmd):
+        _run_legacy(argv)
+        return
+
     # A lone token that is a near-miss for a registered command is a mistyped
     # verb, not a prompt. Without this guard it falls through to the bare-prompt
     # rule below and is billed to an LLM: ``praisonai deploi`` costs money and

{praisonai-4.7.0 → praisonai-4.7.4}/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.4}/praisonai/_dev/parity/generator.py

@@ -453,6 +453,16 @@ class ParityTrackerGenerator:
         lines.append(f"> **Version:** {tracker['version']} | **Last Updated:** {tracker['lastUpdated']}")
         lines.append(f"> **Source of Truth:** {tracker['sourceOfTruth']}")
         lines.append("")
+        lines.append("> [!IMPORTANT]")
+        lines.append("> **What this measures:** whether a matching *exported symbol name* exists in")
+        lines.append("> the TypeScript SDK's public surface (parsed from `src/index.ts`). It does **not**")
+        lines.append("> verify that the capability is reachable, wired up, or behaves like its Python")
+        lines.append("> counterpart. A `✅ exported` cell means the name is exported — not that it works.")
+        lines.append("> Counts include barrel re-exports, so `TypeScript Features` reflects module")
+        lines.append("> structure, not distinct capabilities, and is not directly comparable to the")
+        lines.append("> Python count. For a capability with a testable contract, rely on its conformance")
+        lines.append("> suite rather than this table.")
+        lines.append("")
         
         # Summary
         summary = tracker['summary']
@@ -482,7 +492,7 @@ class ParityTrackerGenerator:
             done_count = sum(1 for g in gaps if g['status'] == 'DONE')
             todo_count = len(gaps) - done_count
             
-            lines.append(f"### {priority_key} ({done_count} done, {todo_count} todo)")
+            lines.append(f"### {priority_key} ({done_count} exported, {todo_count} missing)")
             lines.append("")
             lines.append("| Feature | Python | TypeScript | Effort | Status |")
             lines.append("|---------|--------|------------|--------|--------|")
@@ -490,7 +500,7 @@ class ParityTrackerGenerator:
             for gap in sorted(gaps, key=lambda x: (x['status'] != 'TODO', x['feature'])):
                 py = "✅" if gap['python'] else "❌"
                 ts = "✅" if gap['typescript'] else "❌"
-                status = "✅ DONE" if gap['status'] == 'DONE' else "⏳ TODO"
+                status = "✅ exported" if gap['status'] == 'DONE' else "⏳ missing"
                 feature = _escape_md(gap['feature'])
                 lines.append(f"| `{feature}` | {py} | {ts} | {gap['effort']} | {status} |")
             
@@ -617,6 +627,14 @@ class ParityTrackerGenerator:
         lines.append("")
         lines.append(f"> **Python Features:** {python_count} | **Rust Features:** {rust_count} | **Parity:** {parity_pct}%")
         lines.append("")
+        lines.append("> [!IMPORTANT]")
+        lines.append("> **What this measures:** whether a matching *exported symbol name* exists in the")
+        lines.append("> Rust crate's public surface. It does **not** verify that the capability is")
+        lines.append("> reachable or behaves like its Python counterpart — an exported item whose body")
+        lines.append("> returns `Err(\"not yet implemented\")` still counts here. Treat `✅` as \"a symbol")
+        lines.append("> of this name is exported\", not \"this works\". For a capability with a testable")
+        lines.append("> contract, rely on its conformance suite rather than this table.")
+        lines.append("")
         lines.append("## Summary")
         lines.append("")
         lines.append("| Metric | Count |")

{praisonai-4.7.0 → praisonai-4.7.4}/praisonai/_dev/parity/typescript_extractor.py

@@ -55,8 +55,14 @@ class TypeScriptFeatureExtractor:
     - export { Name } from './path' statements
     - export type { Name } from './path' statements
     - export * from './path' statements
-    
+
     It categorizes exports into modules based on their source paths.
+
+    IMPORTANT — this measures symbol *names*, not behaviour. Presence of an
+    exported name here does NOT mean the capability is reachable, wired up, or
+    behaviourally equivalent to its Python counterpart. A name that is exported
+    but never called (e.g. an approval manager that no code path invokes) still
+    shows up. Downstream reports must label these as "exported", not "done".
     """
     
     # Module category mapping based on source paths

{praisonai-4.7.0 → praisonai-4.7.4}/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.4}/praisonai/agents_generator.py

@@ -897,12 +897,40 @@ class AgentsGenerator:
         # Enforce tool_timeout from CLI/YAML at the wrapper layer so the field is
         # not silently dropped. The timeout stack (_wrap_tool_with_timeout) is
         # framework-agnostic and works for both the native and external adapters.
-        effective = self._resolve_effective_tool_timeout(config)
-        if effective and effective > 0:
-            tools_dict = {
-                name: self._wrap_tool_with_timeout(tool, effective)
-                for name, tool in tools_dict.items()
-            }
+        # Determine whether a single uniform timeout applies to every agent, or
+        # whether agents declared *heterogeneous* per-agent budgets. A uniform
+        # value can still be wrapped once onto the shared dict (cheapest path);
+        # heterogeneous values must be wrapped per-agent so a documented
+        # per-agent ``tool_timeout`` is honoured instead of being silently
+        # downgraded to the tightest value for the whole run.
+        # The uniform and per-agent paths are mutually exclusive. Always resolve
+        # BOTH internal keys on every call (setting the inactive one to None) so
+        # 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.
+        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)
+            tools_dict = {name: wrap(tool) for name, tool in tools_dict.items()}
+        else:
+            # No single uniform timeout. If any agent declared a per-agent
+            # tool_timeout, expose a resolver so adapters wrap each agent's tools
+            # with that agent's own budget (tools stay shared; only the guard
+            # closure differs). Falls back to no wrap for agents without one.
+            resolver = self.make_agent_tool_wrap_resolver(config)
+
+        # Expose the per-run wrap so adapters that inject *more* tools after this
+        # point (e.g. PraisonAIAdapter's ACP/LSP centric tools) apply the same
+        # timeout guard instead of silently bypassing it; expose the per-agent
+        # resolver for heterogeneous budgets. Both keys are written every time so
+        # the inactive path is cleared rather than left holding a prior closure.
+        self.cli_config = {
+            **(self.cli_config or {}),
+            "_tool_timeout_wrap": wrap,
+            "_agent_tool_wrap_resolver": resolver,
+        }
         return tools_dict
 
     def _resolve_effective_tool_timeout(self, config):
@@ -943,6 +971,84 @@ class AgentsGenerator:
                 )
         return tightest
 
+    @staticmethod
+    def _declared_agent_timeout(entity):
+        """Return a positive numeric ``tool_timeout`` declared on an entity, else None."""
+        v = entity.get("tool_timeout") if isinstance(entity, dict) else None
+        if isinstance(v, (int, float)) and not isinstance(v, bool):
+            return float(v)
+        return None
+
+    def _resolve_uniform_tool_timeout(self, config):
+        """Return a single timeout to wrap every tool with, or ``None``.
+
+        A uniform value exists when the CLI sets ``tool_timeout`` (applies to all
+        agents), or when *every* agent/role declares ``tool_timeout`` and they
+        all declare the *same* value. If any agent omits ``tool_timeout``, or
+        declared values differ, returns ``None`` so the shared dict stays
+        unwrapped and the per-agent resolver becomes the sole guard — this
+        avoids both the old "tightest wins for everyone" downgrade and forcing a
+        lone declared budget onto agents that never asked for one (greptile P1).
+        """
+        cli_timeout = (self.cli_config or {}).get("tool_timeout")
+        if isinstance(cli_timeout, (int, float)) and not isinstance(cli_timeout, bool):
+            return float(cli_timeout)
+
+        entities = {**(config.get("roles") or {}), **(config.get("agents") or {})}
+        if not entities:
+            return None
+
+        values = set()
+        for entity in entities.values():
+            t = self._declared_agent_timeout(entity)
+            if t is None:
+                # An agent without a declared budget must not inherit another
+                # agent's timeout via the shared-dict wrap. Defer entirely to the
+                # per-agent resolver.
+                return None
+            values.add(t)
+        if len(values) == 1:
+            return next(iter(values))
+        return None
+
+    def resolve_agent_tool_timeout(self, agent_key, config):
+        """Per-agent effective timeout: agent value > CLI value > ``None``.
+
+        Never downgrades across agents — each agent gets its own declared budget
+        (or the CLI default, or nothing).
+        """
+        entities = {**(config.get("roles") or {}), **(config.get("agents") or {})}
+        val = self._declared_agent_timeout(entities.get(agent_key) or {})
+        if val is not None:
+            return val
+        cli_timeout = (self.cli_config or {}).get("tool_timeout")
+        if isinstance(cli_timeout, (int, float)) and not isinstance(cli_timeout, bool):
+            return float(cli_timeout)
+        return None
+
+    def make_agent_tool_wrap_resolver(self, config):
+        """Return ``resolver(agent_key) -> wrap|None`` for heterogeneous budgets.
+
+        Returns ``None`` when no agent declares a per-agent ``tool_timeout`` (so
+        adapters skip per-agent wrapping entirely). The returned ``wrap`` closes
+        over that agent's timeout; tool objects stay shared, only the guard
+        closure differs per agent.
+        """
+        entities = {**(config.get("roles") or {}), **(config.get("agents") or {})}
+        declared_any = any(
+            self._declared_agent_timeout(e) is not None for e in entities.values()
+        )
+        if not declared_any:
+            return None
+
+        def resolver(agent_key):
+            t = self.resolve_agent_tool_timeout(agent_key, config)
+            if not t or t <= 0:
+                return None
+            return lambda tool, _sec=t: self._wrap_tool_with_timeout(tool, _sec)
+
+        return resolver
+
     # Mirror the legacy CLI's --tool-timeout argparse default so the workflow
     # validation can tell an implicit default apart from a user request.
     _CLI_TOOL_TIMEOUT_DEFAULT = 60
@@ -1527,21 +1633,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.4}/praisonai/api/agent_invoke.py

@@ -311,9 +311,17 @@ def resolve_session_agent(agent_id: str, session_id: Optional[str]) -> Any:
     return agent
 
 
+# Fields whose swap requires side-effects the core SDK owns and the wrapper
+# must not open-code: a bare ``setattr(agent, 'llm', value)`` leaves the cached
+# ``_llm_instance`` / ``_unified_dispatcher`` / ``_llm_init_params`` bound to the
+# previous model, so the request keeps running on the OLD LLM while ``agent.llm``
+# (and the response metadata) reports the new one. Route through the SDK's own
+# invalidator instead (praisonaiagents.Agent._apply_default_llm).
+_SIDE_EFFECT_OVERRIDES = frozenset({"llm"})
+
 _APPLYABLE_OVERRIDES = frozenset({
     "instructions", "goal", "role", "backstory",
-    "llm", "max_iter",
+    "max_iter",
     "verbose", "markdown",
 })
 
@@ -322,6 +330,46 @@ class AgentConfigError(ValueError):
     """Raised when an agent_config override is unsupported or cannot be applied."""
 
 
+def _swap_llm(agent: Any, model: Any) -> None:
+    """Swap the agent's model, invalidating the SDK's cached LLM state.
+
+    Prefers the SDK's own ``_apply_default_llm`` (which drops ``_llm_instance``,
+    ``_unified_dispatcher`` and re-seeds ``_llm_init_params`` atomically). That
+    method self-guards when the agent explicitly chose a model *or* was built
+    with a panel descriptor, so both guards are temporarily cleared — an API
+    override IS an explicit choice that supersedes a panel selection. Without
+    clearing ``_panel_descriptor`` the SDK returns early and the request would
+    silently continue on the panel model. Falls back to mirroring the SDK's
+    invalidation contract when the method is absent.
+    """
+    apply = getattr(agent, "_apply_default_llm", None)
+    if callable(apply):
+        had_explicit = getattr(agent, "_llm_explicit", None)
+        had_panel = getattr(agent, "_panel_descriptor", None)
+        agent._llm_explicit = False
+        if had_panel is not None:
+            agent._panel_descriptor = None
+        try:
+            apply(model)
+        finally:
+            if had_explicit is not None:
+                agent._llm_explicit = had_explicit
+            # ``_panel_descriptor`` is intentionally NOT restored: the override
+            # replaces the panel selection for the lifetime of this isolated
+            # clone. Restoring it would let ``_ensure_llm_instance`` rebuild the
+            # panel LLM and drift back to the old model.
+        return
+    # Fallback: mirror the SDK invalidation contract manually.
+    agent.llm = model
+    if getattr(agent, "_panel_descriptor", None) is not None:
+        agent._panel_descriptor = None
+    for attr in ("_llm_instance", "_unified_dispatcher"):
+        if hasattr(agent, attr):
+            setattr(agent, attr, None)
+    if getattr(agent, "_llm_init_params", None):
+        agent._llm_init_params = {**agent._llm_init_params, "model": model}
+
+
 def _apply_agent_config(agent: Any, agent_config: Optional[Dict[str, Any]]) -> None:
     """Apply per-request overrides to an isolated agent clone.
 
@@ -333,6 +381,10 @@ def _apply_agent_config(agent: Any, agent_config: Optional[Dict[str, Any]]) -> N
     the shared-instance fallback): writing overrides onto a registry-shared
     object would leak this request's config into subsequent/concurrent requests.
     In that case the override is rejected rather than silently applied globally.
+
+    ``llm`` is a side-effecting swap routed through :func:`_swap_llm` so the
+    cached LLM is invalidated — a plain ``setattr`` would leave the request
+    running on the previously cached model.
     """
     if not agent_config:
         return
@@ -342,13 +394,18 @@ def _apply_agent_config(agent: Any, agent_config: Optional[Dict[str, Any]]) -> N
             "agent is shared across requests and cannot be safely overridden "
             "per request."
         )
-    unknown = set(agent_config) - _APPLYABLE_OVERRIDES
+    allowed = _APPLYABLE_OVERRIDES | _SIDE_EFFECT_OVERRIDES
+    unknown = set(agent_config) - allowed
     if unknown:
         raise AgentConfigError(
             f"Unsupported agent_config override(s): {sorted(unknown)}. "
-            f"Allowed: {sorted(_APPLYABLE_OVERRIDES)}"
+            f"Allowed: {sorted(allowed)}"
         )
+    if "llm" in agent_config:
+        _swap_llm(agent, agent_config["llm"])
     for key, value in agent_config.items():
+        if key in _SIDE_EFFECT_OVERRIDES:
+            continue
         if not hasattr(agent, key):
             raise AgentConfigError(
                 f"Agent has no attribute {key!r}; cannot override."