universal-mcp 0.1.22rc1__py3-none-any.whl → 0.1.23__py3-none-any.whl

universal_mcp/applications/__init__.py

@@ -30,6 +30,8 @@ sys.path.append(str(UNIVERSAL_MCP_HOME))
 # Name are in the format of "app-name", eg, google-calendar
 # Class name is NameApp, eg, GoogleCalendarApp
 
+app_cache: dict[str, type[BaseApplication]] = {}
+
 
 def _install_or_upgrade_package(package_name: str, repository_path: str):
     """
@@ -71,6 +73,8 @@ def app_from_slug(slug: str):
     Dynamically resolve and return the application class for the given slug.
     Attempts installation from GitHub if the package is not found locally.
     """
+    if slug in app_cache:
+        return app_cache[slug]
     class_name = get_default_class_name(slug)
     module_path = get_default_module_path(slug)
     package_name = get_default_package_name(slug)
@@ -81,6 +85,7 @@ def app_from_slug(slug: str):
         module = importlib.import_module(module_path)
         class_ = getattr(module, class_name)
         logger.debug(f"Loaded class '{class_}' from module '{module_path}'")
+        app_cache[slug] = class_
         return class_
     except ModuleNotFoundError as e:
         raise ModuleNotFoundError(f"Package '{module_path}' not found locally. Please install it first.") from e

universal_mcp/applications/application.py

@@ -149,6 +149,30 @@ class APIApplication(BaseApplication):
             )
         return self._client
 
+    def _handle_response(self, response: httpx.Response) -> dict[str, Any]:
+        """
+        Handle API responses by checking for errors and parsing the response appropriately.
+
+        This method:
+        1. Checks for API errors and provides detailed error context including status code and response body
+        2. For successful responses, automatically parses JSON or returns success message
+
+        Args:
+            response: The HTTP response to process
+
+        Returns:
+            dict[str, Any] | str: Parsed JSON data if response contains JSON,
+                                 otherwise a success message with status code
+
+        Raises:
+            httpx.HTTPStatusError: If the response indicates an error status, with full error details
+        """
+        response.raise_for_status()
+        try:
+            return response.json()
+        except Exception:
+            return {"status": "success", "status_code": response.status_code, "text": response.text}
+
     def _get(self, url: str, params: dict[str, Any] | None = None) -> httpx.Response:
         """
         Make a GET request to the specified URL.
@@ -158,14 +182,13 @@ class APIApplication(BaseApplication):
             params: Optional query parameters
 
         Returns:
-            httpx.Response: The response from the server
+            httpx.Response: The raw HTTP response object
 
         Raises:
-            httpx.HTTPError: If the request fails
+            httpx.HTTPStatusError: If the request fails (when raise_for_status() is called)
         """
         logger.debug(f"Making GET request to {url} with params: {params}")
         response = self.client.get(url, params=params)
-        response.raise_for_status()
         logger.debug(f"GET request successful with status code: {response.status_code}")
         return response
 
@@ -193,10 +216,10 @@ class APIApplication(BaseApplication):
                    Example: {'file_field_name': ('filename.txt', open('file.txt', 'rb'), 'text/plain')}
 
         Returns:
-            httpx.Response: The response from the server
+            httpx.Response: The raw HTTP response object
 
         Raises:
-            httpx.HTTPError: If the request fails
+            httpx.HTTPStatusError: If the request fails (when raise_for_status() is called)
         """
         logger.debug(
             f"Making POST request to {url} with params: {params}, data type: {type(data)}, content_type={content_type}, files: {'yes' if files else 'no'}"
@@ -235,7 +258,6 @@ class APIApplication(BaseApplication):
                 content=data,  # Expect data to be bytes or str
                 params=params,
             )
-        response.raise_for_status()
         logger.debug(f"POST request successful with status code: {response.status_code}")
         return response
 
@@ -263,10 +285,10 @@ class APIApplication(BaseApplication):
                    Example: {'file_field_name': ('filename.txt', open('file.txt', 'rb'), 'text/plain')}
 
         Returns:
-            httpx.Response: The response from the server
+            httpx.Response: The raw HTTP response object
 
         Raises:
-            httpx.HTTPError: If the request fails
+            httpx.HTTPStatusError: If the request fails (when raise_for_status() is called)
         """
         logger.debug(
             f"Making PUT request to {url} with params: {params}, data type: {type(data)}, content_type={content_type}, files: {'yes' if files else 'no'}"
@@ -306,7 +328,6 @@ class APIApplication(BaseApplication):
                 content=data,  # Expect data to be bytes or str
                 params=params,
             )
-        response.raise_for_status()
         logger.debug(f"PUT request successful with status code: {response.status_code}")
         return response
 
@@ -319,14 +340,13 @@ class APIApplication(BaseApplication):
             params: Optional query parameters
 
         Returns:
-            httpx.Response: The response from the server
+            httpx.Response: The raw HTTP response object
 
         Raises:
-            httpx.HTTPError: If the request fails
+            httpx.HTTPStatusError: If the request fails (when raise_for_status() is called)
         """
         logger.debug(f"Making DELETE request to {url} with params: {params}")
         response = self.client.delete(url, params=params, timeout=self.default_timeout)
-        response.raise_for_status()
         logger.debug(f"DELETE request successful with status code: {response.status_code}")
         return response
 
@@ -340,10 +360,10 @@ class APIApplication(BaseApplication):
             params: Optional query parameters
 
         Returns:
-            httpx.Response: The response from the server
+            httpx.Response: The raw HTTP response object
 
         Raises:
-            httpx.HTTPError: If the request fails
+            httpx.HTTPStatusError: If the request fails (when raise_for_status() is called)
         """
         logger.debug(f"Making PATCH request to {url} with params: {params} and data: {data}")
         response = self.client.patch(
@@ -351,7 +371,6 @@ class APIApplication(BaseApplication):
             json=data,
             params=params,
         )
-        response.raise_for_status()
         logger.debug(f"PATCH request successful with status code: {response.status_code}")
         return response
 

universal_mcp/cli.py

