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

universal_mcp/integrations/integration.py

@@ -5,7 +5,6 @@ from loguru import logger
 
 from universal_mcp.exceptions import KeyNotFoundError, NotAuthorizedError
 from universal_mcp.stores import BaseStore, MemoryStore
-from universal_mcp.utils.agentr import AgentrClient
 
 
 def sanitize_api_key_name(name: str) -> str:
@@ -39,12 +38,13 @@ class Integration:
         """Initializes the Integration.
 
         Args:
-            name (str): The unique name for this integration instance.
+            name (str): The unique name/identifier for this integration instance.
             store (BaseStore | None, optional): A store instance for
                 persisting credentials. Defaults to `MemoryStore()`.
         """
         self.name = name
         self.store = store or MemoryStore()
+        self.type = ""
 
     def authorize(self) -> str | dict[str, Any]:
         """Initiates or provides details for the authorization process.
@@ -103,6 +103,12 @@ class Integration:
         """
         self.store.set(self.name, credentials)
 
+    def __str__(self) -> str:
+        return f"Integration(name={self.name}, type={self.type})"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
 
 class ApiKeyIntegration(Integration):
     """Handles integrations that use a simple API key for authentication.
@@ -262,6 +268,7 @@ class OAuthIntegration(Integration):
             **kwargs: Additional arguments passed to the parent `Integration`.
         """
         super().__init__(name, store, **kwargs)
+        self.type = "oauth"
         self.client_id = client_id
         self.client_secret = client_secret
         self.auth_url = auth_url
@@ -397,92 +404,3 @@ class OAuthIntegration(Integration):
         credentials = response.json()
         self.store.set(self.name, credentials)
         return credentials
-
-
-class AgentRIntegration(Integration):
-    """Manages authentication and authorization via the AgentR platform.
-
-    This integration uses an `AgentrClient` to interact with the AgentR API
-    for operations like retrieving authorization URLs and fetching stored
-    credentials. It simplifies integration with services supported by AgentR.
-
-    Attributes:
-        name (str): Name of the integration (e.g., "github", "google").
-        store (BaseStore): Store, typically not used directly by this class
-                       as AgentR manages the primary credential storage.
-        client (AgentrClient): Client for communicating with the AgentR API.
-        _credentials (dict | None): Cached credentials.
-    """
-
-    def __init__(self, name: str, client: AgentrClient | None = None, **kwargs):
-        """Initializes the AgentRIntegration.
-
-        Args:
-            name (str): The name of the service integration as configured on
-                        the AgentR platform (e.g., "github").
-            client (AgentrClient | None, optional): The AgentR client. If not provided,
-                                                   a new `AgentrClient` will be created.
-            **kwargs: Additional arguments passed to the parent `Integration`.
-        """
-        super().__init__(name, **kwargs)
-        self.client = client or AgentrClient()
-        self._credentials = None
-
-    def set_credentials(self, credentials: dict[str, Any] | None = None) -> str:
-        """Not used for direct credential setting; initiates authorization instead.
-
-        For AgentR integrations, credentials are set via the AgentR platform's
-        OAuth flow. This method effectively redirects to the `authorize` flow.
-
-        Args:
-            credentials (dict | None, optional): Not used by this implementation.
-
-        Returns:
-            str: The authorization URL or message from the `authorize()` method.
-        """
-        return self.authorize()
-
-    @property
-    def credentials(self):
-        """Retrieves credentials from the AgentR API, with caching.
-
-        If credentials are not cached locally (in `_credentials`), this property
-        fetches them from the AgentR platform using `self.client.get_credentials`.
-
-        Returns:
-            dict: The credentials dictionary obtained from AgentR.
-
-        Raises:
-            NotAuthorizedError: If credentials are not found (e.g., 404 from AgentR).
-            httpx.HTTPStatusError: For other API errors from AgentR.
-        """
-        if self._credentials is not None:
-            return self._credentials
-        self._credentials = self.client.get_credentials(self.name)
-        return self._credentials
-
-    def get_credentials(self):
-        """Retrieves credentials from the AgentR API. Alias for `credentials` property.
-
-        Returns:
-            dict: The credentials dictionary obtained from AgentR.
-
-        Raises:
-            NotAuthorizedError: If credentials are not found.
-            httpx.HTTPStatusError: For other API errors.
-        """
-        return self.credentials
-
-    def authorize(self) -> str:
-        """Retrieves the authorization URL from the AgentR platform.
-
-        This URL should be presented to the user to initiate the OAuth flow
-        managed by AgentR for the service associated with `self.name`.
-
-        Returns:
-            str: The authorization URL.
-
-        Raises:
-            httpx.HTTPStatusError: If the API request to AgentR fails.
-        """
-        return self.client.get_authorization_url(self.name)

