universal-mcp 0.1.23rc1__py3-none-any.whl → 0.1.23rc2__py3-none-any.whl

universal_mcp/applications/application.py

@@ -374,113 +374,6 @@ class APIApplication(BaseApplication):
         logger.debug(f"PATCH request successful with status code: {response.status_code}")
         return response
 
-    # New convenience methods that handle responses automatically with enhanced error handling
-    def _get_json(self, url: str, params: dict[str, Any] | None = None) -> dict[str, Any] | str:
-        """
-        Make a GET request and automatically handle the response with enhanced error handling.
-
-        Args:
-            url: The URL to send the request to
-            params: Optional query parameters
-
-        Returns:
-            dict[str, Any] | str: Parsed JSON response if available, otherwise success message
-
-        Raises:
-            httpx.HTTPStatusError: If the request fails with detailed error information including response body
-        """
-        response = self._get(url, params)
-        return self._handle_response(response)
-
-    def _post_json(
-        self,
-        url: str,
-        data: Any,
-        params: dict[str, Any] | None = None,
-        content_type: str = "application/json",
-        files: dict[str, Any] | None = None,
-    ) -> dict[str, Any] | str:
-        """
-        Make a POST request and automatically handle the response with enhanced error handling.
-
-        Args:
-            url: The URL to send the request to
-            data: The data to send
-            params: Optional query parameters
-            content_type: The Content-Type of the request body
-            files: Optional dictionary of files to upload
-
-        Returns:
-            dict[str, Any] | str: Parsed JSON response if available, otherwise success message
-
-        Raises:
-            httpx.HTTPStatusError: If the request fails with detailed error information including response body
-        """
-        response = self._post(url, data, params, content_type, files)
-        return self._handle_response(response)
-
-    def _put_json(
-        self,
-        url: str,
-        data: Any,
-        params: dict[str, Any] | None = None,
-        content_type: str = "application/json",
-        files: dict[str, Any] | None = None,
-    ) -> dict[str, Any] | str:
-        """
-        Make a PUT request and automatically handle the response with enhanced error handling.
-
-        Args:
-            url: The URL to send the request to
-            data: The data to send
-            params: Optional query parameters
-            content_type: The Content-Type of the request body
-            files: Optional dictionary of files to upload
-
-        Returns:
-            dict[str, Any] | str: Parsed JSON response if available, otherwise success message
-
-        Raises:
-            httpx.HTTPStatusError: If the request fails with detailed error information including response body
-        """
-        response = self._put(url, data, params, content_type, files)
-        return self._handle_response(response)
-
-    def _delete_json(self, url: str, params: dict[str, Any] | None = None) -> dict[str, Any] | str:
-        """
-        Make a DELETE request and automatically handle the response with enhanced error handling.
-
-        Args:
-            url: The URL to send the request to
-            params: Optional query parameters
-
-        Returns:
-            dict[str, Any] | str: Parsed JSON response if available, otherwise success message
-
-        Raises:
-            httpx.HTTPStatusError: If the request fails with detailed error information including response body
-        """
-        response = self._delete(url, params)
-        return self._handle_response(response)
-
-    def _patch_json(self, url: str, data: dict[str, Any], params: dict[str, Any] | None = None) -> dict[str, Any] | str:
-        """
-        Make a PATCH request and automatically handle the response with enhanced error handling.
-
-        Args:
-            url: The URL to send the request to
-            data: The data to send in the request body
-            params: Optional query parameters
-
-        Returns:
-            dict[str, Any] | str: Parsed JSON response if available, otherwise success message
-
-        Raises:
-            httpx.HTTPStatusError: If the request fails with detailed error information including response body
-        """
-        response = self._patch(url, data, params)
-        return self._handle_response(response)
-
 
 class GraphQLApplication(BaseApplication):
     """

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())

universal_mcp/config.py

@@ -1,7 +1,8 @@
+import json
 from pathlib import Path
-from typing import Any, Literal
+from typing import Any, Literal, Self
 
-from pydantic import BaseModel, Field, SecretStr, field_validator
+from pydantic import BaseModel, Field, SecretStr, field_validator, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
@@ -19,7 +20,7 @@ class IntegrationConfig(BaseModel):
     """Configuration for API integrations."""
 
     name: str = Field(..., description="Name of the integration")
-    type: Literal["api_key", "oauth", "agentr", "oauth2"] = Field(
+    type: Literal["api_key", "oauth", "agentr", "oauth2", "basic_auth"] = Field(
         default="api_key", description="Type of authentication to use"
     )
     credentials: dict[str, Any] | None = Field(default=None, description="Integration-specific credentials")
@@ -46,6 +47,9 @@ class ServerConfig(BaseSettings):
 
     name: str = Field(default="Universal MCP", description="Name of the MCP server")
     description: str = Field(default="Universal MCP", description="Description of the MCP server")
+    base_url: str = Field(
+        default="https://api.agentr.dev", description="Base URL for AgentR API", alias="AGENTR_BASE_URL"
+    )
     api_key: SecretStr | None = Field(default=None, description="API key for authentication", alias="AGENTR_API_KEY")
     type: Literal["local", "agentr"] = Field(default="agentr", description="Type of server deployment")
     transport: Literal["stdio", "sse", "streamable-http"] = Field(
@@ -70,3 +74,58 @@ class ServerConfig(BaseSettings):
         if not 1 <= v <= 65535:
             raise ValueError("Port must be between 1 and 65535")
         return v
+
+    @classmethod
+    def load_json_config(cls, path: str = "local_config.json") -> Self:
+        with open(path) as f:
+            data = json.load(f)
+        return cls.model_validate(data)
+
+
+class ClientTransportConfig(BaseModel):
+    transport: str | None = None
+    command: str | None = None
+    args: list[str] = []
+    env: dict[str, str] = {}
+    url: str | None = None
+    headers: dict[str, str] = {}
+
+    @model_validator(mode="after")
+    def model_validate(self) -> Self:
+        """
+        Set the transport type based on the presence of command or url.
+        - If command is present, transport is 'stdio'.
+        - Else if url ends with 'mcp', transport is 'streamable_http'.
+        - Else, transport is 'sse'.
+        """
+        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 LLMConfig(BaseModel):
+    api_key: str
+    base_url: str
+    model: str
+
+
+class ClientConfig(BaseSettings):
+    mcpServers: dict[str, ClientTransportConfig]
+    llm: LLMConfig | None = None
+
+    @classmethod
+    def load_json_config(cls, path: str = "servers.json") -> Self:
+        with open(path) as f:
+            data = json.load(f)
+        return cls.model_validate(data)

universal_mcp/integrations/integration.py

@@ -325,9 +325,9 @@ class AgentRIntegration(Integration):
         ValueError: If no API key is provided or found in environment variables
     """
 
