PraisonAI 4.6.150__tar.gz → 4.6.152__tar.gz

{praisonai-4.6.150 → praisonai-4.6.152}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.150
+Version: 4.6.152
 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,12 +11,13 @@ 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.6.153
-Requires-Dist: praisonai-code>=0.0.49
-Requires-Dist: praisonai-bot>=0.0.34
-Requires-Dist: praisonai-train>=0.0.5
-Requires-Dist: praisonai-browser>=0.0.2
-Requires-Dist: praisonai-mcp>=0.0.2
+Requires-Dist: praisonaiagents>=1.6.155
+Requires-Dist: praisonai-code>=0.0.51
+Requires-Dist: praisonai-bot>=0.0.36
+Requires-Dist: praisonai-train>=0.0.7
+Requires-Dist: praisonai-browser>=0.0.4
+Requires-Dist: praisonai-mcp>=0.0.4
+Requires-Dist: praisonai-sandbox>=0.0.2
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0
@@ -60,11 +61,11 @@ Requires-Dist: tavily-python==0.5.0; extra == "code"
 Requires-Dist: crawl4ai>=0.7.0; extra == "code"
 Requires-Dist: playwright>=1.47.0; extra == "code"
 Provides-Extra: sandbox
-Requires-Dist: sandlock>=0.1.0; extra == "sandbox"
+Requires-Dist: praisonai-sandbox[all]; extra == "sandbox"
 Provides-Extra: ssh
-Requires-Dist: asyncssh>=2.14.0; extra == "ssh"
+Requires-Dist: praisonai-sandbox[ssh]; extra == "ssh"
 Provides-Extra: modal
-Requires-Dist: modal>=0.64.0; extra == "modal"
+Requires-Dist: praisonai-sandbox[modal]; extra == "modal"
 Provides-Extra: daytona
 Provides-Extra: realtime
 Requires-Dist: aiui<0.4,>=0.3.121; extra == "realtime"

{praisonai-4.6.150 → praisonai-4.6.152}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.150
+Version: 4.6.152
 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,12 +11,13 @@ 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.6.153
-Requires-Dist: praisonai-code>=0.0.49
-Requires-Dist: praisonai-bot>=0.0.34
-Requires-Dist: praisonai-train>=0.0.5
-Requires-Dist: praisonai-browser>=0.0.2
-Requires-Dist: praisonai-mcp>=0.0.2
+Requires-Dist: praisonaiagents>=1.6.155
+Requires-Dist: praisonai-code>=0.0.51
+Requires-Dist: praisonai-bot>=0.0.36
+Requires-Dist: praisonai-train>=0.0.7
+Requires-Dist: praisonai-browser>=0.0.4
+Requires-Dist: praisonai-mcp>=0.0.4
+Requires-Dist: praisonai-sandbox>=0.0.2
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0
@@ -60,11 +61,11 @@ Requires-Dist: tavily-python==0.5.0; extra == "code"
 Requires-Dist: crawl4ai>=0.7.0; extra == "code"
 Requires-Dist: playwright>=1.47.0; extra == "code"
 Provides-Extra: sandbox
-Requires-Dist: sandlock>=0.1.0; extra == "sandbox"
+Requires-Dist: praisonai-sandbox[all]; extra == "sandbox"
 Provides-Extra: ssh
-Requires-Dist: asyncssh>=2.14.0; extra == "ssh"
+Requires-Dist: praisonai-sandbox[ssh]; extra == "ssh"
 Provides-Extra: modal
-Requires-Dist: modal>=0.64.0; extra == "modal"
+Requires-Dist: praisonai-sandbox[modal]; extra == "modal"
 Provides-Extra: daytona
 Provides-Extra: realtime
 Requires-Dist: aiui<0.4,>=0.3.121; extra == "realtime"

{praisonai-4.6.150 → praisonai-4.6.152}/PraisonAI.egg-info/SOURCES.txt

@@ -471,16 +471,7 @@ praisonai/replay/writer.py
 praisonai/runtime/__init__.py
 praisonai/runtime/__main__.py
 praisonai/sandbox/__init__.py