universal_mcp/servers/__init__.py

@@ -1,15 +1,3 @@
-from universal_mcp.config import ServerConfig
-from universal_mcp.servers.server import AgentRServer, BaseServer, LocalServer, SingleMCPServer
+from universal_mcp.servers.server import BaseServer, LocalServer, SingleMCPServer
 
-
-def server_from_config(config: ServerConfig):
-    if config.type == "agentr":
-        return AgentRServer(config=config, api_key=config.api_key)
-
-    elif config.type == "local":
-        return LocalServer(config=config)
-    else:
-        raise ValueError(f"Unsupported server type: {config.type}")
-
-
-__all__ = ["AgentRServer", "LocalServer", "SingleMCPServer", "BaseServer", "server_from_config"]
+__all__ = ["LocalServer", "SingleMCPServer", "BaseServer"]

universal_mcp/servers/server.py

@@ -5,14 +5,13 @@ from loguru import logger
 from mcp.server.fastmcp import FastMCP
 from mcp.types import TextContent
 
-from universal_mcp.applications import BaseApplication, app_from_slug
-from universal_mcp.config import AppConfig, ServerConfig
+from universal_mcp.applications import BaseApplication, app_from_config
+from universal_mcp.config import ServerConfig
 from universal_mcp.exceptions import ConfigurationError, ToolError
-from universal_mcp.integrations import AgentRIntegration, integration_from_config
+from universal_mcp.integrations.integration import ApiKeyIntegration, OAuthIntegration
 from universal_mcp.stores import store_from_config
 from universal_mcp.tools import ToolManager
 from universal_mcp.tools.adapters import ToolFormat, format_to_mcp_result
-from universal_mcp.utils.agentr import AgentrClient
 
 # --- Loader Implementations ---
 
@@ -39,39 +38,19 @@ def load_from_local_config(config: ServerConfig, tool_manager: ToolManager) -> N
         try:
             integration = None
             if app_config.integration:
-                try:
-                    integration = integration_from_config(app_config.integration, store=store if config.store else None)
-                except Exception as e:
-                    logger.error(f"Failed to setup integration for {app_config.name}: {e}", exc_info=True)
-            app = app_from_slug(app_config.name)(integration=integration)
+                if app_config.integration.type == "api_key":
+                    integration = ApiKeyIntegration(config.name, store=store, **app_config.integration.credentials)
+                elif app_config.integration.type == "oauth":
+                    integration = OAuthIntegration(config.name, store=store, **app_config.integration.credentials)
+                else:
+                    raise ValueError(f"Unsupported integration type: {app_config.integration.type}")
+            app = app_from_config(app_config)(integration=integration)
             tool_manager.register_tools_from_app(app, app_config.actions)
             logger.info(f"Loaded app: {app_config.name}")
         except Exception as e:
             logger.error(f"Failed to load app {app_config.name}: {e}", exc_info=True)
 
 