-    def __init__(self, name: str, api_key: str | None = None, **kwargs):
+    def __init__(self, name: str, api_key: str | None = None, base_url: str | None = None, **kwargs):
         super().__init__(name, **kwargs)
-        self.client = AgentrClient(api_key=api_key)
+        self.client = AgentrClient(api_key=api_key, base_url=base_url)
         self._credentials = None
 
     def set_credentials(self, credentials: dict | None = None):

universal_mcp/servers/server.py

@@ -206,8 +206,8 @@ class AgentRServer(BaseServer):
         self.api_key = config.api_key.get_secret_value() if config.api_key else None
         if not self.api_key:
             raise ValueError("API key is required for AgentR server")
-        logger.info(f"Initializing AgentR server with API key: {self.api_key}")
-        self.client = AgentrClient(api_key=self.api_key)
+        logger.info(f"Initializing AgentR server with API key: {self.api_key} and base URL: {config.base_url}")
+        self.client = AgentrClient(api_key=self.api_key, base_url=config.base_url)
         self._load_apps()
 
     def _fetch_apps(self) -> list[AppConfig]:
@@ -245,7 +245,7 @@ class AgentRServer(BaseServer):
         """
         try:
             integration = (
-                AgentRIntegration(name=app_config.integration.name, api_key=self.api_key)
+                AgentRIntegration(name=app_config.integration.name, api_key=self.api_key, base_url=self.config.base_url)
                 if app_config.integration
                 else None
             )
@@ -276,10 +276,10 @@ class AgentRServer(BaseServer):
             else:
                 logger.info(f"Successfully loaded {loaded_apps}/{len(app_configs)} apps from AgentR")
 
-        except Exception:
+        except Exception as e:
             logger.error("Failed to load apps", exc_info=True)
             # Don't raise the exception to allow server to start with partial functionality
-            logger.warning("Server will start with limited functionality due to app loading failures")
+            logger.warning(f"Server will start with limited functionality due to app loading failures: {e}")
 
 
 class SingleMCPServer(BaseServer):

universal_mcp/tools/adapters.py

@@ -102,3 +102,19 @@ def convert_tool_to_openai_tool(
     }
     logger.debug(f"Successfully converted tool '{tool.name}' to OpenAI format")
     return openai_tool
+
+
+def transform_mcp_tool_to_openai_tool(mcp_tool: Tool):
+    """Convert an MCP tool to an OpenAI tool."""
+    from openai.types import FunctionDefinition
+    from openai.types.chat import ChatCompletionToolParam
+
+    return ChatCompletionToolParam(
+        type="function",
+        function=FunctionDefinition(
+            name=mcp_tool.name,
+            description=mcp_tool.description or "",
+            parameters=mcp_tool.inputSchema,
+            strict=False,
+        ),
+    )

universal_mcp/utils/openapi/api_splitter.py

@@ -15,11 +15,11 @@ class APISegmentBase:
     def _get(self, url: str, params: dict = None, **kwargs):
         return self.main_app_client._get(url, params=params, **kwargs)
 
-    def _post(self, url: str, data: Any = None, files: Any = None, params: dict = None, content_type: str = None, **kwargs):
-        return self.main_app_client._post(url, data=data, files=files, params=params, content_type=content_type, **kwargs)
+    def _post(self, url: str, data: Any = None, params: dict = None, content_type: str = None, files: Any = None, **kwargs):
+        return self.main_app_client._post(url, data=data, params=params, content_type=content_type, files=files, **kwargs)
 
-    def _put(self, url: str, data: Any = None, files: Any = None, params: dict = None, content_type: str = None, **kwargs):
-        return self.main_app_client._put(url, data=data, files=files, params=params, content_type=content_type, **kwargs)
+    def _put(self, url: str, data: Any = None, params: dict = None, content_type: str = None, files: Any = None, **kwargs):
+        return self.main_app_client._put(url, data=data, params=params, content_type=content_type, files=files, **kwargs)
 
     def _patch(self, url: str, data: Any = None, params: dict = None, **kwargs):
         return self.main_app_client._patch(url, data=data, params=params, **kwargs)
@@ -27,20 +27,9 @@ class APISegmentBase:
     def _delete(self, url: str, params: dict = None, **kwargs):
         return self.main_app_client._delete(url, params=params, **kwargs)
 
-    def _get_json(self, url: str, params: dict = None, **kwargs):
-        return self.main_app_client._get_json(url, params=params, **kwargs)
+    def _handle_response(self, response):
+        return self.main_app_client._handle_response(response)
 
-    def _post_json(self, url: str, data: Any = None, files: Any = None, params: dict = None, content_type: str = "application/json", **kwargs):
-        return self.main_app_client._post_json(url, data=data, files=files, params=params, content_type=content_type, **kwargs)
-
-    def _put_json(self, url: str, data: Any = None, files: Any = None, params: dict = None, content_type: str = "application/json", **kwargs):
-        return self.main_app_client._put_json(url, data=data, files=files, params=params, content_type=content_type, **kwargs)
-
-    def _patch_json(self, url: str, data: Any = None, params: dict = None, **kwargs):
-        return self.main_app_client._patch_json(url, data=data, params=params, **kwargs)
-
-    def _delete_json(self, url: str, params: dict = None, **kwargs):
-        return self.main_app_client._delete_json(url, params=params, **kwargs)
 """
 
 
