universal-mcp 0.1.24rc4__py3-none-any.whl → 0.1.24rc7__py3-none-any.whl

universal_mcp/agents/autoagent/graph.py

@@ -0,0 +1,119 @@
+import json
+from datetime import UTC, datetime
+from typing import cast
+
+from langchain_core.messages import AIMessage, ToolMessage
+from langchain_core.tools import tool
+from langgraph.graph import END, START, StateGraph
+from langgraph.runtime import Runtime
+
+from universal_mcp.agents.llm import load_chat_model
+from universal_mcp.tools.manager import ToolManager
+from universal_mcp.tools.registry import ToolRegistry
+from universal_mcp.types import ToolFormat
+
+from universal_mcp.agents.autoagent.context import Context
+from universal_mcp.agents.autoagent.prompts import SYSTEM_PROMPT
+from universal_mcp.agents.autoagent.state import State
+
+
+def create_agent(tool_registry: ToolRegistry, tool_manager: ToolManager, instructions: str = ""):
+    @tool()
+    def retrieve_tools(query: str) -> list[str]:
+        """Retrieve tools using a search query. Use multiple times if you require tools for different tasks."""
+        tools = tool_registry.search_tools(query)
+        my_connections = tool_registry.client.list_my_connections()
+        connected_apps = set(connection["app_id"] for connection in my_connections)
+        filtered_tools = [tool for tool in tools if tool["app_id"] in connected_apps]
+        if len(filtered_tools) == 0:
+            return tools
+        return filtered_tools
+    
+    @tool()
+    def ask_user(question: str) -> str:
+        """Ask the user a question. Use this tool to ask the user for any missing information for performing a task, or when you have multiple apps to choose from for performing a task."""
+        full_question = question
+        return f"ASKING_USER: {full_question}"
+
+    def call_model(
+        state: State,
+        runtime: Runtime[Context],
+    ):
+        system_prompt = runtime.context.system_prompt if runtime.context.system_prompt else SYSTEM_PROMPT
+        system_prompt = system_prompt.format(system_time=datetime.now(tz=UTC).isoformat())
+
+        messages = [{"role": "system", "content": system_prompt + "\n" + instructions}, *state["messages"]]
+        model = load_chat_model(runtime.context.model)
+        # Load tools from tool registry
+        tool_registry.load_tools(tools=state["selected_tool_ids"], tool_manager=tool_manager)
+        loaded_tools = tool_manager.list_tools(format=ToolFormat.LANGCHAIN)
+        model_with_tools = model.bind_tools([retrieve_tools, ask_user, *loaded_tools], tool_choice="auto")
+        response = cast(AIMessage, model_with_tools.invoke(messages))
+        return {"messages": [response]}
+
+    # Define the conditional edge that determines whether to continue or not
+    def should_continue(state: State):
+        messages = state["messages"]
+        last_message = messages[-1]
+        # If there is no function call, then we finish
+        if not last_message.tool_calls:
+            return END
+        # Otherwise if there is, we continue
+        else:
+            return "tools"
+    
+    def tool_router(state: State):
+        last_message = state["messages"][-1]
+        if isinstance(last_message, ToolMessage):
+            return "agent"
+        else:
+            return END
+
+
+    async def tool_node(state: State):
+        outputs = []
+        tool_ids = state["selected_tool_ids"]
+        for tool_call in state["messages"][-1].tool_calls:
+            if tool_call["name"] == retrieve_tools.name:
+                tool_result = retrieve_tools.invoke(tool_call["args"])
+                tool_ids = [tool["id"] for tool in tool_result]
+                outputs.append(
+                    ToolMessage(
+                        content=json.dumps(tool_result),
+                        name=tool_call["name"],
+                        tool_call_id=tool_call["id"],
+                    )
+                )
+            elif tool_call["name"] == ask_user.name:
+                outputs.append(
+                    ToolMessage(
+                        content=json.dumps("The user has been asked the question, and the run will wait for the user's response."),
+                        name=tool_call["name"],
+                        tool_call_id=tool_call["id"],
+                    )
+                )
+                ai_message = AIMessage(content=tool_call["args"]["question"])
+                outputs.append(ai_message)
+            else:
+                tool_manager.clear_tools()
+                tool_registry.load_tools([tool_call["name"]], tool_manager=tool_manager)
+                tool_result = await tool_manager.call_tool(tool_call["name"], tool_call["args"])
+                outputs.append(
+                    ToolMessage(
+                        content=json.dumps(tool_result),
+                        name=tool_call["name"],
+                        tool_call_id=tool_call["id"],
+                    )
+                )
+        return {"messages": outputs, "selected_tool_ids": tool_ids}
+
+    builder = StateGraph(State, context_schema=Context)
+
+    builder.add_node("agent", call_model)
+    builder.add_node("tools", tool_node)
+
+    builder.add_edge(START, "agent")
+    builder.add_conditional_edges("agent", should_continue)
+    builder.add_conditional_edges("tools", tool_router)
+
+    return builder