-def load_from_agentr_server(client: AgentrClient, tool_manager: ToolManager) -> None:
-    """Load apps from AgentR server and register their tools."""
-    try:
-        apps = client.fetch_apps()
-        for app in apps:
-            try:
-                app_config = AppConfig.model_validate(app)
-                integration = (
-                    AgentRIntegration(name=app_config.integration.name, client=client)  # type: ignore
-                    if app_config.integration
-                    else None
-                )
-                app_instance = app_from_slug(app_config.name)(integration=integration)
-                tool_manager.register_tools_from_app(app_instance, app_config.actions)
-                logger.info(f"Loaded app from AgentR: {app_config.name}")
-            except Exception as e:
-                logger.error(f"Failed to load app from AgentR: {e}", exc_info=True)
-    except Exception as e:
-        logger.error(f"Failed to fetch apps from AgentR: {e}", exc_info=True)
-        raise
-
-
 def load_from_application(app_instance: BaseApplication, tool_manager: ToolManager) -> None:
     """Register all tools from a single application instance."""
     tool_manager.register_tools_from_app(app_instance, tags=["all"])
@@ -136,26 +115,6 @@ class LocalServer(BaseServer):
         return self._tool_manager
 
 
-class AgentRServer(BaseServer):
-    """Server that loads apps from AgentR server."""
-
-    def __init__(self, config: ServerConfig, **kwargs):
-        super().__init__(config, **kwargs)
-        self._tools_loaded = False
-        self.api_key = config.api_key.get_secret_value() if config.api_key else None
-        self.base_url = config.base_url
-        self.client = AgentrClient(api_key=self.api_key, base_url=self.base_url)
-
-    @property
-    def tool_manager(self) -> ToolManager:
-        if self._tool_manager is None:
-            self._tool_manager = ToolManager(warn_on_duplicate_tools=True)
-        if not self._tools_loaded:
-            load_from_agentr_server(self.client, self._tool_manager)
-            self._tools_loaded = True
-        return self._tool_manager
-
-
 class SingleMCPServer(BaseServer):
     """Server for a single, pre-configured application."""
 

universal_mcp/tools/__init__.py

