universal-mcp 0.1.2rc1__py3-none-any.whl → 0.1.3rc1__py3-none-any.whl

universal_mcp/servers/server.py

@@ -47,14 +47,20 @@ class Server(FastMCP, ABC):
 
     async def call_tool(self, name: str, arguments: dict[str, Any]):
         """Call a tool by name with arguments."""
+        logger.info(f"Calling tool: {name} with arguments: {arguments}")
         try:
             result = await super().call_tool(name, arguments)
+            logger.info(f"Tool {name} completed successfully")
             return result
         except ToolError as e:
             raised_error = e.__cause__
             if isinstance(raised_error, NotAuthorizedError):
+                logger.warning(
+                    f"Not authorized to call tool {name}: {raised_error.message}"
+                )
                 return [TextContent(type="text", text=raised_error.message)]
             else:
+                logger.error(f"Error calling tool {name}: {str(e)}")
                 raise e
 
 
@@ -101,22 +107,18 @@ class LocalServer(Server):
     def _load_apps(self):
         logger.info(f"Loading apps: {self.apps_list}")
         for app_config in self.apps_list:
-            app = self._load_app(app_config)
-            if app:
-                tools = app.list_tools()
+            try:
+                app = self._load_app(app_config)
+                if app:
+                    tools = app.list_tools()
                 for tool in tools:
-                    full_tool_name = app.name + "_" + tool.__name__
+                    tool_name = tool.__name__
+                    name = app.name + "_" + tool_name
                     description = tool.__doc__
-                    should_add_tool = False
-                    if (
-                        app_config.actions is None
-                        or full_tool_name in app_config.actions
-                    ):
-                        should_add_tool = True
-                    if should_add_tool:
-                        self.add_tool(
-                            tool, name=full_tool_name, description=description
-                        )
+                    if app_config.actions is None or tool_name in app_config.actions:
+                        self.add_tool(tool, name=name, description=description)
+            except Exception as e:
+                logger.error(f"Error loading app {app_config.name}: {e}")
 
 
 class AgentRServer(Server):
@@ -143,7 +145,7 @@ class AgentRServer(Server):
         app = app_from_slug(name)(integration=integration)
         return app
 
