universal-mcp 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

universal_mcp/utils/openapi.py

@@ -1,210 +1,318 @@
 import json
-import yaml
 import re
 from pathlib import Path
+from typing import Any
+
+import yaml
 
 
 def convert_to_snake_case(identifier: str) -> str:
     """
     Convert a camelCase or PascalCase identifier to snake_case.
-    
+
     Args:
         identifier (str): The string to convert
-        
+
     Returns:
         str: The converted snake_case string
     """
     if not identifier:
         return identifier
     # Add underscore between lowercase and uppercase letters
-    result = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', identifier)
+    result = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", identifier)
     # Convert to lowercase
     return result.lower()
 
 
 def load_schema(path: Path):
-    if path.suffix == '.yaml':
-        type = 'yaml'
-    else:
-        type = 'json'
-    with open(path, 'r') as f:
-        if type == 'yaml':
+    type = "yaml" if path.suffix == ".yaml" else "json"
+    with open(path) as f:
+        if type == "yaml":
             return yaml.safe_load(f)
         else:
             return json.load(f)
 
 
+def determine_return_type(operation: dict[str, Any]) -> str:
+    """
+    Determine the return type from the response schema.
+
+    Args:
+        operation (dict): The operation details from the schema.
+
+    Returns:
+        str: The appropriate return type annotation (List[Any], Dict[str, Any], or Any)
+    """
+    responses = operation.get("responses", {})
+    # Find successful response (2XX)
+    success_response = None
+    for code in responses:
+        if code.startswith("2"):
+            success_response = responses[code]
+            break
+
+    if not success_response:
+        return "Any"  # Default to Any if no success response
+
+    # Check if there's content with schema
+    if "content" in success_response:
+        for content_type, content_info in success_response["content"].items():
+            if content_type.startswith("application/json") and "schema" in content_info:
+                schema = content_info["schema"]
+
+                # Only determine if it's a list, dict, or unknown (Any)
+                if schema.get("type") == "array":
+                    return "List[Any]"
+                elif schema.get("type") == "object" or "$ref" in schema:
+                    return "Dict[str, Any]"
+
+    # Default to Any if unable to determine
+    return "Any"
+
+
 def generate_api_client(schema):
     """
     Generate a Python API client class from an OpenAPI schema.
-    
+
     Args:
         schema (dict): The OpenAPI schema as a dictionary.
-    
+
     Returns:
         str: A string containing the Python code for the API client class.
     """
     methods = []
     method_names = []
-    
+
     # Extract API info for naming and base URL
-    info = schema.get('info', {})
-    api_title = info.get('title', 'API')
-    
+    info = schema.get("info", {})
+    api_title = info.get("title", "API")
+
     # Get base URL from servers array if available
     base_url = ""
-    servers = schema.get('servers', [])
-    if servers and isinstance(servers, list) and 'url' in servers[0]:
-        base_url = servers[0]['url'].rstrip('/')
-    
+    servers = schema.get("servers", [])
+    if servers and isinstance(servers, list) and "url" in servers[0]:
+        base_url = servers[0]["url"].rstrip("/")
+
     # Create a clean class name from API title
     if api_title:
         # Convert API title to a clean class name
         base_name = "".join(word.capitalize() for word in api_title.split())
-        clean_name = ''.join(c for c in base_name if c.isalnum())
+        clean_name = "".join(c for c in base_name if c.isalnum())
         class_name = f"{clean_name}App"
+
+        # Extract tool name - remove spaces and convert to lowercase
+        tool_name = api_title.lower()
+
+        # Remove version numbers (like 3.0, v1, etc.)
+        tool_name = re.sub(r"\s*v?\d+(\.\d+)*", "", tool_name)
+
+        # Remove common words that aren't needed
+        common_words = ["api", "openapi", "open", "swagger", "spec", "specification"]
+        for word in common_words:
+            tool_name = tool_name.replace(word, "")
+
+        # Remove spaces, hyphens, underscores
+        tool_name = tool_name.replace(" ", "").replace("-", "").replace("_", "")
+
+        # Remove any non-alphanumeric characters
+        tool_name = "".join(c for c in tool_name if c.isalnum())
+
+        # If empty (after cleaning), use generic name
+        if not tool_name:
+            tool_name = "api"
     else:
         class_name = "APIClient"