@@ -1,3 +1,5 @@
+from universal_mcp.types import ToolFormat
+
 from .adapters import (
     convert_tool_to_langchain_tool,
     convert_tool_to_mcp_tool,
@@ -9,6 +11,7 @@ from .tools import Tool
 __all__ = [
     "Tool",
     "ToolManager",
+    "ToolFormat",
     "convert_tool_to_langchain_tool",
     "convert_tool_to_openai_tool",
     "convert_tool_to_mcp_tool",

universal_mcp/tools/adapters.py

@@ -1,35 +1,44 @@
-from enum import Enum
+from typing import Any
 
 from loguru import logger
 from mcp.types import TextContent
 
 from universal_mcp.tools.tools import Tool
-
-
-class ToolFormat(str, Enum):
-    """Supported tool formats."""
-
-    MCP = "mcp"
-    LANGCHAIN = "langchain"
-    OPENAI = "openai"
+from universal_mcp.types import ToolFormat  # noqa: F401
 
 
 def convert_tool_to_mcp_tool(
     tool: Tool,
 ):
     from mcp.server.fastmcp.server import MCPTool
+    from mcp.types import ToolAnnotations
 
     logger.debug(f"Converting tool '{tool.name}' to MCP format")
+
+    annotations = None
+    annotations = None
+    if tool.tags:
+        # Only set annotation hints if present in tags
+        annotation_hints = ["readOnlyHint", "destructiveHint", "openWorldHint"]
+        annotation_kwargs = {}
+        for hint in annotation_hints:
+            if hint in tool.tags:
+                annotation_kwargs[hint] = True
+        if annotation_kwargs:
+            annotations = ToolAnnotations(**annotation_kwargs)
+
     mcp_tool = MCPTool(
         name=tool.name[:63],
         description=tool.description or "",
         inputSchema=tool.parameters,
+        outputSchema=tool.output_schema,
+        annotations=annotations,
     )
     logger.debug(f"Successfully converted tool '{tool.name}' to MCP format")
     return mcp_tool
 
 
-def format_to_mcp_result(result: any) -> list[TextContent]:
+def format_to_mcp_result(result: Any) -> list[TextContent]:
     """Format tool result into TextContent list.
 
     Args:
@@ -69,7 +78,7 @@ def convert_tool_to_langchain_tool(
     logger.debug(f"Converting tool '{tool.name}' to LangChain format")
 
     async def call_tool(
-        **arguments: dict[str, any],
+        **arguments: dict[str, Any],
     ):
         logger.debug(f"Executing LangChain tool '{tool.name}' with arguments: {arguments}")
         call_tool_result = await tool.run(arguments)

universal_mcp/tools/manager.py

@@ -5,14 +5,14 @@ from loguru import logger
 
 from universal_mcp.analytics import analytics
 from universal_mcp.applications.application import BaseApplication
-from universal_mcp.exceptions import ToolError
+from universal_mcp.exceptions import ToolNotFoundError
 from universal_mcp.tools.adapters import (
-    ToolFormat,
     convert_tool_to_langchain_tool,
     convert_tool_to_mcp_tool,
     convert_tool_to_openai_tool,
 )
 from universal_mcp.tools.tools import Tool
+from universal_mcp.types import ToolFormat
 
 # Constants
 DEFAULT_IMPORTANT_TAG = "important"
@@ -20,6 +20,17 @@ TOOL_NAME_SEPARATOR = "_"
 DEFAULT_APP_NAME = "common"
 
 
+def _get_app_and_tool_name(tool_name: str) -> tuple[str, str]:
+    """Get the app name from a tool name."""
+    if TOOL_NAME_SEPARATOR in tool_name:
+        app_name = tool_name.split(TOOL_NAME_SEPARATOR, 1)[0]
+        tool_name_without_app_name = tool_name.split(TOOL_NAME_SEPARATOR, 1)[1]
+    else:
+        app_name = DEFAULT_APP_NAME
+        tool_name_without_app_name = tool_name
+    return app_name, tool_name_without_app_name
+
+
 def _filter_by_name(tools: list[Tool], tool_names: list[str] | None) -> list[Tool]:
     """Filter tools by name using simple string matching.
 
@@ -81,7 +92,8 @@ def _filter_by_tags(tools: list[Tool], tags: list[str] | None) -> list[Tool]:
 
 
 class ToolManager:
-    """Manages FastMCP tools.
+    """
+    Manages tools
 
     This class provides functionality for registering, managing, and executing tools.
     It supports multiple tool formats and provides filtering capabilities based on names and tags.
@@ -94,7 +106,6 @@ class ToolManager:
         Args:
             warn_on_duplicate_tools: Whether to warn when duplicate tool names are detected.
         """
-        self._tools_by_app: dict[str, dict[str, Tool]] = {}
         self._all_tools: dict[str, Tool] = {}
         self.warn_on_duplicate_tools = warn_on_duplicate_tools
         self.default_format = default_format
@@ -110,25 +121,10 @@ class ToolManager:
         """
         return self._all_tools.get(name)
 
-    def get_tools_by_app(self, app_name: str | None = None) -> list[Tool]:
-        """Get all tools from a specific application.
-
-        Args:
-            app_name: The name of the application to get tools from.
-
-        Returns:
-            List of tools from the specified application.
-        """
-        if app_name:
-            return list(self._tools_by_app.get(app_name, {}).values())
-        else:
-            return list(self._all_tools.values())
-
     def list_tools(
         self,
         format: ToolFormat | None = None,
         tags: list[str] | None = None,
-        app_name: str | None = None,
         tool_names: list[str] | None = None,
     ) -> list:
         """List all registered tools in the specified format.
@@ -149,12 +145,14 @@ class ToolManager:
             format = self.default_format
 
         # Start with app-specific tools or all tools
-        tools = self.get_tools_by_app(app_name)
+        tools = list(self._all_tools.values())
         # Apply filters
         tools = _filter_by_tags(tools, tags)
         tools = _filter_by_name(tools, tool_names)
 
         # Convert to requested format
+        if format == ToolFormat.NATIVE:
+            return [tool.fn for tool in tools]
         if format == ToolFormat.MCP:
             return [convert_tool_to_mcp_tool(tool) for tool in tools]
         elif format == ToolFormat.LANGCHAIN:
@@ -164,15 +162,12 @@ class ToolManager:
         else:
             raise ValueError(f"Invalid format: {format}")
 
-    def add_tool(
-        self, fn: Callable[..., Any] | Tool, name: str | None = None, app_name: str = DEFAULT_APP_NAME
-    ) -> Tool:
+    def add_tool(self, fn: Callable[..., Any] | Tool, name: str | None = None) -> Tool:
         """Add a tool to the manager.
 
         Args:
             fn: The tool function or Tool instance to add.
             name: Optional name override for the tool.
-            app_name: Application name to group the tool under.
 
         Returns:
             The registered Tool instance.
@@ -193,17 +188,11 @@ class ToolManager:
                     logger.debug(f"Tool '{tool.name}' with the same function already exists.")
             return existing
 
-        logger.debug(f"Adding tool: {tool.name} to app: {app_name}")
+        logger.debug(f"Adding tool: {tool.name}")
         self._all_tools[tool.name] = tool
-
-        # Group tool by application
-        if app_name not in self._tools_by_app:
-            self._tools_by_app[app_name] = {}
-        self._tools_by_app[app_name][tool.name] = tool
-
         return tool
 
-    def register_tools(self, tools: list[Tool], app_name: str = DEFAULT_APP_NAME) -> None:
+    def register_tools(self, tools: list[Tool]) -> None:
         """Register a list of tools.
 
         Args:
@@ -211,14 +200,12 @@ class ToolManager:
             app_name: Application name to group the tools under.
         """
         for tool in tools:
-            # Add app name to tool name if not already present
-            if app_name not in tool.name:
-                tool.name = f"{app_name}{TOOL_NAME_SEPARATOR}{tool.name}"
+            app_name, tool_name = _get_app_and_tool_name(tool.name)
 
-            if tool.name in self._all_tools:
-                logger.warning(f"Tool '{tool.name}' already exists. Skipping registration.")
-                continue
-            self.add_tool(tool, app_name=app_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:
         """Remove a tool by name.
@@ -230,23 +217,13 @@ class ToolManager:
             True if the tool was removed, False if it didn't exist.
         """
         if name in self._all_tools:
-            self._all_tools[name]
             del self._all_tools[name]
-
-            # Remove from app-specific grouping if present
-            for app_tools in self._tools_by_app.values():
-                if name in app_tools:
-                    del app_tools[name]
-                    # PERFORMANCE: Break after finding and removing to avoid unnecessary iterations
-                    break
-
             return True
         return False
 
     def clear_tools(self) -> None:
         """Remove all registered tools."""
         self._all_tools.clear()
-        self._tools_by_app.clear()
 
     def register_tools_from_app(
         self,
@@ -283,7 +260,6 @@ class ToolManager:
             try:
                 tool_instance = Tool.from_function(function)
                 tool_instance.name = f"{app.name}{TOOL_NAME_SEPARATOR}{tool_instance.name}"
-                # BUG FIX: Avoid duplicate tags - check if app.name is already in tags before adding
                 if app.name not in tool_instance.tags:
                     tool_instance.tags.append(app.name)
                 tools.append(tool_instance)
@@ -291,19 +267,16 @@ class ToolManager:
                 tool_name = getattr(function, "__name__", "unknown")
                 logger.error(f"Failed to create Tool from '{tool_name}' in {app.name}: {e}")
 
-        # BUG FIX: Apply filtering logic correctly - if both tool_names and tags are provided,
-        # we should filter by both, not use default important tag
         if tags:
             tools = _filter_by_tags(tools, tags)
 
         if tool_names:
             tools = _filter_by_name(tools, tool_names)
 
-        # BUG FIX: Only use default important tag if NO filters are provided at all
         if not tool_names and not tags:
             tools = _filter_by_tags(tools, [DEFAULT_IMPORTANT_TAG])
 
-        self.register_tools(tools, app_name=app.name)
+        self.register_tools(tools)
 
     async def call_tool(
         self,
@@ -325,11 +298,11 @@ class ToolManager:
             ToolError: If the tool is not found or execution fails.
         """
         logger.debug(f"Calling tool: {name} with arguments: {arguments}")
-        app_name = name.split(TOOL_NAME_SEPARATOR, 1)[0] if TOOL_NAME_SEPARATOR in name else DEFAULT_APP_NAME
+        app_name, _ = _get_app_and_tool_name(name)
         tool = self.get_tool(name)
         if not tool:
             logger.error(f"Unknown tool: {name}")
-            raise ToolError(f"Unknown tool: {name}")
+            raise ToolNotFoundError(f"Unknown tool: {name}")
         try:
             result = await tool.run(arguments, context)
             analytics.track_tool_called(name, app_name, "success")

universal_mcp/tools/registry.py

@@ -0,0 +1,41 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class ToolRegistry(ABC):
+    """Abstract base class for platform-specific functionality.
+
+    This class abstracts away platform-specific operations like fetching apps,
+    loading actions, and managing integrations. This allows the AutoAgent to
+    work with different platforms without being tightly coupled to any specific one.
+    """
+
+    @abstractmethod
+    async def list_apps(self) -> list[dict[str, Any]]:
+        """Get list of available apps from the platform.
+
+        Returns:
+            Return a list of apps with their details
+        """
+        pass
+
+    @abstractmethod
+    async def get_app_details(self, app_id: str) -> dict[str, Any]:
+        """Get detailed information about a specific app.
+
+        Args:
+            app_id: The ID of the app to get details for
+
+        Returns:
+            Dictionary containing app details
+        """
+        pass
+
+    @abstractmethod
+    async def load_tools(self, tools: list[str]) -> None:
+        """Load tools from the platform and register them as tools.
+
+        Args:
+            tools: The list of tools to load
+        """
+        pass

universal_mcp/tools/tools.py

@@ -3,7 +3,7 @@ from collections.abc import Callable
 from typing import Any
 
 import httpx
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, create_model
 
 from universal_mcp.exceptions import NotAuthorizedError, ToolError
 from universal_mcp.tools.docstring_parser import parse_docstring
@@ -11,6 +11,22 @@ from universal_mcp.tools.docstring_parser import parse_docstring
 from .func_metadata import FuncMetadata
 
 
+def _get_return_type_schema(return_annotation: Any) -> dict[str, Any] | None:
+    """Convert return type annotation to JSON schema using Pydantic."""
+    if return_annotation == inspect.Signature.empty or return_annotation == Any:
+        return None
+
+    try:
+        temp_model = create_model("ReturnTypeModel", return_value=(return_annotation, ...))
+
+        full_schema = temp_model.model_json_schema()
+        return_field_schema = full_schema.get("properties", {}).get("return_value")
+
+        return return_field_schema
+    except Exception:
+        return None
+
+
 class Tool(BaseModel):
     """Internal tool registration info."""
 
@@ -27,6 +43,7 @@ class Tool(BaseModel):
     )
     tags: list[str] = Field(default_factory=list, description="Tags for categorizing the tool")
     parameters: dict[str, Any] = Field(description="JSON schema for tool parameters")
+    output_schema: dict[str, Any] | None = Field(default=None, description="JSON schema for tool output")
     fn_metadata: FuncMetadata = Field(
         description="Metadata about the function including a pydantic model for tool arguments"
     )
@@ -53,6 +70,9 @@ class Tool(BaseModel):
         func_arg_metadata = FuncMetadata.func_metadata(fn, arg_description=parsed_doc["args"])
         parameters = func_arg_metadata.arg_model.model_json_schema()
 
+        sig = inspect.signature(fn)
+        output_schema = _get_return_type_schema(sig.return_annotation)
+
         simple_args_descriptions: dict[str, str] = {}
         if parsed_doc.get("args"):
             for arg_name, arg_details in parsed_doc["args"].items():
@@ -68,6 +88,7 @@ class Tool(BaseModel):
             raises_description=parsed_doc["raises"],
             tags=parsed_doc["tags"],
             parameters=parameters,
+            output_schema=output_schema,
             fn_metadata=func_arg_metadata,
             is_async=is_async,
         )

universal_mcp/types.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ToolFormat(str, Enum):
+    """Supported tool formats."""
+
+    NATIVE = "native"
+    MCP = "mcp"
+    LANGCHAIN = "langchain"
+    OPENAI = "openai"