-    def _list_apps_with_integrations(self):
+    def _list_apps_with_integrations(self) -> list[AppConfig]:
         # TODO: get this from the API
         response = httpx.get(
             f"{self.base_url}/api/apps/", headers={"X-API-KEY": self.api_key}
@@ -156,11 +158,16 @@ class AgentRServer(Server):
 
     def _load_apps(self):
         apps = self._list_apps_with_integrations()
-        for app in apps:
-            app = self._load_app(app)
-            if app:
-                tools = app.list_tools()
+        for app_config in apps:
+            try:
+                app = self._load_app(app_config)
+                if app:
+                    tools = app.list_tools()
                 for tool in tools:
-                    name = app.name + "_" + tool.__name__
+                    tool_name = tool.__name__
+                    name = app.name + "_" + tool_name
                     description = tool.__doc__
-                    self.add_tool(tool, name=name, description=description)
+                    if app_config.actions is None or tool_name in app_config.actions:
+                        self.add_tool(tool, name=name, description=description)
+            except Exception as e:
+                logger.error(f"Error loading app {app_config.name}: {e}")

universal_mcp/utils/docgen.py

@@ -116,7 +116,7 @@ def extract_functions_from_script(file_path: str) -> list[tuple[str, str]]:
 
 
 def generate_docstring(
-    function_code: str, model: str = "google/gemini-flash"
+    function_code: str, model: str = "openai/gpt-4o"
 ) -> DocstringOutput:
     """
     Generate a docstring for a Python function using litellm with structured output.
@@ -304,7 +304,7 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
         return function_code
 
 
-def process_file(file_path: str, model: str = "google/gemini-flash") -> int:
+def process_file(file_path: str, model: str = "openai/gpt-4o") -> int:
     """
     Process a Python file and add docstrings to all functions in it.
 

universal_mcp/utils/installation.py

@@ -4,6 +4,7 @@ import sys
 from pathlib import Path
 
 from loguru import logger
+from rich import print
 
 
 def get_uvx_path() -> str:
@@ -21,6 +22,7 @@ def get_uvx_path() -> str:
 def create_file_if_not_exists(path: Path) -> None:
     """Create a file if it doesn't exist"""
     if not path.exists():
+        print(f"[yellow]Creating config file at {path}[/yellow]")
         with open(path, "w") as f:
             json.dump({}, f)
 
@@ -32,6 +34,7 @@ def get_supported_apps() -> list[str]:
 
 def install_claude(api_key: str) -> None:
     """Install Claude"""
+    print("[bold blue]Installing Claude configuration...[/bold blue]")
     # Determine platform-specific config path
     if sys.platform == "darwin":  # macOS
         config_path = (
@@ -50,6 +53,9 @@ def install_claude(api_key: str) -> None:
     try:
         config = json.loads(config_path.read_text())
     except json.JSONDecodeError:
+        print(
+            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
+        )
         config = {}
     if "mcpServers" not in config:
         config["mcpServers"] = {}
@@ -60,10 +66,12 @@ def install_claude(api_key: str) -> None:
     }
     with open(config_path, "w") as f:
         json.dump(config, f, indent=4)
+    print("[green]✓[/green] Claude configuration installed successfully")
 
 
 def install_cursor(api_key: str) -> None:
     """Install Cursor"""
+    print("[bold blue]Installing Cursor configuration...[/bold blue]")
     # Set up Cursor config path
     config_path = Path.home() / ".cursor/mcp.json"
 
@@ -73,6 +81,9 @@ def install_cursor(api_key: str) -> None:
     try:
         config = json.loads(config_path.read_text())
     except json.JSONDecodeError:
+        print(
+            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
+        )
         config = {}
 
     if "mcpServers" not in config:
@@ -85,15 +96,18 @@ def install_cursor(api_key: str) -> None:
 
     with open(config_path, "w") as f:
         json.dump(config, f, indent=4)
+    print("[green]✓[/green] Cursor configuration installed successfully")
 
 
 def install_windsurf() -> None:
     """Install Windsurf"""
+    print("[yellow]Windsurf installation not yet implemented[/yellow]")
     pass
 
 
 def install_app(app_name: str) -> None:
     """Install an app"""
+    print(f"[bold]Installing {app_name}...[/bold]")
     if app_name == "claude":
         install_claude()
     elif app_name == "cursor":
@@ -101,4 +115,5 @@ def install_app(app_name: str) -> None:
     elif app_name == "windsurf":
         install_windsurf()
     else:
+        print(f"[red]Error: App '{app_name}' not supported[/red]")
         raise ValueError(f"App '{app_name}' not supported")

universal_mcp/utils/openapi.py

@@ -41,7 +41,7 @@ def determine_return_type(operation: dict[str, Any]) -> str:
         operation (dict): The operation details from the schema.
 
     Returns:
-        str: The appropriate return type annotation (List[Any], Dict[str, Any], or Any)
+        str: The appropriate return type annotation (list[Any], dict[str, Any], or Any)
     """
     responses = operation.get("responses", {})
     # Find successful response (2XX)
@@ -62,9 +62,9 @@ def determine_return_type(operation: dict[str, Any]) -> str:
 
                 # Only determine if it's a list, dict, or unknown (Any)
                 if schema.get("type") == "array":
-                    return "List[Any]"
+                    return "list[Any]"
                 elif schema.get("type") == "object" or "$ref" in schema:
-                    return "Dict[str, Any]"
+                    return "dict[str, Any]"
 
     # Default to Any if unable to determine
     return "Any"
@@ -144,9 +144,9 @@ def generate_api_client(schema):
 
     # Generate class imports
     imports = [
+        "from typing import Any",
         "from universal_mcp.applications import APIApplication",
         "from universal_mcp.integrations import Integration",
-        "from typing import Any, Dict, List",
     ]
 
     # Construct the class code
@@ -177,6 +177,9 @@ def generate_method_code(path, method, operation, tool_name=None):
     Returns:
         tuple: (method_code, func_name) - The Python code for the method and its name.
     """
+    # Extract path parameters from the URL path
+    path_params_in_url = re.findall(r'{([^}]+)}', path)
+    
     # Determine function name
     if "operationId" in operation:
         raw_name = operation["operationId"]
@@ -192,24 +195,35 @@ def generate_method_code(path, method, operation, tool_name=None):
             else:
                 name_parts.append(part)
         func_name = "_".join(name_parts).replace("-", "_").lower()
-
-    # Add tool name prefix if provided
-    if tool_name:
-        func_name = f"{tool_name}_{func_name}"
+    
+   
+   
+    func_name = re.sub(r'_a([^_])', r'_a_\1', func_name)  # Fix for patterns like retrieve_ablock
+    func_name = re.sub(r'_an([^_])', r'_an_\1', func_name)  # Fix for patterns like create_anitem
 
     # Get parameters and request body
-    parameters = operation.get("parameters", [])
+    # Filter out header parameters
+    parameters = [param for param in operation.get("parameters", []) if param.get("in") != "header"]
     has_body = "requestBody" in operation
     body_required = has_body and operation["requestBody"].get("required", False)
 
     # Build function arguments
     required_args = []
     optional_args = []
+    
+    
+    for param_name in path_params_in_url:
+        if param_name not in required_args:
+            required_args.append(param_name)
+
+    
     for param in parameters:
-        if param.get("required", False):
-            required_args.append(param["name"])
-        else:
-            optional_args.append(f"{param['name']}=None")
+        param_name = param["name"]
+        if param_name not in required_args:  
+            if param.get("required", False):
+                required_args.append(param_name)
+            else:
+                optional_args.append(f"{param_name}=None")
 
     # Add request body parameter
     if has_body:
@@ -229,12 +243,12 @@ def generate_method_code(path, method, operation, tool_name=None):
     # Build method body
     body_lines = []
 
-    # Validate required parameters
-    for param in parameters:
-        if param.get("required", False):
-            body_lines.append(f"        if {param['name']} is None:")
+    # Validate required parameters including path parameters
+    for param_name in required_args:
+        if param_name != "request_body":  # Skip validation for request body as it's handled separately
+            body_lines.append(f"        if {param_name} is None:")
             body_lines.append(
-                f"            raise ValueError(\"Missing required parameter '{param['name']}'\")"
+                f"            raise ValueError(\"Missing required parameter '{param_name}'\")"
             )
 
     # Validate required body
@@ -244,15 +258,9 @@ def generate_method_code(path, method, operation, tool_name=None):
             '            raise ValueError("Missing required request body")'
         )
 