-    
+        tool_name = "api"
+
     # Iterate over paths and their operations
-    for path, path_info in schema.get('paths', {}).items():
+    for path, path_info in schema.get("paths", {}).items():
         for method in path_info:
-            if method in ['get', 'post', 'put', 'delete', 'patch', 'options', 'head']:
+            if method in ["get", "post", "put", "delete", "patch", "options", "head"]:
                 operation = path_info[method]
-                method_code, func_name = generate_method_code(path, method, operation)
+                method_code, func_name = generate_method_code(
+                    path, method, operation, tool_name
+                )
                 methods.append(method_code)
                 method_names.append(func_name)
-    
+
     # Generate list_tools method with all the function names
     tools_list = ",\n            ".join([f"self.{name}" for name in method_names])
     list_tools_method = f"""    def list_tools(self):
         return [
             {tools_list}
         ]"""
-    
+
     # Generate class imports
     imports = [
         "from universal_mcp.applications import APIApplication",
         "from universal_mcp.integrations import Integration",
-        "from typing import Any, Dict"
+        "from typing import Any, Dict, List",
     ]
-    
+
     # Construct the class code
     class_code = (
         "\n".join(imports) + "\n\n"
         f"class {class_name}(APIApplication):\n"
         f"    def __init__(self, integration: Integration = None, **kwargs) -> None:\n"
         f"        super().__init__(name='{class_name.lower()}', integration=integration, **kwargs)\n"
-        f"        self.base_url = \"{base_url}\"\n\n" +
-        '\n\n'.join(methods) + "\n\n" +
-        list_tools_method + "\n"
+        f'        self.base_url = "{base_url}"\n\n'
+        + "\n\n".join(methods)
+        + "\n\n"
+        + list_tools_method
+        + "\n"
     )
     return class_code
 
 
