universal-mcp 0.1.24rc17__tar.gz → 0.1.24rc21__tar.gz

{universal_mcp-0.1.24rc17 → universal_mcp-0.1.24rc21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.24rc17
+Version: 0.1.24rc21
 Summary: Universal MCP acts as a middle ware for your API applications. It can store your credentials, authorize, enable disable apps on the fly and much more.
 Author-email: Manoj Bajaj <manojbajaj95@gmail.com>
 License: MIT
@@ -32,7 +32,6 @@ Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=14.0.0
 Requires-Dist: streamlit>=1.46.1
 Requires-Dist: typer>=0.15.2
-Requires-Dist: universal-mcp-applications>=0.1.2
 Provides-Extra: dev
 Requires-Dist: litellm>=1.30.7; extra == 'dev'
 Requires-Dist: pre-commit>=4.2.0; extra == 'dev'

{universal_mcp-0.1.24rc17 → universal_mcp-0.1.24rc21}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp"
-version = "0.1.24-rc17"
+version = "0.1.24-rc21"
 description = "Universal MCP acts as a middle ware for your API applications. It can store your credentials, authorize, enable disable apps on the fly and much more."
 readme = "README.md"
 authors = [
@@ -39,7 +39,6 @@ dependencies = [
     "rich>=14.0.0",
     "streamlit>=1.46.1",
     "typer>=0.15.2",
-    "universal-mcp-applications>=0.1.2",
 ]
 
 [project.optional-dependencies]

universal_mcp-0.1.24rc21/src/tests/test_apps.py

@@ -0,0 +1,64 @@
+import pytest
+
+from universal_mcp.applications.sample.app import SampleApp
+
+
+@pytest.mark.asyncio
+async def test_sample_app_initialization():
+    """Test that the SampleApp initializes correctly."""
+    app = SampleApp()
+
+    # Check app initialized
+    assert app is not None
+    assert app.name == "sample"
+
+
+@pytest.mark.asyncio
+async def test_sample_app_tools():
+    """Test that the SampleApp provides the expected tools."""
+    app = SampleApp()
+
+    # Get list of tools
+    tools = app.list_tools()
+
+    # Check that tools are available
+    assert len(tools) > 0
+
+    # Check specific tools exist
+    tool_names = [tool.__name__ for tool in tools]
+    expected_tools = [
+        "get_current_time",
+        "get_current_date",
+        "calculate",
+        "read_file",
+        "write_file",
+        "get_simple_weather",
+        "generate_image",
+    ]
+
+    for expected_tool in expected_tools:
+        assert expected_tool in tool_names
+
+
+@pytest.mark.asyncio
+async def test_sample_app_basic_functionality():
+    """Test basic functionality of SampleApp tools."""
+    app = SampleApp()
+
+    # Test get_current_time
+    current_time = app.get_current_time()
+    assert isinstance(current_time, str)
+    assert len(current_time) > 0
+
+    # Test get_current_date
+    current_date = app.get_current_date()
+    assert isinstance(current_date, str)
+    assert len(current_date) > 0
+
+    # Test calculate
+    result = app.calculate("2 + 2")
+    assert "Result: 4" in result
+
+    # Test calculate with error
+    error_result = app.calculate("invalid expression")
+    assert "Error in calculation" in error_result

universal_mcp-0.1.24rc21/src/tests/test_local_registry.py

@@ -0,0 +1,94 @@
+import os
+import shutil
+
+import pytest
+from langchain_core.tools import StructuredTool
+from mcp.server.fastmcp.server import MCPTool
+
+from universal_mcp.exceptions import ToolNotFoundError
+from universal_mcp.tools.local_registry import LocalRegistry
+from universal_mcp.types import ToolFormat
+
+
+@pytest.fixture
+def registry():
+    """Provides a LocalRegistry instance and cleans up the output directory."""
+    output_dir = "test_output"
+    reg = LocalRegistry(output_dir=output_dir)
+    yield reg
+    # Cleanup the test output directory after tests are done
+    if os.path.exists(output_dir):
+        shutil.rmtree(output_dir)
+
+
+@pytest.mark.asyncio
+async def test_export_tools_formats(registry: LocalRegistry):
+    """Verify that tools are exported to all supported formats correctly."""
+    tool_names = ["sample__get_current_date", "sample__calculate"]
+
+    # Test MCP Format
+    mcp_tools = await registry.export_tools(tool_names, format=ToolFormat.MCP)
+    assert len(mcp_tools) == 2
+    assert all(isinstance(t, MCPTool) for t in mcp_tools)
+
+    # Test LangChain Format
+    langchain_tools = await registry.export_tools(tool_names, format=ToolFormat.LANGCHAIN)
+    assert len(langchain_tools) == 2
+    assert all(isinstance(t, StructuredTool) for t in langchain_tools)
+
+    # Test OpenAI Format
+    openai_tools = await registry.export_tools(tool_names, format=ToolFormat.OPENAI)
+    assert len(openai_tools) == 2
+    assert all(isinstance(t, dict) and t.get("type") == "function" for t in openai_tools)
+
+    # Test Native Format
+    native_tools = await registry.export_tools(tool_names, format=ToolFormat.NATIVE)
+    assert len(native_tools) == 2
+    assert all(callable(t) for t in native_tools)
+
+
+@pytest.mark.asyncio
+async def test_call_tool_success(registry: LocalRegistry):
+    """Test a successful tool call through the registry."""
+    await registry.export_tools(["sample__calculate"], format=ToolFormat.NATIVE)  # Load the tool
+    result = await registry.call_tool("sample__calculate", {"expression": "10 - 4"})
+    assert result == "Result: 6"
+
+
+@pytest.mark.asyncio
+async def test_call_tool_not_found(registry: LocalRegistry):
+    """Test that calling a non-existent tool raises the correct exception."""
+    with pytest.raises(ToolNotFoundError):
+        await registry.call_tool("nonexistent__tool", {})
+
+
+@pytest.mark.asyncio
+async def test_file_output_handling(registry: LocalRegistry):
+    """Test that file outputs are correctly handled by writing to a file."""
+    tool_name = "sample__generate_image"
+    await registry.export_tools([tool_name], format=ToolFormat.NATIVE)  # Load the tool
+
+    result = await registry.call_tool(tool_name, {"prompt": "testing file output"})
+    assert isinstance(result, str)
+    assert "File saved to:" in result
+
+    # Verify the file was actually created
+    file_path = result.split("File saved to: ")[1]
+    assert os.path.exists(file_path)
+
+
+@pytest.mark.asyncio
+async def test_unimplemented_methods(registry: LocalRegistry):
+    """Test that abstract methods raise NotImplementedError."""
+    with pytest.raises(NotImplementedError):
+        await registry.list_all_apps()
+    with pytest.raises(NotImplementedError):
+        await registry.get_app_details("some_app")
+    with pytest.raises(NotImplementedError):
+        await registry.search_apps("query")
+    with pytest.raises(NotImplementedError):
+        await registry.list_tools("some_app")
+    with pytest.raises(NotImplementedError):
+        await registry.search_tools("query")
+    with pytest.raises(NotImplementedError):
+        await registry.list_connected_apps()

universal_mcp-0.1.24rc21/src/tests/test_localserver.py

@@ -0,0 +1,71 @@
+import pytest
+
+from universal_mcp.config import AppConfig, ServerConfig
+from universal_mcp.servers.server import LocalServer
+from universal_mcp.tools.local_registry import LocalRegistry
+
+
+@pytest.fixture
+def registry():
+    """Provides a fresh LocalRegistry for each test."""
+    return LocalRegistry()
+
+
+@pytest.mark.asyncio
+async def test_local_server_initialization(registry: LocalRegistry):
+    """Test that the server initializes correctly and loads default tools."""
+    apps_list = [AppConfig(name="sample")]
+    server_config = ServerConfig(apps=apps_list)
+    server = LocalServer(server_config, registry=registry)
+
+    assert server is not None
+    assert server.registry is registry
+
+    tools = await server.list_tools()
+    tool_names = {tool.name for tool in tools}
+
+    # By default, only "important" tools should be loaded
+    assert "sample__get_current_time" in tool_names
+    assert "sample__calculate" in tool_names
+    assert "sample__generate_image" in tool_names
+    # This tool is not tagged as important
+    assert "sample__get_simple_weather" not in tool_names
+
+
+@pytest.mark.asyncio
+async def test_local_server_loads_specific_actions(registry: LocalRegistry):
+    """Test that the server loads only the actions specified in the config."""
+    actions = ["get_current_date", "calculate"]
+    apps_list = [AppConfig(name="sample", actions=actions)]
+    server_config = ServerConfig(apps=apps_list)
+    server = LocalServer(server_config, registry=registry)
+
+    tools = await server.list_tools()
+    assert len(tools) == 2
+    tool_names = {tool.name for tool in tools}
+    assert tool_names == {"sample__get_current_date", "sample__calculate"}
+
+
+@pytest.mark.asyncio
+async def test_local_server_no_apps(registry: LocalRegistry):
+    """Test that the server handles a config with no apps gracefully."""
+    server_config = ServerConfig(apps=[])
+    server = LocalServer(server_config, registry=registry)
+
+    tools = await server.list_tools()
+    assert len(tools) == 0
+
+
+@pytest.mark.asyncio
+async def test_local_server_tool_call(registry: LocalRegistry):
+    """Test that a tool can be successfully called through the server."""
+    apps_list = [AppConfig(name="sample", actions=["get_current_date"])]
+    server_config = ServerConfig(apps=apps_list)
+    server = LocalServer(server_config, registry=registry)
+
+    # Test tool call
+    result = await server.call_tool("sample__get_current_date", {})
+    assert result is not None
+    # A basic check on the result format
+    assert isinstance(result[0].text, str)
+    assert "-" in result[0].text

{universal_mcp-0.1.24rc17 → universal_mcp-0.1.24rc21}/src/tests/test_tool_manager.py

@@ -1,8 +1,6 @@
 import pytest
 
 from universal_mcp.applications.application import BaseApplication
-from universal_mcp.exceptions import ToolError, ToolNotFoundError
-from universal_mcp.tools.adapters import ToolFormat
 from universal_mcp.tools.manager import Tool, ToolManager
 from universal_mcp.types import TOOL_NAME_SEPARATOR
 
@@ -76,14 +74,14 @@ class ExampleApp(BaseApplication):
 def test_add_tool(tool_manager: ToolManager):
     tool = tool_manager.add_tool(dummy_add)
     assert tool.name == "dummy_add"
-    assert tool.name in [t.name for t in tool_manager.list_tools()]
+    assert tool.name in [t.name for t in tool_manager.get_tools()]
 
 
 def test_add_duplicate_tool(tool_manager: ToolManager):
     tool1 = tool_manager.add_tool(dummy_add)
     tool2 = tool_manager.add_tool(dummy_add)
     assert tool1 is tool2  # Should return existing tool
-    assert len(tool_manager.list_tools()) == 1
+    assert len(tool_manager.get_tools()) == 1
 
 
 def test_remove_tool(tool_manager: ToolManager):
@@ -96,26 +94,17 @@ def test_remove_tool(tool_manager: ToolManager):
 def test_clear_tools(tool_manager: ToolManager, dummy_tools):
     for tool in dummy_tools:
         tool_manager.add_tool(tool)
-    assert len(tool_manager.list_tools()) == 3
+    assert len(tool_manager.get_tools()) == 3
     tool_manager.clear_tools()
-    assert len(tool_manager.list_tools()) == 0
+    assert len(tool_manager.get_tools()) == 0
 
 
-def test_list_tools_format(tool_manager: ToolManager, dummy_tools):
+def test_get_tools_no_filters(tool_manager: ToolManager, dummy_tools):
     for tool in dummy_tools:
         tool_manager.add_tool(tool)
 
-    # Test MCP format
-    mcp_tools = tool_manager.list_tools(format=ToolFormat.MCP)
-    assert len(mcp_tools) == 3
-
-    # Test LangChain format
-    langchain_tools = tool_manager.list_tools(format=ToolFormat.LANGCHAIN)
-    assert len(langchain_tools) == 3
-
-    # Test OpenAI format
-    openai_tools = tool_manager.list_tools(format=ToolFormat.OPENAI)
-    assert len(openai_tools) == 3
+    tools = tool_manager.get_tools()
+    assert len(tools) == 3
 
 
 def test_filter_tools_by_tags(tool_manager: ToolManager, dummy_tools):
@@ -123,53 +112,21 @@ def test_filter_tools_by_tags(tool_manager: ToolManager, dummy_tools):
         tool_manager.add_tool(tool)
 
     # Test filtering by important tag
-    important_tools = tool_manager.list_tools(tags=["important"])
+    important_tools = tool_manager.get_tools(tags=["important"])
     assert len(important_tools) == 1
     assert important_tools[0].name == "dummy_add"
 
     # Test filtering by math tag
-    math_tools = tool_manager.list_tools(tags=["math"])
+    math_tools = tool_manager.get_tools(tags=["math"])
     assert len(math_tools) == 2
 
 
-@pytest.mark.asyncio
-async def test_call_tool_success(tool_manager):
-    tool_manager.add_tool(dummy_add)
-    result = await tool_manager.call_tool("dummy_add", {"a": 2, "b": 3})
-    assert result == 5
-
-
-@pytest.mark.asyncio
-async def test_call_tool_error(tool_manager: ToolManager):
-    tool_manager.add_tool(dummy_error)
-    with pytest.raises(ToolError):
-        await tool_manager.call_tool("dummy_error", {})
-
-
-@pytest.mark.asyncio
-async def test_call_nonexistent_tool(tool_manager: ToolManager):
-    with pytest.raises(ToolNotFoundError):
-        await tool_manager.call_tool("nonexistent", {})
-
-
-@pytest.mark.asyncio
-async def test_call_tool_from_app(tool_manager: ToolManager):
-    app = ExampleApp()
-    # Only important are added by default
-    tool_manager.register_tools_from_app(app)
-    tools = tool_manager.list_tools()
-    assert len(tools) == 1
-    assert f"example_app{TOOL_NAME_SEPARATOR}dummy_add" in [t.name for t in tools]
-    result = await tool_manager.call_tool(f"example_app{TOOL_NAME_SEPARATOR}dummy_add", {"a": 2, "b": 3})
-    assert result == 5
-
-
 @pytest.mark.asyncio
 async def test_call_tool_from_app_with_tags(tool_manager: ToolManager):
     app = ExampleApp()
     # Only important are added by default
     tool_manager.register_tools_from_app(app, tags=["math"])
-    tools = tool_manager.list_tools()
+    tools = tool_manager.get_tools()
     assert len(tools) == 2
     assert "example_app__dummy_add" in [t.name for t in tools]
     assert "example_app__dummy_multiply" in [t.name for t in tools]
@@ -180,7 +137,7 @@ async def test_load_tool_from_name(tool_manager: ToolManager):
     app = ExampleApp()
     # Only important are added by default
     tool_manager.register_tools_from_app(app, tool_names=["dummy_multiply", "dummy_add"])
-    tools = tool_manager.list_tools()
+    tools = tool_manager.get_tools()
     assert len(tools) == 2
     assert f"example_app{TOOL_NAME_SEPARATOR}dummy_multiply" in [t.name for t in tools]
     assert f"example_app{TOOL_NAME_SEPARATOR}dummy_add" in [t.name for t in tools]

{universal_mcp-0.1.24rc17 → universal_mcp-0.1.24rc21}/src/universal_mcp/agentr/README.md

@@ -85,7 +85,7 @@ if apps:
 
 if all_tools:
     tool_id = all_tools[0]['id']
-    
+
     # Fetch a single tool's details
     tool_details = client.get_tool(tool_id)
     print(f"Fetched details for tool '{tool_id}':", tool_details)
@@ -207,4 +207,4 @@ async def main():
 
 if __name__ == "__main__":
     asyncio.run(main())
-```
+```

{universal_mcp-0.1.24rc17 → universal_mcp-0.1.24rc21}/src/universal_mcp/agentr/client.py

@@ -1,3 +1,4 @@
+import io
 import os
 from typing import Any
 
@@ -25,6 +26,7 @@ class AgentrClient:
         base_url = base_url or os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
         self.base_url = f"{base_url.rstrip('/')}/v1"
         api_key = api_key or os.getenv("AGENTR_API_KEY")
+        self.user_id = None
         if api_key:
             self.client = httpx.Client(
                 base_url=self.base_url,
@@ -34,6 +36,7 @@ class AgentrClient:
                 verify=False,
             )
             me_data = self.me()
+            self.user_id = me_data["id"]
             logger.debug(f"Client initialized with user: {me_data['email']}")
         elif auth_token:
             logger.debug("Initializing client with auth token")
@@ -45,6 +48,7 @@ class AgentrClient:
                 verify=False,
             )
             me_data = self.me()
+            self.user_id = me_data["id"]
             logger.debug(f"Client initialized with user: {me_data['email']}")
         else:
             raise ValueError("No API key or auth token provided")
@@ -207,3 +211,10 @@ class AgentrClient:
         response = self.client.get("/tools/", params=params)
         response.raise_for_status()
         return response.json().get("items", [])
+
+    def _upload_file(self, file_name: str, mime_type: str, base64_data: str) -> str:
+        """Upload a file to the server."""
+        files = {"file": (file_name, io.BytesIO(base64_data), mime_type)}
+        reponse = self.client.post("/files/upload", files=files)
+        reponse.raise_for_status()
+        return reponse.json()

{universal_mcp-0.1.24rc17 → universal_mcp-0.1.24rc21}/src/universal_mcp/agentr/registry.py

@@ -1,25 +1,49 @@
+import base64
 from typing import Any
 
 from loguru import logger
 
 from universal_mcp.agentr.client import AgentrClient
+from universal_mcp.applications.application import BaseApplication
 from universal_mcp.applications.utils import app_from_slug
-from universal_mcp.tools.manager import ToolManager, _get_app_and_tool_name
+from universal_mcp.exceptions import ToolError, ToolNotFoundError
+from universal_mcp.tools.adapters import convert_tools
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolConfig, ToolFormat
 
 from .integration import AgentrIntegration
 
+MARKDOWN_INSTRUCTIONS = """Always render the URL in markdown format for images and media files. Here are examples:
+The url is provided in the response as "signed_url".
+For images:
+- Use markdown image syntax: ![alt text](url)
+- Example: ![Generated sunset image](https://example.com/image.png)
+- Always include descriptive alt text that explains what the image shows
+
+For audio files:
+- Use markdown link syntax with audio description: [🔊 Audio file description](url)
+- Example: [🔊 Generated speech audio](https://example.com/audio.mp3)
+
+For other media:
+- Use descriptive link text: [📄 File description](url)
+- Example: [📄 Generated document](https://example.com/document.pdf)
+
+Always make the links clickable and include relevant context about what the user will see or hear when they access the URL."""
+
 
 class AgentrRegistry(ToolRegistry):
     """Platform manager implementation for AgentR platform."""
 
     def __init__(self, client: AgentrClient | None = None, **kwargs):
         """Initialize the AgentR platform manager."""
-
+        super().__init__()
         self.client = client or AgentrClient(**kwargs)
-        self.tool_manager = ToolManager()
-        logger.debug("AgentrRegistry initialized successfully")
+
+    def _create_app_instance(self, app_name: str) -> BaseApplication:
+        """Create an app instance with an AgentrIntegration."""
+        app = app_from_slug(app_name)
+        integration = AgentrIntegration(name=app_name, client=self.client)
+        return app(integration=integration)
 
     async def list_all_apps(self) -> list[dict[str, Any]]:
         """Get list of available apps from AgentR.
@@ -120,7 +144,7 @@ class AgentrRegistry(ToolRegistry):
         self,
         tools: list[str] | ToolConfig,
         format: ToolFormat,
-    ) -> str:
+    ) -> list[Any]:
         """Export given tools to required format.
 
         Args:
@@ -128,60 +152,83 @@ class AgentrRegistry(ToolRegistry):
             format: The format to export tools to (native, mcp, langchain, openai)
 
         Returns:
-            String representation of tools in the specified format
+            List of tools in the specified format
         """
+        from langchain_core.tools import StructuredTool
+
         try:
             # Clear tools from tool manager before loading new tools
             self.tool_manager.clear_tools()
+            logger.info(f"Exporting tools to {format.value} format")
             if isinstance(tools, dict):
-                logger.info("Loading tools from tool config")
-                self._load_tools_from_tool_config(tools, self.tool_manager)
+                self._load_tools_from_tool_config(tools)
             else:
-                logger.info("Loading tools from list")
-                self._load_agentr_tools_from_list(tools, self.tool_manager)
-            loaded_tools = self.tool_manager.list_tools(format=format)
-            logger.info(f"Exporting {len(loaded_tools)} tools to {format} format")
-            return loaded_tools
-        except Exception as e:
-            logger.error(f"Error exporting tools: {e}")
-            return ""
+                self._load_tools_from_list(tools)
 
-    def _load_tools(self, app_name: str, tool_names: list[str], tool_manager: ToolManager) -> None:
-        """Helper method to load and register tools for an app."""
-        app = app_from_slug(app_name)
-        integration = AgentrIntegration(name=app_name, client=self.client)
-        app_instance = app(integration=integration)
-        tool_manager.register_tools_from_app(app_instance, tool_names=tool_names)
+            loaded_tools = self.tool_manager.get_tools()
 
-    def _load_agentr_tools_from_list(self, tools: list[str], tool_manager: ToolManager) -> None:
-        """Load tools from AgentR and register them as tools.
+            if format != ToolFormat.LANGCHAIN:
+                return convert_tools(loaded_tools, format)
 
-        Args:
-            tools: The list of tools to load (prefixed with app name)
-            tool_manager: The tool manager to register tools with
-        """
-        logger.info(f"Loading all tools: {tools}")
-        tools_by_app = {}
-        for tool_name in tools:
-            app_name, _ = _get_app_and_tool_name(tool_name)
-            tools_by_app.setdefault(app_name, []).append(tool_name)
+            logger.info(f"Exporting {len(loaded_tools)} tools to LangChain format with special handling")
 
-        for app_name, tool_names in tools_by_app.items():
-            self._load_tools(app_name, tool_names, tool_manager)
+            langchain_tools = []
+            for tool in loaded_tools:
 
-    def _load_tools_from_tool_config(self, tool_config: ToolConfig, tool_manager: ToolManager) -> None:
-        """Load tools from ToolConfig and register them as tools.
+                def create_coroutine(t):
+                    async def call_tool_wrapper(**arguments: dict[str, Any]):
+                        logger.debug(
+                            f"Executing registry-wrapped LangChain tool '{t.name}' with arguments: {arguments}"
+                        )
+                        return await self.call_tool(t.name, arguments)
 
-        Args:
-            tool_config: The tool configuration containing app names and tools
-            tool_manager: The tool manager to register tools with
-        """
-        for app_name, tool_names in tool_config.items():
-            self._load_tools(app_name, tool_names, tool_manager)
+                    return call_tool_wrapper
+
+                langchain_tool = StructuredTool(
+                    name=tool.name,
+                    description=tool.description or "",
+                    coroutine=create_coroutine(tool),
+                    response_format="content",
+                    args_schema=tool.parameters,
+                )
+                langchain_tools.append(langchain_tool)
+
+            return langchain_tools
+
+        except Exception as e:
+            logger.error(f"Error exporting tools: {e}")
+            return []
+
+    def _handle_special_output(self, data: Any) -> Any:
+        if isinstance(data, dict):
+            type_ = data.get("type")
+            if type_ == "image" or type_ == "audio":
+                # Special handling for images and audio
+                base64_data = data.get("data")
+                mime_type = data.get("mime_type")
+                file_name = data.get("file_name")
+                if not mime_type or not file_name:
+                    raise ToolError("Mime type or file name is missing")
+                bytes_data = base64.b64decode(base64_data)
+                response = self.client._upload_file(file_name, mime_type, bytes_data)
+                # Hard code instructions for llm
+                response = {**response, "instructions": MARKDOWN_INSTRUCTIONS}
+                return response
+        return data
 
     async def call_tool(self, tool_name: str, tool_args: dict[str, Any]) -> dict[str, Any]:
         """Call a tool with the given name and arguments."""
-        return await self.tool_manager.call_tool(tool_name, tool_args)
+        logger.debug(f"Calling tool: {tool_name} with arguments: {tool_args}")
+        tool = self.tool_manager.get_tool(tool_name)
+        if not tool:
+            logger.error(f"Unknown tool: {tool_name}")
+            raise ToolNotFoundError(f"Unknown tool: {tool_name}")
+        try:
+            data = await tool.run(tool_args)
+            logger.debug(f"Tool {tool_name} called with args {tool_args} and returned {data}")
+            return self._handle_special_output(data)
+        except Exception as e:
+            raise e
 
     async def list_connected_apps(self) -> list[str]:
         """List all apps that the user has connected."""