-praisonai/sandbox/_compat.py
 praisonai/sandbox/_registry.py
-praisonai/sandbox/_shell.py
-praisonai/sandbox/daytona.py
-praisonai/sandbox/docker.py
-praisonai/sandbox/e2b.py
-praisonai/sandbox/modal.py
-praisonai/sandbox/sandlock.py
-praisonai/sandbox/ssh.py
-praisonai/sandbox/subprocess.py
 praisonai/scheduler/__init__.py
 praisonai/scheduler/_base_scheduler.py
 praisonai/scheduler/_delivery.py
@@ -558,10 +549,8 @@ praisonai/tools/skill_manage.py
 praisonai/train/__init__.py
 praisonai/ui/_aiui_datastore.py
 praisonai/ui/_external_agents.py
-praisonai/ui/callbacks.py
 praisonai/ui/context.py
 praisonai/ui/database_config.py
-praisonai/ui/components/aicoder.py
 praisonai/ui_agents/__init__.py
 praisonai/ui_agents/default_app.py
 praisonai/ui_bot/__init__.py

{praisonai-4.6.150 → praisonai-4.6.152}/PraisonAI.egg-info/requires.txt

@@ -1,12 +1,13 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.153
-praisonai-code>=0.0.49
-praisonai-bot>=0.0.34
-praisonai-train>=0.0.5
-praisonai-browser>=0.0.2
-praisonai-mcp>=0.0.2
+praisonaiagents>=1.6.155
+praisonai-code>=0.0.51
+praisonai-bot>=0.0.36
+praisonai-train>=0.0.7
+praisonai-browser>=0.0.4
+praisonai-mcp>=0.0.4
+praisonai-sandbox>=0.0.2
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0
@@ -171,7 +172,7 @@ praisonai-tools>=0.1.0
 praisonai-mcp[all]
 
 [modal]
-modal>=0.64.0
+praisonai-sandbox[modal]
 
 [mongodb]
 pymongo>=4.6.0
@@ -216,10 +217,10 @@ ddgs>=9.0.0
 redis>=5.0.0
 
 [sandbox]
-sandlock>=0.1.0
+praisonai-sandbox[all]
 
 [ssh]
-asyncssh>=2.14.0
+praisonai-sandbox[ssh]
 
 [train]
 praisonai-train[llm]

{praisonai-4.6.150 → praisonai-4.6.152}/praisonai/_bootstrap.py

@@ -91,3 +91,19 @@ def ensure_praisonai_mcp() -> None:
         root = str(mcp_src)
         if root not in sys.path:
             sys.path.insert(0, root)
+
+
+def ensure_praisonai_sandbox() -> None:
+    """Ensure ``praisonai_sandbox`` can be imported in monorepo dev layouts."""
+    try:
+        import praisonai_sandbox  # noqa: F401
+        return
+    except ImportError:
+        pass
+
+    wrapper_src = Path(__file__).resolve().parents[1]  # .../src/praisonai
+    sandbox_src = wrapper_src.parent / "praisonai-sandbox"
+    if (sandbox_src / "praisonai_sandbox").is_dir():
+        root = str(sandbox_src)
+        if root not in sys.path:
+            sys.path.insert(0, root)

{praisonai-4.6.150 → praisonai-4.6.152}/praisonai/agents_generator.py

@@ -401,7 +401,7 @@ def _resolve_yaml_cli_backend(cli_backend_config, logger):
 
 
 class AgentsGenerator:
-    def __init__(self, agent_file, framework, config_list, log_level=None, agent_callback=None, task_callback=None, agent_yaml=None, tools=None, cli_config=None, adapter_registry=None, tool_timeout_executor=None):
+    def __init__(self, agent_file, framework, config_list, log_level=None, agent_callback=None, task_callback=None, agent_yaml=None, tools=None, cli_config=None, adapter_registry=None, tool_timeout_executor=None, tool_resolver=None):
         """
         Initialize the AgentsGenerator object.
 
@@ -416,6 +416,7 @@ class AgentsGenerator:
             tools (dict, optional): A dictionary containing the tools to be used for the agents. Defaults to None.
             cli_config (dict, optional): CLI configuration to override YAML settings. Defaults to None.
             adapter_registry (FrameworkAdapterRegistry, optional): Registry for framework adapters. Defaults to process default.
+            tool_resolver (ToolResolver, optional): Canonical tool resolver. Defaults to the shared context-local resolver so discovery runs once per run.
 
         Attributes:
             agent_file (str): The path to the agent file.
@@ -448,9 +449,14 @@ class AgentsGenerator:
         elif os.environ.get('LOGLEVEL'):
             self.logger.setLevel(getattr(logging, os.environ.get('LOGLEVEL', 'INFO').upper(), logging.INFO))
         
-        # Initialize tool resolver (single source of truth for tool resolution)
-        from .tool_resolver import ToolResolver
-        self.tool_resolver = ToolResolver()
+        # Initialize tool resolver (single source of truth for tool resolution).
+        # DI-friendly: callers (e.g. AutoGenerator hand-off, tests) may pass a
+        # resolver; otherwise share the context-local default so tool discovery
+        # runs once per run instead of once per generator construction.
+        if tool_resolver is None:
+            from .tool_resolver import _get_default_resolver
+            tool_resolver = _get_default_resolver()
+        self.tool_resolver = tool_resolver
         
         # DI-friendly: tests/multi-tenant runtimes pass their own registry;
         # CLI users get the process default.
@@ -699,30 +705,40 @@ class AgentsGenerator:
         framework_name = self.framework or config.get('framework', 'praisonai')
         adapter = self._select_framework(framework_name, config)
         
-        # Validate framework availability
+        # Validate framework availability through the injected registry so a
+        # scoped/per-tenant adapter registered on this generator's registry is
+        # not rejected just because it is absent from the process default.
         from .framework_adapters.validators import assert_framework_available
-        assert_framework_available(adapter.name)
+        assert_framework_available(adapter.name, registry=self._adapter_registry)
         
         # Validate cli_backend compatibility
         self._validate_cli_backend_compatibility(config, adapter.name, adapter=adapter)
-        
-        # Initialize observability hooks
-        from .observability.hooks import init_observability
-        init_observability(adapter.name)
-        
-        # Run adapter setup hooks
-        adapter.setup(framework_tag=adapter.name)
-        
+
         # Update framework reference if resolution changed it
         self.framework = adapter.name
         self.framework_adapter = adapter
-        
+
+        # NB: adapter setup is intentionally NOT run here. The caller opens the
+        # observability_session (which owns init/finalize for every adapter) and
+        # then invokes _run_adapter_setup INSIDE that session, so setup events —
+        # and any setup/import failure — are recorded and finalized instead of
+        # slipping outside observability. See generate_crew_and_kickoff /
+        # agenerate_crew_and_kickoff.
         return {
             'adapter': adapter,
             'config': config,
             'topic': topic,
             'tools_dict': tools_dict,
         }
+
+    def _run_adapter_setup(self, adapter):
+        """Run an adapter's setup hooks.
+
+        Kept as a tiny seam so both the sync and async run paths execute setup
+        *inside* the observability_session, keeping init/setup/run/finalize
+        bracketed together for every adapter.
+        """
+        adapter.setup(framework_tag=adapter.name)
     
     def _build_tools_dict(self, config):
         """Shared tool resolution logic for sync and async paths."""
@@ -991,15 +1007,22 @@ class AgentsGenerator:
         prep = self._prepare_for_run(config)
         
         self.logger.info(f"Using framework: {prep['adapter'].name}")
-        return prep['adapter'].run(
-            prep['config'],
-            self.config_list,
-            prep['topic'],
-            tools_dict=prep['tools_dict'],
-            agent_callback=getattr(self, 'agent_callback', None),
-            task_callback=getattr(self, 'task_callback', None),
-            cli_config=getattr(self, 'cli_config', None),
-        )
+        # Own the observability lifecycle here so init and finalize are always
+        # paired for every adapter (the CM finalizes on success and error alike).
+        from .observability.hooks import observability_session
+        with observability_session(prep['adapter'].name):
+            # Run setup INSIDE the session so setup events and any setup/import
+            # failure are recorded and finalized, not dropped outside observability.
+            self._run_adapter_setup(prep['adapter'])
+            return prep['adapter'].run(
+                prep['config'],
+                self.config_list,
+                prep['topic'],
+                tools_dict=prep['tools_dict'],
+                agent_callback=getattr(self, 'agent_callback', None),
+                task_callback=getattr(self, 'task_callback', None),
+                cli_config=getattr(self, 'cli_config', None),
+            )
 
     async def _aload_config(self):
         """Async-safe config loading (blocking file I/O off the event loop)."""
@@ -1007,7 +1030,8 @@ class AgentsGenerator:
         return await asyncio.to_thread(self._load_config)
 
     async def _aprepare_for_run(self, config):
-        """Async-safe run preparation (heavy imports + adapter.setup() off the loop)."""
+        """Async-safe run preparation (heavy imports off the loop). Adapter setup
+        runs later, inside the observability_session (see agenerate_crew_and_kickoff)."""
         import asyncio
         return await asyncio.to_thread(self._prepare_for_run, config)
 
@@ -1026,15 +1050,24 @@ class AgentsGenerator:
         prep = await self._aprepare_for_run(config)
         
         self.logger.info(f"Using framework: {prep['adapter'].name}")
-        return await prep['adapter'].arun(
-            prep['config'],
-            self.config_list,
-            prep['topic'],
-            tools_dict=prep['tools_dict'],
-            agent_callback=getattr(self, 'agent_callback', None),
-            task_callback=getattr(self, 'task_callback', None),
-            cli_config=getattr(self, 'cli_config', None),
-        )
+        # Own the observability lifecycle here so init and finalize are always
+        # paired for every adapter (the CM finalizes on success and error alike).
+        import asyncio
+        from .observability.hooks import observability_session
+        with observability_session(prep['adapter'].name):
+            # Run setup INSIDE the session (off the event loop, as it may block)
+            # so setup events and any setup/import failure are recorded and
+            # finalized, not dropped outside observability.
+            await asyncio.to_thread(self._run_adapter_setup, prep['adapter'])
+            return await prep['adapter'].arun(
+                prep['config'],
+                self.config_list,
+                prep['topic'],
+                tools_dict=prep['tools_dict'],
+                agent_callback=getattr(self, 'agent_callback', None),
+                task_callback=getattr(self, 'task_callback', None),
+                cli_config=getattr(self, 'cli_config', None),
+            )
 
 
     def _build_yaml_workflow(self, config):

{praisonai-4.6.150 → praisonai-4.6.152}/praisonai/api/agent_invoke.py

@@ -168,6 +168,109 @@ def list_registered_agents() -> list:
     return list(_agent_registry.keys())
 
 
+def _is_real_agent(agent: Any) -> bool:
+    """Return True when ``agent`` is a genuine ``praisonaiagents`` ``Agent``.
+
+    Uses ``isinstance`` against the real ``Agent`` class so **subclasses defined
+    in application code** are recognised too (they inherit the per-session
+    machinery and ``clone_for_channel``). Plain mocks / lightweight callables are
+    not ``Agent`` instances, so they fall back to the shared instance for
+    backward compatibility. If ``praisonaiagents`` cannot be imported we treat
+    the object as non-isolatable.
+    """
+    try:
+        from praisonaiagents import Agent
+    except Exception:
+        return False
+    return isinstance(agent, Agent)
+
+
+def _supports_session_isolation(agent: Any) -> bool:
+    """Return True when ``agent`` can be safely cloned per session.
+
+    A real ``Agent`` (or any subclass) exposes the per-session machinery
+    (``_session_id`` binding, ``chat_history`` and a safe clone path). Plain
+    mocks / lightweight callables do not, so they stay on the shared instance to
+    preserve backward compatibility.
+    """
+    if not _is_real_agent(agent):
+        return False
+    if not hasattr(agent, "_session_id"):
+        return False
+    if not hasattr(agent, "chat_history"):
+        return False
+    return callable(getattr(agent, "clone_for_channel", None))
+
+
+def _clone_agent(agent: Any) -> Any:
+    """Create an independent copy of a real ``Agent``.
+
+    Prefers ``clone_for_channel`` (purpose-built for multi-channel isolation
+    with fresh locks), falling back to ``deepcopy``.
+    """
+    clone_for_channel = getattr(agent, "clone_for_channel", None)
+    if callable(clone_for_channel):
+        return clone_for_channel()
+    import copy as _copy
+
+    return _copy.deepcopy(agent)
+
+
+def resolve_session_agent(agent_id: str, session_id: Optional[str]) -> Any:
+    """Resolve an isolated, session-scoped agent for a single request.
+
+    The registry holds a *template* agent, not a live conversation. Every
+    request gets its own clone so concurrent callers never share mutable
+    ``chat_history``:
+
+    - With a ``session_id``: the clone is bound to that session so its history
+      is loaded from (and persisted to) the shared, file-locked session store —
+      giving continuity across requests and isolation between sessions.
+    - Without a ``session_id``: the clone is ephemeral (no session binding), so
+      no global state is mutated.
+
+    Agents that don't support cloning/session binding (e.g. plain mocks) fall
+    back to the shared registry instance for backward compatibility.
+    """
+    template = get_agent(agent_id)
+    if template is None:
+        return None
+
+    if not _supports_session_isolation(template):
+        return template
+
+    try:
+        agent = _clone_agent(template)
+    except Exception as e:
+        # A clone failure must never silently fall back to the shared template:
+        # doing so would leak one session's chat_history into another. Fail the
+        # request instead so isolation is guaranteed.
+        logger.error(
+            f"Failed to clone agent '{agent_id}' for session isolation: {e}"
+        )
+        raise RuntimeError(
+            f"Failed to isolate agent '{agent_id}' for session: {e}"
+        ) from e
+
+    # Reset per-request conversation state so the clone starts clean and
+    # (re)loads the requested session's history lazily on first chat.
+    try:
+        agent.chat_history = []
+    except Exception:
+        pass
+    if hasattr(agent, "_session_store_initialized"):
+        agent._session_store_initialized = False
+    if session_id:
+        agent._session_id = session_id
+        if hasattr(agent, "_history_session_id"):
+            agent._history_session_id = session_id
+    else:
+        agent._session_id = None
+        if hasattr(agent, "_history_session_id"):
+            agent._history_session_id = None
+    return agent
+
+
 def _supports_async_start(agent: Any) -> bool:
     """Return True if agent.astart is a coroutine function."""
     astart = getattr(agent, "astart", None)
@@ -218,8 +321,17 @@ if FASTAPI_AVAILABLE and APIRouter is not None:
         }
         ```
         """