universal_mcp/agents/autoagent/prompts.py

@@ -0,0 +1,5 @@
+"""Default prompts used by the agent."""
+
+SYSTEM_PROMPT = """You are a helpful AI assistant. When you lack tools for any task you should use the `retrieve_tools` function to unlock relevant tools. Whenever you need to ask the user for any information, or choose between multiple different applications, you can ask the user using the `ask_user` function.
+
+System time: {system_time}"""

universal_mcp/agents/autoagent/state.py

@@ -0,0 +1,27 @@
+from typing import Annotated
+
+from langgraph.prebuilt.chat_agent_executor import AgentState
+
+
+def _enqueue(left: list, right: list) -> list:
+    """Treat left as a FIFO queue, append new items from right (preserve order),
+    keep items unique, and cap total size to 20 (drop oldest items)."""
+    max_size = 30
+    preferred_size = 20
+    if len(right) > preferred_size:
+        preferred_size = min(max_size, len(right))
+    queue = list(left or [])
+
+    for item in right[:preferred_size] or []:
+        if item in queue:
+            queue.remove(item)
+        queue.append(item)
+
+    if len(queue) > preferred_size:
+        queue = queue[-preferred_size:]
+
+    return queue
+
+
+class State(AgentState):
+    selected_tool_ids: Annotated[list[str], _enqueue]

universal_mcp/agents/autoagent/studio.py

@@ -0,0 +1,25 @@
+from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.agents.autoagent import create_agent
+from universal_mcp.tools import ToolManager
+
+tool_registry = AgentrRegistry()
+tool_manager = ToolManager()
+
+
+
+apps = tool_registry.client.list_all_apps()
+names = [app["name"] for app in apps]
+
+instructions = """
+You are a helpful assistant that can use tools to help the user. If a task requires multiple steps, you should perform separate different searches for different actions.
+These are the list of applications you can use to help the user:
+{names}
+"""
+graph = create_agent(tool_registry, tool_manager, instructions=instructions)
+
+
+
+
+
+
+

universal_mcp/agents/autoagent/utils.py

@@ -0,0 +1,13 @@
+from langchain_core.messages import BaseMessage
+
+
+def get_message_text(msg: BaseMessage) -> str:
+    """Get the text content of a message."""
+    content = msg.content
+    if isinstance(content, str):
+        return content
+    elif isinstance(content, dict):
+        return content.get("text", "")
+    else:
+        txts = [c if isinstance(c, str) else (c.get("text") or "") for c in content]
+        return "".join(txts).strip()

universal_mcp/agents/base.py

@@ -3,26 +3,31 @@ from typing import cast
 from uuid import uuid4
 
 from langchain_core.messages import AIMessageChunk
+from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.checkpoint.memory import MemorySaver
 from langgraph.types import Command
 
+from .llm import load_chat_model
 from .utils import RichCLI
 
 
 class BaseAgent:
-    def __init__(self, name: str, instructions: str, model: str):
+    def __init__(self, name: str, instructions: str, model: str, memory: BaseCheckpointSaver | None = None, **kwargs):
         self.name = name
         self.instructions = instructions
         self.model = model
-        self.memory = MemorySaver()
+        self.memory = memory or MemorySaver()
+        self._graph = None
+        self.llm = load_chat_model(model)
         self.cli = RichCLI()
 
-    @property
-    def graph(self):
+    async def _build_graph(self):
         raise NotImplementedError("Subclasses must implement this method")
 
     async def stream(self, thread_id: str, user_input: str):