-def generate_method_code(path, method, operation):
+def generate_method_code(path, method, operation, tool_name=None):
     """
     Generate the code for a single API method.
-    
+
     Args:
         path (str): The API path (e.g., '/users/{user_id}').
         method (str): The HTTP method (e.g., 'get').
         operation (dict): The operation details from the schema.
-    
+        tool_name (str, optional): The name of the tool/app to prefix the function name with.
+
     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']
-        cleaned_name = raw_name.replace('.', '_').replace('-', '_')
+    if "operationId" in operation:
+        raw_name = operation["operationId"]
+        cleaned_name = raw_name.replace(".", "_").replace("-", "_")
         func_name = convert_to_snake_case(cleaned_name)
     else:
         # Generate name from path and method
-        path_parts = path.strip('/').split('/')
+        path_parts = path.strip("/").split("/")
         name_parts = [method]
         for part in path_parts:
-            if part.startswith('{') and part.endswith('}'):
-                name_parts.append('by_' + part[1:-1])
+            if part.startswith("{") and part.endswith("}"):
+                name_parts.append("by_" + part[1:-1])
             else:
                 name_parts.append(part)
-        func_name = '_'.join(name_parts).replace('-', '_').lower()
-    
+        func_name = "_".join(name_parts).replace("-", "_").lower()
+
+    # Add tool name prefix if provided
+    if tool_name:
+        func_name = f"{tool_name}_{func_name}"
+
     # Get parameters and request body
-    parameters = operation.get('parameters', [])
-    has_body = 'requestBody' in operation
-    body_required = has_body and operation['requestBody'].get('required', False)
-    
+    # 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
-    args = []
-    for param in parameters:
-        if param.get('required', False):
-            args.append(param['name'])
-        else:
-            args.append(f"{param['name']}=None")
+    required_args = []
+    optional_args = []
     
-    if has_body:
-        args.append('request_body' if body_required else 'request_body=None')
     
-    signature = f"    def {func_name}(self, {', '.join(args)}) -> Dict[str, Any]:"
+    for param_name in path_params_in_url:
+        if param_name not in required_args:
+            required_args.append(param_name)
+
     
+    for param in parameters:
+        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:
+        if body_required:
+            required_args.append("request_body")
+        else:
+            optional_args.append("request_body=None")
+
+    # Combine required and optional arguments
+    args = required_args + optional_args
+
+    # Determine return type
+    return_type = determine_return_type(operation)
+
+    signature = f"    def {func_name}(self, {', '.join(args)}) -> {return_type}:"
+
     # 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:")
-            body_lines.append(f"            raise ValueError(\"Missing required parameter '{param['name']}'\")")
-    
+
+    # 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}'\")"
+            )
+
     # Validate required body
     if has_body and body_required:
         body_lines.append("        if request_body is None:")
-        body_lines.append("            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)")
-    
+        body_lines.append(
+            '            raise ValueError("Missing required request body")'
+        )
+
+    # 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']
-    query_params_items = ', '.join([f"('{p['name']}', {p['name']})" for p in query_params])
-    body_lines.append(
-        f"        query_params = {{k: v for k, v in [{query_params_items}] if v is not None}}"
-    )
-    
+    query_params = [p for p in parameters if p["in"] == "query"]
+    if query_params:
+        query_params_items = ", ".join(
+            [f"('{p['name']}', {p['name']})" for p in query_params]
+        )
+        body_lines.append(
+            f"        query_params = {{k: v for k, v in [{query_params_items}] if v is not 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")
-    
+        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':
+    if method_lower == "get":
         body_lines.append("        response = self._get(url, params=query_params)")
-    elif method_lower == 'post':
+    elif method_lower == "post":
         if has_body:
-            body_lines.append("        response = self._post(url, data=json_body)")
+            body_lines.append(
+                "        response = self._post(url, data=json_body, params=query_params)"
+            )
         else:
-            body_lines.append("        response = self._post(url, data={})")
-    elif method_lower == 'put':
+            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)")
+            body_lines.append(
+                "        response = self._put(url, data=json_body, params=query_params)"
+            )
         else:
-            body_lines.append("        response = self._put(url, data={})")
-    elif method_lower == 'delete':
-        body_lines.append("        response = self._delete(url)")
+            body_lines.append(
+                "        response = self._put(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={{}})")
-    
+        body_lines.append(
+            f"        response = self._{method_lower}(url, data={{}}, params=query_params)"
+        )
+
     # Handle response
     body_lines.append("        response.raise_for_status()")
     body_lines.append("        return response.json()")
-    
-    method_code = signature + '\n' + '\n'.join(body_lines)
+
+    method_code = signature + "\n" + "\n".join(body_lines)
     return method_code, func_name
 
 
@@ -221,15 +329,17 @@ if __name__ == "__main__":
                             "name": "limit",
                             "in": "query",
                             "required": False,
-                            "schema": {"type": "integer"}
+                            "schema": {"type": "integer"},
                         }
                     ],
                     "responses": {
                         "200": {
                             "description": "A list of users",
-                            "content": {"application/json": {"schema": {"type": "array"}}}
+                            "content": {
+                                "application/json": {"schema": {"type": "array"}}
+                            },
                         }
-                    }
+                    },
                 },
                 "post": {
                     "summary": "Create a user",
@@ -239,15 +349,13 @@ if __name__ == "__main__":
                             "application/json": {
                                 "schema": {
                                     "type": "object",
-                                    "properties": {"name": {"type": "string"}}
+                                    "properties": {"name": {"type": "string"}},
                                 }
                             }
-                        }
+                        },
                     },
-                    "responses": {
-                        "201": {"description": "User created"}
-                    }
-                }
+                    "responses": {"201": {"description": "User created"}},
+                },
             },
             "/users/{user_id}": {
                 "get": {
@@ -257,18 +365,15 @@ if __name__ == "__main__":
                             "name": "user_id",
                             "in": "path",
                             "required": True,
-                            "schema": {"type": "string"}
+                            "schema": {"type": "string"},
                         }
                     ],
-                    "responses": {
-                        "200": {"description": "User details"}
-                    }
+                    "responses": {"200": {"description": "User details"}},
                 }
-            }
+            },
         }
     }
-    
 
-    schema = load_schema('openapi.yaml')
+    schema = load_schema("openapi.yaml")
     code = generate_api_client(schema)
-    print(code)
+    print(code)

{universal_mcp-0.1.1.dist-info → universal_mcp-0.1.2.dist-info}/METADATA

@@ -1,25 +1,39 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.1
+Version: 0.1.2
 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: pydantic-settings>=2.8.1
 Requires-Dist: pydantic>=2.11.1
 Requires-Dist: pyyaml>=6.0.2
 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: test
-Requires-Dist: pytest-asyncio>=0.26.0; extra == 'test'
-Requires-Dist: pytest>=8.3.5; extra == 'test'
+Provides-Extra: serpapi
+Requires-Dist: google-search-results>=2.4.2; extra == 'serpapi'
 Description-Content-Type: text/markdown
 
 # Universal MCP
@@ -166,7 +180,11 @@ AgentR includes a command-line interface for common operations:
 agentr version
 
 # Generate API client from OpenAPI schema
-agentr generate --schema path/to/openapi.yaml
+
+# Use the name of the API as the output filename (e.g., twitter, petstore, github)
+universal_mcp generate --schema petstore.json --output outputfilename
+
+# The tool will create src/universal_mcp/applications/petstore/ with app.py and README.md
 
 # Run the test server
 agentr run

universal_mcp-0.1.2.dist-info/RECORD

@@ -0,0 +1,40 @@
+universal_mcp/__init__.py,sha256=2gdHpHaDDcsRjZjJ01FLN-1iidN_wbDAolNpxhGoFB4,59
+universal_mcp/cli.py,sha256=7-8LZR9GiCW_iAz040XdgocCm6CvuJwBmKoZpFZDf-I,5557
+universal_mcp/config.py,sha256=9eb3DDg4PBBr1MlGeBrA4bja3Y6howOH-UKpo7JIbs8,828
+universal_mcp/exceptions.py,sha256=Zp2_v_m3L7GDAmD1ZyuwFtY6ngapdhxuIygrvpZAQtM,271
+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/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/notion/README.md,sha256=kmdjfXyoEQyk1UTP3zZiGYj2XdMcWieGjs0iscaQ028,2109
+universal_mcp/applications/notion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/applications/notion/app.py,sha256=OpoCbGyq3ieNMXHYxaZkqBfjvWRNUwEt3n1-Yj23AyY,17981
+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
+universal_mcp/applications/tavily/app.py,sha256=FSIRFz7jwm2i9wiDpRWIoQBxHaJ6dl89AjSZY9WP2VE,1776
+universal_mcp/applications/zenquotes/app.py,sha256=nidRGwVORIU25QGCCbjDIv1UNFUj5nWA3qqK4JP0Tdg,621
+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/servers/__init__.py,sha256=dgRW_khG537GeLKC5_U5jhxCuu1L_1YeTujeDg0601E,654
+universal_mcp/servers/server.py,sha256=tSbHfFVqsksMIrMcKDPiJdBZYhrpsx3QXyEuvBnUAU0,5893
+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=XhCqWI4pUWX9s_-WNPx03EBboe6CjYUaFip1OqZWRRQ,12926
+universal_mcp-0.1.2.dist-info/METADATA,sha256=fGQ1eC4wBti2_acIAMjXlQNmzQ26b8DIktE-uM5Ij6Q,5931
+universal_mcp-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.2.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.2.dist-info/RECORD,,

universal_mcp-0.1.1.dist-info/RECORD

@@ -1,29 +0,0 @@
-universal_mcp/__init__.py,sha256=2gdHpHaDDcsRjZjJ01FLN-1iidN_wbDAolNpxhGoFB4,59
-universal_mcp/cli.py,sha256=BmO-_huXXKvBsg0S3REPDNdu1YNmmSz5-fXlFceJyg4,2848
-universal_mcp/config.py,sha256=YTygfFJPUuL-epRuILvt5tc5ACzByWIFFNhpFwHlDCE,387
-universal_mcp/exceptions.py,sha256=cPpdoioDrtNXD6QvH_GKs7bcQ5XRfX8wTrklC4mLS2g,273
-universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-universal_mcp/applications/__init__.py,sha256=8X1y7kzqBRYsx7vP5jKSagyi4wa5hkbj6d8f8XanKU4,1132
-universal_mcp/applications/application.py,sha256=gHVR7jS0SusNiIm98yoy6RpR-uJsgnvYNa_6DanaPsY,3409
-universal_mcp/applications/github/app.py,sha256=yXVukXPvAtTAuwNRjo6VU_bt52Sp91P3-K7GUpa3jt4,14020
-universal_mcp/applications/google_calendar/app.py,sha256=tovWxCW6YM2DiXM7aEZyA7_u2w2IHlcGcvmj3NsQzyA,19897
-universal_mcp/applications/google_mail/app.py,sha256=AiTj3uv_fX5J9d5aoIj3zNfhq2y2FRqCfonw3DUuFiY,23745
-universal_mcp/applications/reddit/app.py,sha256=MaHjqgmkHEaJMh3UMvAx4J6HtWQyWA8kOglk699AnlY,13317
-universal_mcp/applications/resend/app.py,sha256=Zy702XAxjL4_X_JxHv-3gFfEFZznHdazgde-Z9102S8,1456
-universal_mcp/applications/tavily/app.py,sha256=d8mSUzvgzBA07WTzMLEKbFNwGpzEeVWGczJKnvu_2aQ,1833
-universal_mcp/applications/zenquotes/app.py,sha256=S86lTiIypXkDqx3kbc3Couk5L_7ejH-Qy-gLTLcCfwM,627
-universal_mcp/integrations/README.md,sha256=lTAPXO2nivcBe1q7JT6PRa6v9Ns_ZersQMIdw-nmwEA,996
-universal_mcp/integrations/__init__.py,sha256=frBUL7zHnCeukXLuGL8g2P8Rx7D_1TryJQFKKZE2mT4,252
-universal_mcp/integrations/agentr.py,sha256=wmac5vwMvftv8PWR54_42fYGlQloFejx76e-vxa597Q,3385
-universal_mcp/integrations/integration.py,sha256=R4yATIL6JcuPmFZQknQgWv9mb5eGIcpoismOx2VkKPs,4647
-universal_mcp/servers/__init__.py,sha256=IA9hGn0pebJx4hzTdcsRlH4rPD6BAeuw-7VG_WlRzFw,105
-universal_mcp/servers/server.py,sha256=vGnqdCd6AA1uh0G87GyfbCXuKqjR12gC2TDnGhFzFYU,5275
-universal_mcp/stores/__init__.py,sha256=2_qV1Np4GIrFPdH5CIKLeXEXn2b_ImoOTXmaEuHLc6g,135
-universal_mcp/stores/store.py,sha256=fB3uAaobnWf2ILcDBmg3ToDaqAIPYlLtmHBdpmkcGcI,1585
-universal_mcp/utils/bridge.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-universal_mcp/utils/installation.py,sha256=DXcl6voNn1Ihx717KIo2LBzFi_67ffDUxvPu8j0bMyY,2498
-universal_mcp/utils/openapi.py,sha256=YvDAUohGkcUf2j1-C9jXCF9DaM4ovnr2NlwejFRxGdI,9590
-universal_mcp-0.1.1.dist-info/METADATA,sha256=KFEK1nblKHpSOiRxmJEpbPHAIFzcaYF1vXCCVTlhJAc,5123
-universal_mcp-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp-0.1.1.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
-universal_mcp-0.1.1.dist-info/RECORD,,