@@ -270,6 +270,7 @@ def preprocess(
 def split_api(
     input_app_file: Path = typer.Argument(..., help="Path to the generated app.py file to split"),
     output_dir: Path = typer.Option(..., "--output-dir", "-o", help="Directory to save the split files"),
+    package_name: str = typer.Option(None, "--package-name", "-p", help="Package name for absolute imports (e.g., 'hubspot')"),
 ):
     """Splits a single generated API client file into multiple files based on path groups."""
     from universal_mcp.utils.openapi.api_splitter import split_generated_app_file
@@ -286,7 +287,7 @@ def split_api(
         raise typer.Exit(1)
 
     try:
-        split_generated_app_file(input_app_file, output_dir)
+        split_generated_app_file(input_app_file, output_dir, package_name)
         console.print(f"[green]Successfully split {input_app_file} into {output_dir}[/green]")
     except Exception as e:
         console.print(f"[red]Error splitting API client: {e}[/red]")

universal_mcp/client/__main__.py

@@ -0,0 +1,30 @@
+import asyncio
+import os
+import sys
+
+from loguru import logger
+from pydantic import ValidationError
+
+from universal_mcp.client.agent import ChatSession
+from universal_mcp.client.client import MultiClientServer
+from universal_mcp.config import ClientConfig
+
+
+async def main() -> None:
+    """Initialize and run the chat session."""
+    # Load settings and config using Pydantic BaseSettings
+
+    config_path = os.getenv("MCP_CONFIG_PATH", "servers.json")
+    try:
+        app_config = ClientConfig.load_json_config(config_path)
+    except (FileNotFoundError, ValidationError) as e:
+        logger.error(f"Error loading config: {e}")
+        sys.exit(1)
+
+    async with MultiClientServer(app_config.mcpServers) as mcp_server:
+        chat_session = ChatSession(mcp_server, app_config.llm)
+        await chat_session.interactive_loop()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

universal_mcp/client/agent.py

@@ -0,0 +1,96 @@
+import json
+
+from loguru import logger
+from mcp.server import Server as MCPServer
+from openai import AsyncOpenAI
+
+from universal_mcp.config import LLMConfig
+
+
+class ChatSession:
+    """Orchestrates the interaction between user, LLM, and tools."""
+
+    def __init__(self, mcp_server: MCPServer, llm: LLMConfig | None) -> None:
+        self.mcp_server: MCPServer = mcp_server
+        self.llm: AsyncOpenAI | None = AsyncOpenAI(api_key=llm.api_key, base_url=llm.base_url) if llm else None
+        self.model = llm.model if llm else None
+
+    async def run(self, messages, tools) -> None:
+        """Run the chat session."""
+        llm_response = await self.llm.chat.completions.create(
+            model=self.model,
+            messages=messages,
+            tools=tools,
+            tool_choice="auto",
+        )
+
+        tool_calls = llm_response.choices[0].message.tool_calls
+        if tool_calls:
+            for tool_call in tool_calls:
+                result = await self.mcp_server.call_tool(
+                    tool_name=tool_call.function.name,
+                    arguments=json.loads(tool_call.function.arguments) if tool_call.function.arguments else {},
+                )
+                result_content = [rc.text for rc in result.content] if result.content else "No result"
+                messages.append(
+                    {
+                        "tool_call_id": tool_call.id,
+                        "role": "tool",
+                        "name": tool_call.function.name,
+                        "content": result_content,
+                    }
+                )
+        else:
+            messages.append(llm_response.choices[0].message)
+        return messages
+
+    async def interactive_loop(self) -> None:
+        """Main chat session handler."""
+        all_openai_tools = await self.mcp_server.list_tools(format="openai")
+        system_message = "You are a helpful assistant"
+        messages = [{"role": "system", "content": system_message}]
+
+        print("\n🎯 Interactive MCP Client")
+        print("Commands:")
+        print("  list - List available tools")
+        print("  call <tool_name> [args] - Call a tool")
+        print("  quit - Exit the client")
+        print()
+        while True:
+            try:
+                user_input = input("You: ").strip()
+                if user_input.lower() in {"quit", "exit"}:
+                    logger.info("\nExiting...")
+                    break
+                elif user_input.lower() == "list":
+                    tools = await self.mcp_server.list_tools()
+                    print("\nAvailable tools:")
+                    for tool in tools:
+                        print(f"  {tool.name}")
+                    continue
+                elif user_input.startswith("call "):
+                    parts = user_input.split(maxsplit=2)
+                    tool_name = parts[1] if len(parts) > 1 else ""
+
+                    if not tool_name:
+                        print("❌ Please specify a tool name")
+                        continue
+
+                    # Parse arguments (simple JSON-like format)
+                    arguments = {}
+                    if len(parts) > 2:
+                        try:
+                            arguments = json.loads(parts[2])
+                        except json.JSONDecodeError:
+                            print("❌ Invalid arguments format (expected JSON)")
+                            continue
+                    await self.mcp_server.call_tool(tool_name, arguments)
+
+                messages.append({"role": "user", "content": user_input})
+
+                messages = await self.run(messages, all_openai_tools)
+                print("\nAssistant: ", messages[-1]["content"])
+
+            except KeyboardInterrupt:
+                print("\nExiting...")
+                break

universal_mcp/client/client.py

@@ -0,0 +1,198 @@
+import os
+import webbrowser
+from contextlib import AsyncExitStack
+from typing import Any, Literal
+
+from loguru import logger
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.auth import OAuthClientProvider
+from mcp.client.sse import sse_client
+from mcp.client.stdio import stdio_client
+from mcp.client.streamable_http import streamablehttp_client
+from mcp.server import Server
+from mcp.shared.auth import OAuthClientMetadata
+from mcp.types import (
+    CallToolResult as MCPCallToolResult,
+)
+from mcp.types import (
+    Tool as MCPTool,
+)
+from openai.types.chat import ChatCompletionToolParam
+
+from universal_mcp.client.oauth import CallbackServer
+from universal_mcp.client.token_store import TokenStore
+from universal_mcp.config import ClientTransportConfig
+from universal_mcp.stores.store import KeyringStore
+from universal_mcp.tools.adapters import transform_mcp_tool_to_openai_tool
+
+
+class MCPClient:
+    """Manages MCP server connections and tool execution."""
+
+    def __init__(self, name: str, config: ClientTransportConfig) -> None:
+        self.name: str = name
+        self.config: ClientTransportConfig = config
+        self.session: ClientSession | None = None
+        self.server_url: str = config.url
+
+        # Set up callback server
+        self.callback_server = CallbackServer(port=3000)
+        self.callback_server.start()
+
+        # Create OAuth authentication handler using the new interface
+        if self.server_url and not self.config.headers:
+            self.store = KeyringStore(self.name)
+            self.auth = OAuthClientProvider(
+                server_url="/".join(self.server_url.split("/")[:-1]),
+                client_metadata=OAuthClientMetadata.model_validate(self.client_metadata_dict),
+                storage=TokenStore(self.store),
+                redirect_handler=self._default_redirect_handler,
+                callback_handler=self._callback_handler,
+            )
+        else:
+            self.auth = None
+
+    async def _callback_handler(self) -> tuple[str, str | None]:
+        """Wait for OAuth callback and return auth code and state."""
+        print("⏳ Waiting for authorization callback...")
+        try:
+            auth_code = self.callback_server.wait_for_callback(timeout=300)
+            return auth_code, self.callback_server.get_state()
+        finally:
+            self.callback_server.stop()
+
+    @property
+    def client_metadata_dict(self) -> dict[str, Any]:
+        return {
+            "client_name": "Simple Auth Client",
+            "redirect_uris": ["http://localhost:3000/callback"],
+            "grant_types": ["authorization_code", "refresh_token"],
+            "response_types": ["code"],
+            "token_endpoint_auth_method": "client_secret_post",
+        }
+
+    async def _default_redirect_handler(self, authorization_url: str) -> None:
+        """Default redirect handler that opens the URL in a browser."""
+        print(f"Opening browser for authorization: {authorization_url}")
+        webbrowser.open(authorization_url)
+
+    async def initialize(self, exit_stack: AsyncExitStack):
+        """Initialize the server connection."""
+        transport = self.config.transport
+        try:
+            if transport == "stdio":
+                command = self.config["command"]
+                if command is None:
+                    raise ValueError("The command must be a valid string and cannot be None.")
+
+                server_params = StdioServerParameters(
+                    command=command,
+                    args=self.config["args"],
+                    env={**os.environ, **self.config["env"]} if self.config.get("env") else None,
+                )
+                stdio_transport = await exit_stack.enter_async_context(stdio_client(server_params))
+                read, write = stdio_transport
+                session = await exit_stack.enter_async_context(ClientSession(read, write))
+                await session.initialize()
+                self.session = session
+            elif transport == "streamable_http":
+                url = self.config.get("url")
+                headers = self.config.get("headers", {})
+                if not url:
+                    raise ValueError("'url' must be provided for streamable_http transport.")
+                streamable_http_transport = await exit_stack.enter_async_context(
+                    streamablehttp_client(url=url, headers=headers, auth=self.auth)
+                )
+                read, write, _ = streamable_http_transport
+                session = await exit_stack.enter_async_context(ClientSession(read, write))
+                await session.initialize()
+                self.session = session
+            elif transport == "sse":
+                url = self.config.url
+                headers = self.config.headers
+                if not url:
+                    raise ValueError("'url' must be provided for sse transport.")
+                sse_transport = await exit_stack.enter_async_context(
+                    sse_client(url=url, headers=headers, auth=self.auth)
+                )
+                read, write = sse_transport
+                session = await exit_stack.enter_async_context(ClientSession(read, write))
+                await session.initialize()
+                self.session = session
+            else:
+                raise ValueError(f"Unknown transport: {transport}")
+        except Exception as e:
+            logger.error(f"Error initializing server {self.name}: {e}")
+            raise
+
+    async def list_tools(self) -> list[MCPTool]:
+        """List available tools from the server."""
+        if self.session:
+            tools = await self.session.list_tools()
+            return list(tools.tools)
+        return []
+
+    async def call_tool(self, tool_name: str, arguments: dict[str, Any]) -> MCPCallToolResult:
+        """Call a tool on the server."""
+        if self.session:
+            return await self.session.call_tool(tool_name, arguments)
+        return MCPCallToolResult(
+            content=[],
+            isError=True,
+        )
+
+
+class MultiClientServer(Server):
+    """
+    Manages multiple MCP servers and maintains a mapping from tool name to the server that provides it.
+    """
+
+    def __init__(self, clients: dict[str, ClientTransportConfig]):
+        self.clients: list[MCPClient] = [MCPClient(name, config) for name, config in clients.items()]
+        self.tool_to_client: dict[str, MCPClient] = {}
+        self._mcp_tools: list[MCPTool] = []
+        self._exit_stack: AsyncExitStack = AsyncExitStack()
+
+    async def __aenter__(self):
+        """Initialize the server connection."""
+        for client in self.clients:
+            await client.initialize(self._exit_stack)
+        await self._populate_tool_mapping()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Clean up the server connection."""
+        self.clients.clear()
+        self.tool_to_client.clear()
+        self._mcp_tools.clear()
+        await self._exit_stack.aclose()
+
+    async def _populate_tool_mapping(self):
+        """Populate the mapping from tool name to server."""
+        self.tool_to_client.clear()
+        self._mcp_tools.clear()
+        for client in self.clients:
+            try:
+                tools = await client.list_tools()
+                for tool in tools:
+                    self._mcp_tools.append(tool)
+                    tool_name = tool.name
+                    logger.info(f"Found tool: {tool_name} from client: {client.name}")
+                    if tool_name:
+                        self.tool_to_client[tool_name] = client
+            except Exception as e:
+                logger.warning(f"Failed to list tools for client {client.name}: {e}")
+
+    async def list_tools(self, format: Literal["mcp", "openai"] = "mcp") -> list[MCPTool | ChatCompletionToolParam]:
+        """List available tools from all servers."""
+        if format == "mcp":
+            return self._mcp_tools
+        elif format == "openai":
+            return [transform_mcp_tool_to_openai_tool(tool) for tool in self._mcp_tools]
+        else:
+            raise ValueError(f"Invalid format: {format}")
+
+    async def call_tool(self, tool_name: str, arguments: dict[str, Any]) -> MCPCallToolResult:
+        """Call a tool on the server."""
+        client = self.tool_to_client[tool_name]
+        return await client.call_tool(tool_name, arguments)

universal_mcp/client/oauth.py

@@ -0,0 +1,114 @@
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib.parse import parse_qs, urlparse
+
+from universal_mcp.utils.singleton import Singleton
+
+
+class CallbackHandler(BaseHTTPRequestHandler):
+    """Simple HTTP handler to capture OAuth callback."""
+
+    def __init__(self, request, client_address, server, callback_data):
+        """Initialize with callback data storage."""
+        self.callback_data = callback_data
+        super().__init__(request, client_address, server)
+
+    def do_GET(self):
+        """Handle GET request from OAuth redirect."""
+        parsed = urlparse(self.path)
+        query_params = parse_qs(parsed.query)
+
+        if "code" in query_params:
+            self.callback_data["authorization_code"] = query_params["code"][0]
+            self.callback_data["state"] = query_params.get("state", [None])[0]
+            self.send_response(200)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            self.wfile.write(b"""
+            <html>
+            <body>
+                <h1>Authorization Successful!</h1>
+                <p>You can close this window and return to the terminal.</p>
+                <script>setTimeout(() => window.close(), 2000);</script>
+            </body>
+            </html>
+            """)
+        elif "error" in query_params:
+            self.callback_data["error"] = query_params["error"][0]
+            self.send_response(400)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            self.wfile.write(
+                f"""
+            <html>
+            <body>
+                <h1>Authorization Failed</h1>
+                <p>Error: {query_params['error'][0]}</p>
+                <p>You can close this window and return to the terminal.</p>
+            </body>
+            </html>
+            """.encode()
+            )
+        else:
+            self.send_response(404)
+            self.end_headers()
+
+    def log_message(self, format, *args):
+        """Suppress default logging."""
+        pass
+
+
+class CallbackServer(metaclass=Singleton):
+    """Simple server to handle OAuth callbacks."""
+
+    def __init__(self, port=3000):
+        self.port = port
+        self.server = None
+        self.thread = None
+        self.callback_data = {"authorization_code": None, "state": None, "error": None}
+        self._running = False
+
+    def _create_handler_with_data(self):
+        """Create a handler class with access to callback data."""
+        callback_data = self.callback_data
+
+        class DataCallbackHandler(CallbackHandler):
+            def __init__(self, request, client_address, server):
+                super().__init__(request, client_address, server, callback_data)
+
+        return DataCallbackHandler
+
+    def start(self):
+        """Start the callback server in a background thread."""
+        if self._running:
+            return
+        handler_class = self._create_handler_with_data()
+        self.server = HTTPServer(("localhost", self.port), handler_class)
+        self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)
+        self.thread.start()
+        print(f"🖥️  Started callback server on http://localhost:{self.port}")
+        self._running = True
+
+    def stop(self):
+        """Stop the callback server."""
+        if self.server:
+            self.server.shutdown()
+            self.server.server_close()
+        if self.thread:
+            self.thread.join(timeout=1)
+
+    def wait_for_callback(self, timeout=300):
+        """Wait for OAuth callback with timeout."""
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if self.callback_data["authorization_code"]:
+                return self.callback_data["authorization_code"]
+            elif self.callback_data["error"]:
+                raise Exception(f"OAuth error: {self.callback_data['error']}")
+            time.sleep(0.1)
+        raise Exception("Timeout waiting for OAuth callback")
+
+    def get_state(self):
+        """Get the received state parameter."""
+        return self.callback_data["state"]

universal_mcp/client/token_store.py

@@ -0,0 +1,32 @@
+from mcp.client.auth import TokenStorage as MCPTokenStorage
+from mcp.shared.auth import OAuthClientInformationFull, OAuthToken
+
+from universal_mcp.exceptions import KeyNotFoundError
+from universal_mcp.stores.store import KeyringStore
+
+
+class TokenStore(MCPTokenStorage):
+    """Simple in-memory token storage implementation."""
+
+    def __init__(self, store: KeyringStore):
+        self.store = store
+        self._tokens: OAuthToken | None = None
+        self._client_info: OAuthClientInformationFull | None = None
+
+    async def get_tokens(self) -> OAuthToken | None:
+        try:
+            return OAuthToken.model_validate_json(self.store.get("tokens"))
+        except KeyNotFoundError:
+            return None
+
+    async def set_tokens(self, tokens: OAuthToken) -> None:
+        self.store.set("tokens", tokens.model_dump_json())
+
+    async def get_client_info(self) -> OAuthClientInformationFull | None:
+        try:
+            return OAuthClientInformationFull.model_validate_json(self.store.get("client_info"))
+        except KeyNotFoundError:
+            return None
+
+    async def set_client_info(self, client_info: OAuthClientInformationFull) -> None:
+        self.store.set("client_info", client_info.model_dump_json())