-    # Path parameters
-    path_params = [p for p in parameters if p["in"] == "path"]
-    path_params_dict = ", ".join([f"'{p['name']}': {p['name']}" for p in path_params])
-    body_lines.append(f"        path_params = {{{path_params_dict}}}")
-
-    # Format URL
-    body_lines.append(
-        f'        url = f"{{self.base_url}}{path}".format_map(path_params)'
-    )
+    # Format URL directly with path parameters
+    url_line = f'        url = f"{{self.base_url}}{path}"'
+    body_lines.append(url_line)
 
     # Query parameters
     query_params = [p for p in parameters if p["in"] == "query"]
@@ -266,40 +274,32 @@ def generate_method_code(path, method, operation, tool_name=None):
     else:
         body_lines.append("        query_params = {}")
 
-    # Request body handling for JSON
-    if has_body:
-        body_lines.append(
-            "        json_body = request_body if request_body is not None else None"
-        )
-
     # Make HTTP request using the proper method
     method_lower = method.lower()
     if method_lower == "get":
         body_lines.append("        response = self._get(url, params=query_params)")
     elif method_lower == "post":
         if has_body:
-            body_lines.append(
-                "        response = self._post(url, data=json_body, params=query_params)"
-            )
+            body_lines.append("        response = self._post(url, data=request_body, params=query_params)")
         else:
-            body_lines.append(
-                "        response = self._post(url, data={}, params=query_params)"
-            )
+            body_lines.append("        response = self._post(url, data={}, params=query_params)")
     elif method_lower == "put":
         if has_body:
-            body_lines.append(
-                "        response = self._put(url, data=json_body, params=query_params)"
-            )
+            body_lines.append("        response = self._put(url, data=request_body, params=query_params)")
         else:
-            body_lines.append(
-                "        response = self._put(url, data={}, params=query_params)"
-            )
+            body_lines.append("        response = self._put(url, data={}, params=query_params)")
+    elif method_lower == "patch":
+        if has_body:
+            body_lines.append("        response = self._patch(url, data=request_body, params=query_params)")
+        else:
+            body_lines.append("        response = self._patch(url, data={}, params=query_params)")
     elif method_lower == "delete":
         body_lines.append("        response = self._delete(url, params=query_params)")
     else:
-        body_lines.append(
-            f"        response = self._{method_lower}(url, data={{}}, params=query_params)"
-        )
+        if has_body:
+            body_lines.append(f"        response = self._{method_lower}(url, data=request_body, params=query_params)")
+        else:
+            body_lines.append(f"        response = self._{method_lower}(url, data={{}}, params=query_params)")
 
     # Handle response
     body_lines.append("        response.raise_for_status()")

universal_mcp-0.1.3rc1.dist-info/METADATA