-        async for event, _ in self.graph.astream(
+        if self._graph is None:
+            self._graph = await self._build_graph()
+        async for event, _ in self._graph.astream(
             {"messages": [{"role": "user", "content": user_input}]},
             config={"configurable": {"thread_id": thread_id}},
             stream_mode="messages",
@@ -32,25 +37,34 @@ class BaseAgent:
 
     async def stream_interactive(self, thread_id: str, user_input: str):
         with self.cli.display_agent_response_streaming(self.name) as stream_updater:
-            async for event in self.stream(thread_id, user_input):
+            async for event in self.astream(thread_id, user_input):
                 stream_updater.update(event.content)
 
-    async def process_command(self, command: str) -> bool | None:
-        """Process a command from the user"""
+    async def run(self, user_input: str, thread_id: str = str(uuid4())):
+        """Run the agent"""
+        if not self._graph:
+            self._graph = await self._build_graph()
+        return await self._graph.ainvoke(
+            {"messages": [{"role": "user", "content": user_input}]},
+            config={"configurable": {"thread_id": thread_id}},
+            context={"system_prompt": self.instructions, "model": self.model},
+        )
 
     async def run_interactive(self, thread_id: str = str(uuid4())):
         """Main application loop"""
 
+        if not self._graph:
+            self._graph = await self._build_graph()
         # Display welcome
         self.cli.display_welcome(self.name)
 
         # Main loop
         while True:
             try:
-                state = self.graph.get_state(config={"configurable": {"thread_id": thread_id}})
+                state = self._graph.get_state(config={"configurable": {"thread_id": thread_id}})
                 if state.interrupts:
                     value = self.cli.handle_interrupt(state.interrupts[0])
-                    self.graph.invoke(Command(resume=value), config={"configurable": {"thread_id": thread_id}})
+                    self._graph.invoke(Command(resume=value), config={"configurable": {"thread_id": thread_id}})
                     continue
 
                 user_input = self.cli.get_user_input()

universal_mcp/agents/codeact/test.py

@@ -1,10 +1,10 @@
 from universal_mcp.agentr import Agentr
 from universal_mcp.agents.codeact import create_codeact
 from universal_mcp.agents.codeact.sandbox import eval_unsafe
-from universal_mcp.agents.llm import get_llm
+from universal_mcp.agents.llm import load_chat_model
 from universal_mcp.tools.adapters import ToolFormat
 
-model = get_llm("gpt-4.1")
+model = load_chat_model("gpt-4.1")
 
 agentr = Agentr()
 agentr.load_tools(["google-mail_send_email"])

universal_mcp/agents/hil.py

@@ -7,7 +7,7 @@ from langgraph.graph.message import add_messages
 from langgraph.types import Interrupt, interrupt
 
 from .base import BaseAgent
-from .llm import get_llm
+from .llm import load_chat_model
 
 
 class State(TypedDict):
@@ -70,7 +70,7 @@ def handle_interrupt(interrupt: Interrupt) -> str | bool:
 class HilAgent(BaseAgent):
     def __init__(self, name: str, instructions: str, model: str):
         super().__init__(name, instructions, model)
-        self.llm = get_llm(model)
+        self.llm = load_chat_model(model)
         self._graph = self._build_graph()
 
     def chatbot(self, state: State):

universal_mcp/agents/llm.py

@@ -1,10 +1,28 @@
+from langchain_anthropic import ChatAnthropic
+from langchain_core.language_models import BaseChatModel
+from langchain_google_vertexai.model_garden import ChatAnthropicVertex
 from langchain_openai import AzureChatOpenAI
 
 
-def get_llm(model: str, tags: list[str] | None = None):
-    return AzureChatOpenAI(model=model, api_version="2024-12-01-preview", azure_deployment=model, tags=tags)
+def load_chat_model(fully_specified_name: str, tags: list[str] | None = None) -> BaseChatModel:
+    """Load a chat model from a fully specified name.
+
+    Args:
+        fully_specified_name (str): String in the format 'provider/model'.
+    """
+    provider, model = fully_specified_name.split("/", maxsplit=1)
+    if provider == "google_anthropic_vertex":
+        return ChatAnthropicVertex(model=model, temperature=0.2, location="asia-east1", tags=tags)
+    elif provider == "anthropic":
+        return ChatAnthropic(
+            model=model, temperature=1, thinking={"type": "enabled", "budget_tokens": 2048}, max_tokens=4096, tags=tags
+        )  # pyright: ignore[reportCallIssue]
+    elif provider == "azure":
+        return AzureChatOpenAI(model=model, api_version="2024-12-01-preview", azure_deployment=model, tags=tags)
+    else:
+        raise ValueError(f"Unsupported provider: {provider}")
 
 
 if __name__ == "__main__":
-    llm = get_llm("gpt-4.1")
+    llm = load_chat_model("azure/gpt-4.1")
     print(llm.invoke("Hello, world!"))

universal_mcp/agents/react.py

@@ -1,34 +1,36 @@
+from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.prebuilt import create_react_agent
 from loguru import logger
 
-from universal_mcp.agentr.registry import AgentrRegistry
-from universal_mcp.tools.adapters import ToolFormat
-from universal_mcp.tools.manager import ToolManager
-
-from .base import BaseAgent
-from .llm import get_llm
+from universal_mcp.agents.base import BaseAgent
+from universal_mcp.agents.tools import load_agentr_tools, load_mcp_tools
+from universal_mcp.types import ToolConfig
 
 
 class ReactAgent(BaseAgent):
     def __init__(
-        self, name: str, instructions: str, model: str, tools: list[str] | None = None, max_iterations: int = 10
+        self,
+        name: str,
+        instructions: str,
+        model: str,
+        memory: BaseCheckpointSaver | None = None,
+        tools: ToolConfig | None = None,
+        max_iterations: int = 10,
+        **kwargs,
     ):
-        super().__init__(name, instructions, model)
-        self.llm = get_llm(model)
+        super().__init__(name, instructions, model, memory, **kwargs)
+        self.tools = tools
         self.max_iterations = max_iterations
-        self.tool_manager = ToolManager()
-        registry = AgentrRegistry()
-        if tools:
-            registry.load_tools(tools, self.tool_manager)
-        logger.debug(f"Initialized ReactAgent: name={name}, model={model}")
-        self._graph = self._build_graph()
-
-    @property
-    def graph(self):
-        return self._graph
-
-    def _build_graph(self):
-        tools = self.tool_manager.list_tools(format=ToolFormat.LANGCHAIN) if self.tool_manager else []
+
+    async def _build_graph(self):
+        if self.tools:
+            config = self.tools.model_dump(exclude_none=True)
+            agentr_tools = await load_agentr_tools(config["agentrServers"]) if config.get("agentrServers") else []
+            mcp_tools = await load_mcp_tools(config["mcpServers"]) if config.get("mcpServers") else []
+            tools = agentr_tools + mcp_tools
+        else:
+            tools = []
+        logger.debug(f"Initialized ReactAgent: name={self.name}, model={self.model}")
         return create_react_agent(
             self.llm,
             tools,
@@ -53,6 +55,12 @@ if __name__ == "__main__":
     import asyncio
 
     agent = ReactAgent(
-        "Universal React Agent", "You are a helpful assistant", "gpt-4.1", tools=["google-mail_send_email"]
+        "Universal React Agent",
+        instructions="",
+        model="gpt-4o",
+        tools=ToolConfig(agentrServers={"google-mail": {"tools": ["send_email"]}}),
+    )
+    result = asyncio.run(
+        agent.run(user_input="Send an email with the subject 'testing react agent' to manoj@agentr.dev")
     )
-    asyncio.run(agent.run_interactive())
+    print(result["messages"][-1].content)

universal_mcp/agents/simple.py

@@ -5,8 +5,8 @@ from langgraph.graph import END, START, StateGraph
 from langgraph.graph.message import add_messages
 from typing_extensions import TypedDict
 
-from .base import BaseAgent
-from .llm import get_llm
+from universal_mcp.agents.base import BaseAgent
+from universal_mcp.agents.llm import load_chat_model
 
 
 class State(TypedDict):
@@ -16,7 +16,7 @@ class State(TypedDict):
 class SimpleAgent(BaseAgent):
     def __init__(self, name: str, instructions: str, model: str):
         super().__init__(name, instructions, model)
-        self.llm = get_llm(model)
+        self.llm = load_chat_model(model)
         self._graph = self._build_graph()
 
     def _build_graph(self):

universal_mcp/agents/tools.py

@@ -0,0 +1,35 @@
+import json
+
+from langchain_mcp_adapters.client import MultiServerMCPClient
+
+from universal_mcp.agentr.integration import AgentrIntegration
+from universal_mcp.applications import app_from_slug
+from universal_mcp.tools.adapters import ToolFormat
+from universal_mcp.tools.manager import ToolManager
+from universal_mcp.types import ToolConfig
+
+
+async def load_agentr_tools(agentr_servers: dict):
+    tool_manager = ToolManager()
+    for app_name, tool_names in agentr_servers.items():
+        app = app_from_slug(app_name)
+        integration = AgentrIntegration(name=app_name)
+        app_instance = app(integration=integration)
+        tool_manager.register_tools_from_app(app_instance, tool_names=tool_names["tools"])
+    tools = tool_manager.list_tools(format=ToolFormat.LANGCHAIN)
+    return tools
+
+
+async def load_mcp_tools(mcp_servers: dict):
+    client = MultiServerMCPClient(mcp_servers)
+    tools = await client.get_tools()
+    return tools
+
+
+async def load_tools(path: str) -> ToolConfig:
+    with open(path) as f:
+        data = json.load(f)
+        config = ToolConfig.model_validate(data)
+        agentr_tools = await load_agentr_tools(config.model_dump(exclude_none=True)["agentrServers"])
+        mcp_tools = await load_mcp_tools(config.model_dump(exclude_none=True)["mcpServers"])
+        return agentr_tools + mcp_tools

universal_mcp/config.py

@@ -176,96 +176,3 @@ class ServerConfig(BaseSettings):
         with open(path) as f:
             data = json.load(f)
         return cls.model_validate(data)
-
-
-class ClientTransportConfig(BaseModel):
-    """Configuration for how an MCP client connects to an MCP server.
-
-    Specifies the transport protocol and its associated parameters, such as
-    the command for stdio, URL for HTTP-based transports (SSE, streamable_http),
-    and any necessary headers or environment variables.
-    """
-
-    transport: str | None = Field(
-        default=None,
-        description="The transport protocol (e.g., 'stdio', 'sse', 'streamable_http'). Auto-detected in model_validate if not set.",
-    )
-    command: str | None = Field(
-        default=None, description="The command to execute for 'stdio' transport (e.g., 'python -m mcp_server.run')."
-    )
-    args: list[str] = Field(default=[], description="List of arguments for the 'stdio' command.")
-    env: dict[str, str] = Field(default={}, description="Environment variables to set for the 'stdio' command.")
-    url: str | None = Field(default=None, description="The URL for 'sse' or 'streamable_http' transport.")
-    headers: dict[str, str] = Field(
-        default={}, description="HTTP headers to include for 'sse' or 'streamable_http' transport."
-    )
-
-    @model_validator(mode="after")
-    def determine_transport_if_not_set(self) -> Self:
-        """Determines and sets the transport type if not explicitly provided.
-
-        - If `command` is present, transport is set to 'stdio'.
-        - If `url` is present, transport is 'streamable_http' if URL ends with '/mcp',
-          otherwise 'sse' if URL ends with '/sse'.
-        - Raises ValueError if transport cannot be determined or if neither
-          `command` nor `url` is provided.
-        """
-        if self.command:
-            self.transport = "stdio"
-        elif self.url:
-            # Remove search params from url
-            url = self.url.split("?")[0]
-            if url.rstrip("/").endswith("mcp"):
-                self.transport = "streamable_http"
-            elif url.rstrip("/").endswith("sse"):
-                self.transport = "sse"
-            else:
-                raise ValueError(f"Unknown transport: {self.url}")
-        else:
-            raise ValueError("Either command or url must be provided")
-        return self
-
-
-class ClientConfig(BaseSettings):
-    """Configuration for a client application that interacts with MCP servers and an LLM.
-
-    Defines connections to one or more MCP servers (via `mcpServers`) and
-    optionally, settings for an LLM to be used by the client (e.g., by an agent).
-    """
-
-    mcpServers: dict[str, ClientTransportConfig] = Field(
-        ...,
-        description="Dictionary of MCP server connections. Keys are descriptive names for the server, values are `ClientTransportConfig` objects defining how to connect to each server.",
-    )
-    apps: list[AppConfig] = Field(
-        default=[],
-        description="List of application configurations to load",
-    )
-    store: StoreConfig | None = Field(
-        default=None,
-        description="Default credential store configuration for applications that do not define their own specific store.",
-    )
-    model: str = Field(
-        default="openrouter/auto",
-        description="The model to use for the LLM.",
-    )
-
-    @classmethod
-    def load_json_config(cls, path: Path) -> Self:
-        """Loads client configuration from a JSON file.
-
-        Args:
-            path (str, optional): The path to the JSON configuration file.
-                Defaults to "client_config.json".
-
-        Returns:
-            ClientConfig: An instance of ClientConfig populated with data
-                          from the JSON file.
-        """
-        with open(path) as f:
-            data = json.load(f)
-        return cls.model_validate(data)
-
-    def save_json_config(self, path: str) -> None:
-        with open(path, "w") as f:
-            json.dump(self.model_dump(), f, indent=4)

universal_mcp/tools/manager.py

@@ -12,12 +12,7 @@ from universal_mcp.tools.adapters import (
     convert_tool_to_openai_tool,
 )
 from universal_mcp.tools.tools import Tool
-from universal_mcp.types import ToolFormat
-
-# Constants
-DEFAULT_IMPORTANT_TAG = "important"
-TOOL_NAME_SEPARATOR = "_"
-DEFAULT_APP_NAME = "common"
+from universal_mcp.types import DEFAULT_APP_NAME, DEFAULT_IMPORTANT_TAG, TOOL_NAME_SEPARATOR, ToolFormat
 
 
 def _get_app_and_tool_name(tool_name: str) -> tuple[str, str]:
@@ -31,8 +26,13 @@ def _get_app_and_tool_name(tool_name: str) -> tuple[str, str]:
     return app_name, tool_name_without_app_name
 
 
+def _sanitize_tool_names(tool_names: list[str]) -> list[str]:
+    """Sanitize tool names by removing empty strings and converting to lowercase."""
+    return [_get_app_and_tool_name(name)[1].lower() for name in tool_names if name]
+
+
 def _filter_by_name(tools: list[Tool], tool_names: list[str] | None) -> list[Tool]:
-    """Filter tools by name using simple string matching.
+    """Filter tools by name using set comparison for efficient matching.
 
     Args:
         tools: List of tools to filter.
@@ -45,16 +45,14 @@ def _filter_by_name(tools: list[Tool], tool_names: list[str] | None) -> list[Too
         return tools
 
     logger.debug(f"Filtering tools by names: {tool_names}")
-    # Convert names to lowercase for case-insensitive matching
-    tool_names = [name.lower() for name in tool_names]
+    tool_names_set = set(_sanitize_tool_names(tool_names))
+    logger.debug(f"Tool names set: {tool_names_set}")
     filtered_tools = []
     for tool in tools:
-        for tool_name in tool_names:
-            if tool_name in tool.name.lower():
-                filtered_tools.append(tool)
-                logger.debug(f"Tool '{tool.name}' matched name filter")
-                break
-
+        if tool.tool_name.lower() in tool_names_set:
+            filtered_tools.append(tool)
+            logger.debug(f"Tool '{tool.name}' matched name filter")
+    logger.debug(f"Filtered tools: {[tool.name for tool in filtered_tools]}")
     return filtered_tools
 
 
@@ -200,11 +198,6 @@ class ToolManager:
             app_name: Application name to group the tools under.
         """
         for tool in tools:
-            app_name, tool_name = _get_app_and_tool_name(tool.name)
-
-            # Add prefix to tool name, if not already present
-            tool.name = f"{app_name}{TOOL_NAME_SEPARATOR}{tool_name}"
-            tool.tags.append(app_name)
             self.add_tool(tool)
 
     def remove_tool(self, name: str) -> bool:
@@ -259,14 +252,14 @@ class ToolManager:
 
             try:
                 tool_instance = Tool.from_function(function)
-                tool_instance.name = f"{app.name}{TOOL_NAME_SEPARATOR}{tool_instance.name}"
+                tool_instance.app_name = app.name
                 if app.name not in tool_instance.tags:
                     tool_instance.tags.append(app.name)
                 tools.append(tool_instance)
             except Exception as e:
                 tool_name = getattr(function, "__name__", "unknown")
                 logger.error(f"Failed to create Tool from '{tool_name}' in {app.name}: {e}")
-
+        print([tool.name for tool in tools])
         if tags:
             tools = _filter_by_tags(tools, tags)