-        # Get agent from registry
-        agent = get_agent(agent_id)
+        # Resolve a per-session isolated agent view so concurrent callers never
+        # share mutable chat_history. A provided session_id gives continuity via
+        # the shared session store; its absence yields an ephemeral conversation.
+        try:
+            agent = resolve_session_agent(agent_id, request.session_id)
+        except Exception as e:
+            logger.error(f"Failed to isolate agent {agent_id}: {e}")
+            raise HTTPException(
+                status_code=500,
+                detail=f"Agent execution failed: {str(e)}"
+            )
         if not agent:
             logger.error(f"Agent not found: {agent_id}")
             raise HTTPException(
@@ -228,7 +340,7 @@ if FASTAPI_AVAILABLE and APIRouter is not None:
             )
         
         try:
-            # Set session ID if provided
+            # Session ID echoed back to the caller
             session_id = request.session_id or "default"
             
             # Apply agent config overrides if provided
@@ -362,15 +474,19 @@ async def invoke_agent_standalone(
     This can be used in environments where FastAPI is not available
     or when integrating with other web frameworks.
     """
-    agent = get_agent(agent_id)
-    if not agent:
+    if get_agent(agent_id) is None:
         return {
             "error": f"Agent '{agent_id}' not found",
             "status": "error",
             "available_agents": list_registered_agents()
         }
-    
+
     try:
+        # Per-session isolated agent view (see resolve_session_agent). Done
+        # inside the try so a clone/isolation failure returns a clean error
+        # rather than leaking one session's history into another.
+        agent = resolve_session_agent(agent_id, session_id)
+
         # Apply config if provided
         if agent_config:
             logger.debug(f"Agent config provided: {agent_config}")

{praisonai-4.6.150 → praisonai-4.6.152}/praisonai/auto.py

@@ -733,10 +733,50 @@ class BaseAutoGenerator:
             raise error[0]
         return result[0]
 
-    @staticmethod
-    def get_available_tools() -> List[str]:
-        """Return list of available tools for agent assignment."""
-        return AVAILABLE_TOOLS.copy()
+    def _get_tool_resolver(self):
+        """Lazily construct the canonical ToolResolver (single source of truth).
+
+        Uses the shared context-local resolver so every generator in a run
+        (auto phase + AgentsGenerator + workflow/job generators) reuses one
+        warm cache instead of repeating full tool discovery. Kept lazy so
+        importing auto.py stays cheap and so a resolver-construction failure
+        never blocks generation — callers fall back to keyword/legacy hints.
+        """
+        resolver = getattr(self, "_tool_resolver", None)
+        if resolver is None:
+            try:
+                from .tool_resolver import _get_default_resolver
+                resolver = _get_default_resolver()
+            except Exception as e:  # pragma: no cover - defensive
+                logger.debug("ToolResolver unavailable (%s); using keyword hints only.", e)
+                resolver = False  # sentinel: attempted, not available
+            self._tool_resolver = resolver
+        return resolver or None
+
+    def _available_tools(self) -> List[str]:
+        """Return the real, installed tool names from the canonical ToolResolver.
+
+        This is the single source of truth shared with AgentsGenerator. Returns
+        an empty list if the resolver is unavailable so callers can fall back.
+        """
+        resolver = self._get_tool_resolver()
+        if resolver is None:
+            return []
+        try:
+            return sorted(resolver.list_available().keys())
+        except Exception as e:  # pragma: no cover - defensive
+            logger.debug("ToolResolver.list_available() failed (%s).", e)
+            return []
+
+    def get_available_tools(self) -> List[str]:
+        """Return list of available tools for agent assignment.
+
+        Routes through the canonical ToolResolver (single source of truth) so
+        the LLM is shown only tools that are actually installed. Falls back to
+        the frozen ``AVAILABLE_TOOLS`` list solely when the resolver is
+        unavailable or returns nothing.
+        """
+        return self._available_tools() or AVAILABLE_TOOLS.copy()
     
     @staticmethod
     def analyze_complexity(topic: str) -> str:
@@ -1103,38 +1143,6 @@ class AutoGenerator(BaseAutoGenerator):
         
         return merged_data
 
-    def _get_tool_resolver(self):
-        """Lazily construct the canonical ToolResolver (single source of truth).
-
-        Kept lazy so importing auto.py stays cheap and so a resolver-construction
-        failure never blocks generation — callers fall back to keyword hints.
-        """
-        resolver = getattr(self, "_tool_resolver", None)
-        if resolver is None:
-            try:
-                from .tool_resolver import ToolResolver
-                resolver = ToolResolver()
-            except Exception as e:  # pragma: no cover - defensive
-                logger.debug("ToolResolver unavailable (%s); using keyword hints only.", e)
-                resolver = False  # sentinel: attempted, not available
-            self._tool_resolver = resolver
-        return resolver or None
-
-    def _available_tools(self) -> List[str]:
-        """Return the real, installed tool names from the canonical ToolResolver.
-
-        This is the single source of truth shared with AgentsGenerator. Returns
-        an empty list if the resolver is unavailable so callers can fall back.
-        """
-        resolver = self._get_tool_resolver()
-        if resolver is None:
-            return []
-        try:
-            return sorted(resolver.list_available().keys())
-        except Exception as e:  # pragma: no cover - defensive
-            logger.debug("ToolResolver.list_available() failed (%s).", e)
-            return []
-
     def discover_tools_for_topic(self) -> List[str]:
         """
         Discover appropriate tools for the topic.