@@ -0,0 +1,252 @@
+Metadata-Version: 2.4
+Name: universal-mcp
+Version: 0.1.3rc1
+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>
+Requires-Python: >=3.11
+Requires-Dist: keyring>=25.6.0
+Requires-Dist: litellm>=1.30.7
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: markitdown[all]>=0.1.1
+Requires-Dist: mcp>=1.5.0
+Requires-Dist: posthog>=3.24.0
+Requires-Dist: pydantic-settings>=2.8.1
+Requires-Dist: pydantic>=2.11.1
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: rich>=14.0.0
+Requires-Dist: typer>=0.15.2
+Provides-Extra: dev
+Requires-Dist: litellm>=1.30.7; extra == 'dev'
+Requires-Dist: pyright>=1.1.398; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.26.0; extra == 'dev'
+Requires-Dist: pytest>=8.3.5; extra == 'dev'
+Requires-Dist: ruff>=0.11.4; extra == 'dev'
+Provides-Extra: e2b
+Requires-Dist: e2b-code-interpreter>=1.2.0; extra == 'e2b'
+Provides-Extra: firecrawl
+Requires-Dist: firecrawl-py>=1.15.0; extra == 'firecrawl'
+Provides-Extra: playground
+Requires-Dist: fastapi[standard]>=0.115.12; extra == 'playground'
+Requires-Dist: langchain-anthropic>=0.3.10; extra == 'playground'
+Requires-Dist: langchain-mcp-adapters>=0.0.3; extra == 'playground'
+Requires-Dist: langchain-openai>=0.3.12; extra == 'playground'
+Requires-Dist: langgraph-checkpoint-sqlite>=2.0.6; extra == 'playground'
+Requires-Dist: langgraph>=0.3.24; extra == 'playground'
+Requires-Dist: python-dotenv>=1.0.1; extra == 'playground'
+Requires-Dist: streamlit>=1.44.1; extra == 'playground'
+Provides-Extra: serpapi
+Requires-Dist: google-search-results>=2.4.2; extra == 'serpapi'
+Description-Content-Type: text/markdown
+
+# Universal MCP
+Universal MCP acts as a middleware layer for your API applications, enabling seamless integration with various services through the Model Context Protocol (MCP). It simplifies credential management, authorization, and dynamic app enablement.
+
+## 🌟 Features
+
+- **MCP (Model Context Protocol) Integration**: Seamlessly works with MCP server architecture
+- **Simplified API Integration**: Connect to services like GitHub, Google Calendar, Gmail, Reddit, Tavily, and more with minimal code
+- **Managed Authentication**: Built-in support for API keys and OAuth-based authentication flows
+- **Extensible Architecture**: Easily build and add new app integrations with minimal boilerplate
+- **Credential Management**: Flexible storage options for API credentials with memory and environment-based implementations
+
+## 🔧 Installation
+
+Install Universal MCP using pip:
+
+```bash
+pip install universal-mcp
+```
+
+## 🚀 Quick Start
+
+**Important Prerequisite: AgentR API Key (If Using AgentR Integration)**
+
+If you plan to use integrations with `type: "agentr"` (for services like GitHub, Gmail, Notion via the AgentR platform), or if you run the server with `type: "agentr"`, you first need an AgentR API key:
+
+1.  Visit [https://agentr.dev](https://agentr.dev) to create an account and generate an API key from your dashboard.
+2.  Set it as an environment variable *before* running the MCP server:
+    ```bash
+    export AGENTR_API_KEY="your_api_key_here"
+    ```
+
+**1. Create a Configuration File (e.g., `config.json`)**
+
+This file defines the server settings, credential stores, and the applications to load with their respective integrations.
+
+```python
+{
+  "name": "My Local MCP Server",
+  "description": "A server for testing applications locally",
+  "type": "local",                  # Or "agentr" to load apps dynamically from AgentR
+  "transport": "sse",
+  "port": 8005,
+  "store": {
+    "name": "my_mcp_store",
+    "type": "keyring"
+  },
+  "apps": [
+    {
+      "name": "zenquotes",          # App slug
+      "integration": null           # No authentication needed
+    },
+    {
+      "name": "tavily",
+      "integration": {
+        "name": "TAVILY_API_KEY",   # Unique name for this credential
+        "type": "api_key",
+        "store": {
+          "type": "environment"
+        }
+      }
+    },
+    {
+      "name": "github",
+      "integration": {
+        "name": "github",          # Matches the service name in AgentR
+        "type": "agentr"           # Uses AgentR platform for auth/creds
+      }
+    }
+  ]
+}
+```
+
+*Notes:*
+*   `type: "local"` runs applications defined directly in the config's `apps` list.
+*   `type: "agentr"` connects to the AgentR platform to dynamically load user-enabled apps (ignores the `apps` list in the config) and handle credentials (requires `AGENTR_API_KEY` env var).
+*   `store`: Defines credential storage. `environment` looks for `<INTEGRATION_NAME_UPPERCASE>` env var (e.g., `TAVILY_API_KEY`). `keyring` uses the system's secure storage. `memory` is transient.
+*   `integration`: Configures authentication for each app when using `type: "local"`. `type: "agentr"` uses the AgentR platform for OAuth/credential management. `type: "api_key"` uses the specified `store`.
+
+**2. Run the Server via CLI**
+
+Make sure any required environment variables (like `TAVILY_API_KEY` for the example above, or `AGENTR_API_KEY` if using `"agentr"` type server/integrations) are set.
+
+```bash
+universal_mcp run -c config.json
+```
+
+The server will start, load the configured applications (or connect to AgentR if `type: "agentr"`), and listen for connections based on the `transport` type (`sse`, `stdio`, or `http`).
+
+## 🛠️ Using Playground
+
+The `playground` directory provides a runnable example with a FastAPI backend and a Streamlit frontend for interacting with the MCP server.
+
+**Prerequisites:**
+
+*   Ensure `local_config.json` exists in the project root directory. See `src/playground/README.md` for its format. This configures the *local* MCP server that the playground backend connects to.
+*   Install playground dependencies if needed (e.g., `fastapi`, `streamlit`, `uvicorn`, `langchain`, etc.).
+
+**Running the Playground:**
+
+The easiest way is to use the automated startup script from the **project root directory**:
+
+```bash
+python src/playground
+```
+Refer to `src/playground/README.md` for more detailed setup and usage instructions.
+
+## 🧩 Available Applications
+
+Universal MCP comes with several pre-built applications:
+
+| Application Slug | Description                              | Authentication Type                       |
+| :--------------- | :--------------------------------------- | :---------------------------------------- |
+| `e2b`            | Execute Python code in secure sandboxes  | API Key (via Integration)                 |
+| `firecrawl`      | Scrape/crawl web pages, search           | API Key (via Integration)                 |
+| `github`         | Interact with GitHub repos, issues, PRs  | OAuth (AgentR)                            |
+| `google-calendar`| Manage Google Calendar events            | OAuth (AgentR)                            |
+| `google-mail`    | Read and send Gmail emails               | OAuth (AgentR)                            |
+| `markitdown`     | Convert web pages/files to Markdown      | None                                      |
+| `notion`         | Interact with Notion pages/databases     | OAuth (AgentR)                            |
+| `reddit`         | Interact with Reddit posts/comments      | OAuth (AgentR)                            |
+| `resend`         | Send emails via Resend API               | API Key (via Integration)                 |
+| `serp`           | Perform web searches via SerpApi         | API Key (via Integration)                 |
+| `tavily`         | Advanced web search & research API       | API Key (via Integration)                 |
+| `zenquotes`      | Get inspirational quotes                 | None                                      |
+
+*Authentication Type notes:*
+*   *OAuth (AgentR)*: Typically requires configuring the integration with `type: "agentr"` in your `ServerConfig`. Requires the `AGENTR_API_KEY`.
+*   *API Key (via Integration)*: Requires configuring `type: "api_key"` and a `store` (like `environment` or `keyring`) in your `ServerConfig`.
+
+## 🔐 Integration Types
+
+Universal MCP supports different ways to handle authentication for applications:
+
+### 1. API Key Integration
+
+For services that authenticate via simple API keys. Configure using `IntegrationConfig` with `type: "api_key"`.
+
+```python
+{
+  "name": "tavily",
+  "integration": {
+    "name": "TAVILY_API_KEY",
+    "type": "api_key",
+    "store": {
+      "name": "universal_mcp",
+      "type": "environment"   # Or "keyring", "memory"
+       }
+    } 
+}
+```
+
+### 2. AgentR Integration
+
+For services integrated with the AgentR platform, typically handling OAuth flows or centrally managed credentials. Configure using `IntegrationConfig` with `type: "agentr"`. Requires the `AGENTR_API_KEY` environment variable to be set for the MCP server process.
+
+```python
+{
+  "name": "github",
+  "integration": {
+    "name": "github", # Matches the service name configured in AgentR
+    "type": "agentr"
+  }
+}
+```
+When an action requiring authorization is called, the `AgentRIntegration` will prompt the user (via the MCP client) to visit a URL to complete the OAuth flow managed by AgentR. This is also the default integration type when using `type: "agentr"` for the main server config.
+
+### 3. OAuth Integration (Direct - Less Common)
+
+While `AgentRIntegration` is preferred for OAuth, a direct `OAuthIntegration` class exists but requires manual configuration of client IDs, secrets, and handling callbacks, which is generally more complex to set up outside the AgentR platform.
+
+## 🤖 CLI Usage
+
+Universal MCP includes a command-line interface:
+
+```bash
+# Run the MCP server using a configuration file
+universal_mcp run -c config.json
+
+# Generate API client code and application structure from an OpenAPI schema
+# Output file name (e.g., 'twitter.py') determines app name ('twitter')
+universal_mcp generate --schema <path_to_schema.json/yaml> --output <path/to/output_app_name.py> [--no-docstrings]
+
+# Generate Google-style docstrings for functions in a Python file using an LLM
+universal_mcp docgen <path/to/file.py> [--model <model_name>] [--api-key <llm_api_key>]
+
+# Install MCP configuration for supported desktop apps (Claude, Cursor)
+# Requires AgentR API key for configuration.
+universal_mcp install claude
+universal_mcp install cursor
+
+# Check installed version (standard typer command)
+universal_mcp --version
+```
+
+## 📋 Requirements
+
+-   Python 3.11+
+-   Dependencies (installed automatically via pip):
+    -   `mcp-server`
+    -   `loguru`
+    -   `typer`
+    -   `httpx`
+    -   `pydantic`
+    -   `pyyaml`
+    -   `keyring` (optional, for `KeyringStore`)
+    -   `litellm` (optional, for `docgen` command)
+    -   ... and others specific to certain applications.
+
+## 📝 License
+
+This project is licensed under the MIT License.
+

{universal_mcp-0.1.2rc1.dist-info → universal_mcp-0.1.3rc1.dist-info}/RECORD

@@ -1,17 +1,22 @@
 universal_mcp/__init__.py,sha256=2gdHpHaDDcsRjZjJ01FLN-1iidN_wbDAolNpxhGoFB4,59
-universal_mcp/cli.py,sha256=rLdE1CRiouPIL2nBYv9EInOk_1uJfUBHmakWHBZ0roc,5555
+universal_mcp/cli.py,sha256=DG-Qxc5vQIdbhAIQuU7bKKJuRGzwyOigjfCKSWBRhBI,5258
 universal_mcp/config.py,sha256=9eb3DDg4PBBr1MlGeBrA4bja3Y6howOH-UKpo7JIbs8,828
 universal_mcp/exceptions.py,sha256=Zp2_v_m3L7GDAmD1ZyuwFtY6ngapdhxuIygrvpZAQtM,271
+universal_mcp/logger.py,sha256=KFRYc96RcyqiDVB8i0lTlVrHmXXB_C8on2QeZgrqBrw,2058
 universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 universal_mcp/applications/__init__.py,sha256=qeWnbdIudyMR7ST4XTc0gpEM9o6TsM1ZnZ92dMAPSBA,754
 universal_mcp/applications/application.py,sha256=dqp8lgIi2xhY62imwo7C6769URQtNmqd6Ok6PiTr6wc,3399
 universal_mcp/applications/e2b/app.py,sha256=5piCipi1TC_KuKLFP17do1Y1r28fqApvRsZy76equ9w,2573
-universal_mcp/applications/firecrawl/app.py,sha256=AOEQkaOpbkXeMtNdsPKmVQFd-4YHgjpjZy4j0ZvY9co,16831
+universal_mcp/applications/firecrawl/app.py,sha256=RSy8zRn4k1A1tIpJNqrUnPI8ctEv1nKWuOuJQcp9mGo,9264
 universal_mcp/applications/github/README.md,sha256=m_6FlPpx9l5y29TkFMewCXMXSRHriDtj71qyYYeFzCw,643
 universal_mcp/applications/github/app.py,sha256=L201f5MSx1YVx0nqgduZ5gyHPZdX0UfcEhPmDWiWK6s,13686
 universal_mcp/applications/google_calendar/app.py,sha256=g_3vrsM2ltwpTySgC5I4SYg47n4UJiYigECO0ax1EHM,19134
 universal_mcp/applications/google_mail/app.py,sha256=VXeD3_TRgYIUDFUzDPCKgR47XvovxLFulD-HG22hls8,22716
-universal_mcp/applications/markitdown/app.py,sha256=LV8cvkhmacsal-mJmKL9DH5BMypL9MGHIiCkhal6Jtg,1019
+universal_mcp/applications/markitdown/app.py,sha256=Gh12f1dW6DA_AW5DuStbCkOR7KtyJp8VEjdTaIicrRI,1996
+universal_mcp/applications/notion/README.md,sha256=45NmPOmSQv99qBvWdwmnV5vbaYc9_8vq8I-FA7veVAA,2600
+universal_mcp/applications/notion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/applications/notion/app.py,sha256=XpLnmeXj0Gnf_RYHlbAFnwtSCTYsrNzk6MSMSyDmHGQ,17283
+universal_mcp/applications/perplexity/app.py,sha256=J27IDcz9pRC_uW4wABpn-EcI4RvKIzoh_o2hzysM5wA,3187
 universal_mcp/applications/reddit/app.py,sha256=leU__w5VxX1vMK-kfuy-dvY97Pn8Mn80X2payVshirU,13562
 universal_mcp/applications/resend/app.py,sha256=bRo-CRDuk65EUSHOJnbVHWV6TuiUHtedz6FXKRS1ym0,1386
 universal_mcp/applications/serp/app.py,sha256=hPXu1sBiRZRCCzr4q2uvt54F0-B3aZK2Uz4wfKokkZ4,3131
@@ -20,18 +25,18 @@ universal_mcp/applications/zenquotes/app.py,sha256=nidRGwVORIU25QGCCbjDIv1UNFUj5
 universal_mcp/integrations/README.md,sha256=lTAPXO2nivcBe1q7JT6PRa6v9Ns_ZersQMIdw-nmwEA,996
 universal_mcp/integrations/__init__.py,sha256=8e11JZyctaR9CmlNkfEZ6HhGDvhlvf9iug2wdjb5pwY,270
 universal_mcp/integrations/agentr.py,sha256=l0mo79oeDML19udFfoCo9lyhbDAf0X94_lnpOgbTrb0,3331
-universal_mcp/integrations/integration.py,sha256=zMrSoubzdmJLYr-SKSDMBLWOwIG4-g0l5UEu3xmzsjY,5622
+universal_mcp/integrations/integration.py,sha256=8TYr7N1F6oV8PPOSLo0eA_6nD-vrwIWbuplqwD03uuQ,5819
 universal_mcp/servers/__init__.py,sha256=dgRW_khG537GeLKC5_U5jhxCuu1L_1YeTujeDg0601E,654
-universal_mcp/servers/server.py,sha256=tSbHfFVqsksMIrMcKDPiJdBZYhrpsx3QXyEuvBnUAU0,5893
+universal_mcp/servers/server.py,sha256=uHArnw_kYIhvlE-Zp5GharGqapGy4jaOlxRQGsOafPM,6431
 universal_mcp/stores/__init__.py,sha256=Sc4AWtee_qtK5hpEVUAH2XM_6EBhcfikQXWiGXdNfes,560
 universal_mcp/stores/store.py,sha256=CNOnmKeOCkSU2ZA9t12AIWJcmqZZX_LSyZaV8FQf8Xk,4545
 universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
 universal_mcp/utils/api_generator.py,sha256=-wRBpLVfJQXy1R-8FpDNs6b8_eeekVDuPc_uwjSGgiY,8883
 universal_mcp/utils/bridge.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-universal_mcp/utils/docgen.py,sha256=UUjiRcIeb96xbogF96Ujzw3Hdd5ExckOao5rzIpRsBQ,12651
-universal_mcp/utils/installation.py,sha256=nyuQDl8S6KftjukCOKE4vtiqSzpVO7M5U-W00ivp444,2939
-universal_mcp/utils/openapi.py,sha256=A719DaYc7AgN-n_uW868MBmpG_oPvuvMOgUCauInLeY,12629
-universal_mcp-0.1.2rc1.dist-info/METADATA,sha256=ImRyeQyPY4NxFMJTMCazXYeIoJGXQ_ra4o8Z7e8l-X0,5871
-universal_mcp-0.1.2rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp-0.1.2rc1.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
-universal_mcp-0.1.2rc1.dist-info/RECORD,,
+universal_mcp/utils/docgen.py,sha256=yK6Ijo8G-wHPU3E1AnFpnXS9vXt2j9FM77w0etTaNOA,12639
+universal_mcp/utils/installation.py,sha256=uSL_H76fG_7yN4QNxkfp1mEF_00iAPyiXqtdWEMVJe8,3747
+universal_mcp/utils/openapi.py,sha256=ud_ZB7_60BcS1Vao7ESKDqo0gry9JN5wzy-CFssrjm8,13140
+universal_mcp-0.1.3rc1.dist-info/METADATA,sha256=AO_09p7mP6jb2TuHbyvAWlrPFSxnbCl1tBcLOeNM_Us,10801
+universal_mcp-0.1.3rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.3rc1.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.3rc1.dist-info/RECORD,,