@@ -165,7 +154,8 @@ class MethodTransformer(ast.NodeTransformer):
         return self.generic_visit(node)
 
 
-def split_generated_app_file(input_app_file: Path, output_dir: Path):
+def split_generated_app_file(input_app_file: Path, output_dir: Path, package_name: str = None):
+
     content = input_app_file.read_text()
     tree = ast.parse(content)
 
@@ -515,7 +505,7 @@ def split_generated_app_file(input_app_file: Path, output_dir: Path):
         # Adjust import path for segments subfolder
         final_main_module_imports.append(
             ast.ImportFrom(
-                module=f".{segments_foldername}.{seg_detail['module_name']}",
+                module=f"universal_mcp_{package_name}.{segments_foldername}.{seg_detail['module_name']}",
                 names=[ast.alias(name=seg_detail["class_name"])],
                 level=0,
             )

universal_mcp/utils/openapi/openapi.py

@@ -150,7 +150,7 @@ def _sanitize_identifier(name: str | None) -> str:
 
     # Initial replacements for common non-alphanumeric characters
     sanitized = (
-        name.replace("-", "_").replace(".", "_").replace("[", "_").replace("]", "").replace("$", "_").replace("/", "_")
+        name.replace("-", "_").replace(".", "_").replace("[", "_").replace("]", "").replace("$", "_").replace("/", "_").replace("@", "at")
     )
 
     # Remove leading underscores, but preserve a single underscore if the name (after initial replace)
@@ -971,33 +971,37 @@ def _generate_method_code(path, method, operation):
     # Use convenience methods that automatically handle responses and errors
 
     if method_lower == "get":
-        body_lines.append("        return self._get_json(url, params=query_params)")
+        body_lines.append("        response = self._get(url, params=query_params)")
+        body_lines.append("        return self._handle_response(response)")
     elif method_lower == "post":
         if selected_content_type == "multipart/form-data":
             body_lines.append(
-                f"        return self._post_json(url, data=request_body_data, files=files_data, params=query_params, content_type='{final_content_type_for_api_call}')"
+                f"        response = self._post(url, data=request_body_data, files=files_data, params=query_params, content_type='{final_content_type_for_api_call}')"
             )
         else:
             body_lines.append(
-                f"        return self._post_json(url, data=request_body_data, params=query_params, content_type='{final_content_type_for_api_call}')"
+                f"        response = self._post(url, data=request_body_data, params=query_params, content_type='{final_content_type_for_api_call}')"
             )
+        body_lines.append("        return self._handle_response(response)")
     elif method_lower == "put":
         if selected_content_type == "multipart/form-data":
             body_lines.append(
-                f"        return self._put_json(url, data=request_body_data, files=files_data, params=query_params, content_type='{final_content_type_for_api_call}')"
+                f"        response = self._put(url, data=request_body_data, files=files_data, params=query_params, content_type='{final_content_type_for_api_call}')"
             )
         else:
             body_lines.append(
-                f"        return self._put_json(url, data=request_body_data, params=query_params, content_type='{final_content_type_for_api_call}')"
+                f"        response = self._put(url, data=request_body_data, params=query_params, content_type='{final_content_type_for_api_call}')"
             )
+        body_lines.append("        return self._handle_response(response)")
     elif method_lower == "patch":
-        body_lines.append("        return self._patch_json(url, data=request_body_data, params=query_params)")
+        body_lines.append("        response = self._patch(url, data=request_body_data, params=query_params)")
+        body_lines.append("        return self._handle_response(response)")
     elif method_lower == "delete":
-        body_lines.append("        return self._delete_json(url, params=query_params)")
+        body_lines.append("        response = self._delete(url, params=query_params)")
+        body_lines.append("        return self._handle_response(response)")
     else:
-        body_lines.append(f"        return self._{method_lower}_json(url, data=request_body_data, params=query_params)")
-
-    # No need for manual response handling anymore - convenience methods handle it automatically
+        body_lines.append(f"        response = self._{method_lower}(url, data=request_body_data, params=query_params)")
+        body_lines.append("        return self._handle_response(response)")
 
     # --- Combine Signature, Docstring, and Body for Final Method Code ---
     method_code = signature + formatted_docstring + "\n" + "\n".join(body_lines)

{universal_mcp-0.1.23rc1.dist-info → universal_mcp-0.1.23rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.23rc1
+Version: 0.1.23rc2
 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
@@ -15,7 +15,7 @@ Requires-Dist: keyring>=25.6.0
 Requires-Dist: langchain-mcp-adapters>=0.0.3
 Requires-Dist: litellm>=1.30.7
 Requires-Dist: loguru>=0.7.3
-Requires-Dist: mcp>=1.9.0
+Requires-Dist: mcp>=1.9.3
 Requires-Dist: posthog>=3.24.0
 Requires-Dist: pydantic-settings>=2.8.1
 Requires-Dist: pydantic>=2.11.1

{universal_mcp-0.1.23rc1.dist-info → universal_mcp-0.1.23rc2.dist-info}/RECORD

@@ -1,25 +1,30 @@
 universal_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 universal_mcp/analytics.py,sha256=Dkv8mkc_2T2t5NxLSZzcr3BlmOispj1RKtbB86V1i4M,2306
-universal_mcp/cli.py,sha256=-MVcqDEL_0AefmEgjq3ZCa2tySxXwi-Tfoat2kboX_U,10311
-universal_mcp/config.py,sha256=HaAZvf-XzQZpqGGWUuT5zojWloO8GL5Acfa5_0sDs_Q,3321
+universal_mcp/cli.py,sha256=Ndc1I4BtmvDCM6xNtXaO6roUvNabRlclI3tLDeSHKAw,10453
+universal_mcp/config.py,sha256=9yofM9MCyBiriojFVcMqRwc9njce6lgwX5r_EfvG0NE,5185
 universal_mcp/exceptions.py,sha256=-pbeZhpNieJfnSd2-WM80pU8W8mK8VHXcSjky0BHwdk,665
 universal_mcp/logger.py,sha256=VmH_83efpErLEDTJqz55Dp0dioTXfGvMBLZUx5smOLc,2116
 universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 universal_mcp/applications/README.md,sha256=eqbizxaTxKH2O1tyIJR2yI0Db5TQxtgPd_vbpWyCa2Y,3527
 universal_mcp/applications/__init__.py,sha256=l19_sMs5766VFWU_7O2niamvvvfQOteysqylbqvjjGQ,3500
-universal_mcp/applications/application.py,sha256=-5uHUJORRjRnOwDbqJO4qSJLrFSGRghaUWOKMqhN5vo,22891
+universal_mcp/applications/application.py,sha256=_fcnfAeT5Lm2PJpHjK5ax8pCsxlDGJIKyRqnlCdEg_w,18758
+universal_mcp/client/__main__.py,sha256=72e4WyJRiLoCtHlpIuvMZcDV98LvZclVaUGJmuCvpIE,886
+universal_mcp/client/agent.py,sha256=20N0aZ55ge9PBg-R9gHxit2NSY1ppSz2ez8ZXTiO5kc,3803
+universal_mcp/client/client.py,sha256=rx-meuWZuurjaTbjumpf5NO9zIh4wH9nMYUAp2uAejU,8393
+universal_mcp/client/oauth.py,sha256=H7goK8FcVuITiwdXR30Am-qAWcgNylsrvt9EJHZMayA,4144
+universal_mcp/client/token_store.py,sha256=eoZJbVcmkR-mAGhwk1tmDXXZnDKvjoqOVZG3nXfI8f8,1234
 universal_mcp/integrations/README.md,sha256=lTAPXO2nivcBe1q7JT6PRa6v9Ns_ZersQMIdw-nmwEA,996
 universal_mcp/integrations/__init__.py,sha256=X8iEzs02IlXfeafp6GMm-cOkg70QdjnlTRuFo24KEfo,916
-universal_mcp/integrations/integration.py,sha256=2Wv9g5fJ4cbsTNsp4WcFNKdQCnj6rbBhgNQgMDAQ1Os,13057
+universal_mcp/integrations/integration.py,sha256=WtW92Awr111Vb_i_vKBvyyYvsNton3N2cX7wQ3ZXy2Y,13105
 universal_mcp/servers/README.md,sha256=ytFlgp8-LO0oogMrHkMOp8SvFTwgsKgv7XhBVZGNTbM,2284
 universal_mcp/servers/__init__.py,sha256=eBZCsaZjiEv6ZlRRslPKgurQxmpHLQyiXv2fTBygHnM,532
-universal_mcp/servers/server.py,sha256=K7sPdCixYgJmQRxOL1icscL7-52sVsghpRX_D_uREu4,12329
+universal_mcp/servers/server.py,sha256=FqAdAAXh23_ZL7ghZvXR5quAidXxQ6m-vDQrim40tag,12429
 universal_mcp/stores/README.md,sha256=jrPh_ow4ESH4BDGaSafilhOVaN8oQ9IFlFW-j5Z5hLA,2465
 universal_mcp/stores/__init__.py,sha256=quvuwhZnpiSLuojf0NfmBx2xpaCulv3fbKtKaSCEmuM,603
 universal_mcp/stores/store.py,sha256=mxnmOVlDNrr8OKhENWDtCIfK7YeCBQcGdS6I2ogRCsU,6756
 universal_mcp/tools/README.md,sha256=RuxliOFqV1ZEyeBdj3m8UKfkxAsfrxXh-b6V4ZGAk8I,2468
 universal_mcp/tools/__init__.py,sha256=Fatza_R0qYWmNF1WQSfUZZKQFu5qf-16JhZzdmyx3KY,333
-universal_mcp/tools/adapters.py,sha256=nMoZ9jnv1uKhfq6NmBJ5-a6uwdB_H8RqkdNLIacCRfM,2978
+universal_mcp/tools/adapters.py,sha256=rnicV_WBgNe0WqVG60ms0o92BoRTRqd_C9jMMndx47c,3461
 universal_mcp/tools/func_metadata.py,sha256=7kUWArtUDa2Orr7VGzpwPVfyf2LM3UFA_9arMpl7Zn8,10838
 universal_mcp/tools/manager.py,sha256=ao_ovTyca8HR4uwHdL_lTWNdquxcqRx6FaLA4U1lZvQ,11242
 universal_mcp/tools/tools.py,sha256=8S_KzARYbG9xbyqhZcI4Wk46tXiZcWlcAMgjChXNEI4,3698
@@ -32,15 +37,15 @@ universal_mcp/utils/singleton.py,sha256=kolHnbS9yd5C7z-tzaUAD16GgI-thqJXysNi3sZM
 universal_mcp/utils/testing.py,sha256=0znYkuFi8-WjOdbwrTbNC-UpMqG3EXcGOE0wxlERh_A,1464
 universal_mcp/utils/openapi/__inti__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 universal_mcp/utils/openapi/api_generator.py,sha256=FjtvbnWuI1P8W8wXuKLCirUtsqQ4HI_TuQrhpA4SqTs,4749
-universal_mcp/utils/openapi/api_splitter.py,sha256=hED34exwKcBtKzkz-3jVWzNeFBNGgjxANQeu1FibuOU,21818
+universal_mcp/utils/openapi/api_splitter.py,sha256=0hoq6KMcDVA5NynDBrFjjqjDugZvaWGBdfLzvyLkFAM,20968
 universal_mcp/utils/openapi/docgen.py,sha256=DNmwlhg_-TRrHa74epyErMTRjV2nutfCQ7seb_Rq5hE,21366
-universal_mcp/utils/openapi/openapi.py,sha256=tUD3HNLGAF808AszHLGGKPqpqLT-PZB_8LwagyvsWKQ,50828
+universal_mcp/utils/openapi/openapi.py,sha256=8TV7L1Wm9_mi_1iy0ccf_4H39XLuZjIinBnJ56H-ggw,51197
 universal_mcp/utils/openapi/preprocessor.py,sha256=PPIM3Uu8DYi3dRKdqi9thr9ufeUgkr2K08ri1BwKpoQ,60835
 universal_mcp/utils/openapi/readme.py,sha256=R2Jp7DUXYNsXPDV6eFTkLiy7MXbSULUj1vHh4O_nB4c,2974
 universal_mcp/utils/templates/README.md.j2,sha256=Mrm181YX-o_-WEfKs01Bi2RJy43rBiq2j6fTtbWgbTA,401
 universal_mcp/utils/templates/api_client.py.j2,sha256=972Im7LNUAq3yZTfwDcgivnb-b8u6_JLKWXwoIwXXXQ,908
-universal_mcp-0.1.23rc1.dist-info/METADATA,sha256=qsh7rNBIpaSDFBkw7vmIUpDgM4YYkriK9HYeDOLJpwE,12154
-universal_mcp-0.1.23rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp-0.1.23rc1.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
-universal_mcp-0.1.23rc1.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
-universal_mcp-0.1.23rc1.dist-info/RECORD,,
+universal_mcp-0.1.23rc2.dist-info/METADATA,sha256=oRusZjRll0c923kS-RTc64lZw_XTVk8NSuv1gKis1Lk,12154
+universal_mcp-0.1.23rc2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.23rc2.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.23rc2.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp-0.1.23rc2.dist-info/RECORD,,