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

universal_mcp/applications/notion/README.md

@@ -0,0 +1,32 @@
+# Notion Tool
+
+This is automatically generated from OpenAPI schema for the Notion API.
+
+## Supported Integrations
+
+This tool can be integrated with any service that supports HTTP requests.
+
+## Tool List
+
+| Tool | Description |
+|------|-------------|
+| notion_retrieve_auser | Retrieves user information from the Notion API by user ID. |
+| notion_list_all_users | Fetches and returns a list of all users from the Notion API. |
+| notion_retrieve_your_token_sbot_user | Retrieves the current user's token data from the Notion API. |
+| notion_retrieve_adatabase | Retrieves a Notion database by its unique identifier. |
+| notion_update_adatabase | Updates a Notion database with the given ID and request body data. |
+| notion_query_adatabase | Executes a query on a Notion database using the Notion API. |
+| notion_create_adatabase | Creates a new database in Notion using the provided request body. |
+| notion_create_apage | Creates a new page in Notion by sending a POST request with the specified request body. |
+| notion_retrieve_apage | Retrieves a page from the Notion API using a given page ID. |
+| notion_update_page_properties | Updates the properties of a Notion page identified by a given ID. |
+| notion_retrieve_apage_property_item | Retrieves a specific property item from a page in Notion using the page and property IDs. |
+| notion_retrieve_block_children | Retrieves the child blocks of a specified Notion block. |
+| notion_append_block_children | Appends child blocks to a block in Notion using its API. |
+| notion_retrieve_ablock | Retrieves a block from the Notion API using the specified block ID. |
+| notion_delete_ablock | Deletes a block from the Notion database using the specified block ID. |
+| notion_update_ablock | Updates a block in Notion with the given ID and request body. |
+| notion_search | Executes a search request to the Notion API and returns the response in JSON format. |
+| notion_retrieve_comments | Retrieves comments from a Notion block using the Notion API. |
+| notion_add_comment_to_page | Adds a comment to a specified Notion page using the provided request body. |
+

universal_mcp/applications/notion/app.py

@@ -0,0 +1,415 @@
+from typing import Any
+
+from universal_mcp.applications import APIApplication
+from universal_mcp.integrations import Integration
+
+
+class NotionApp(APIApplication):
+    def __init__(self, integration: Integration = None, **kwargs) -> None:
+        """
+        Initializes a new instance of the class with given integration and additional options.
+        
+        Args:
+            integration: An optional Integration instance to configure the connection. Defaults to None.
+            **kwargs: Additional keyword arguments for configuration.
+        
+        Returns:
+            None
+        """
+        super().__init__(name='notion', integration=integration, **kwargs)
+        self.base_url = "https://api.notion.com"
+
+    def _get_headers(self):
+        if not self.integration:
+            raise ValueError("Integration not configured for NotionApp")
+        credentials = self.integration.get_credentials()
+        if "headers" in credentials:
+            return credentials["headers"]
+        return {
+            "Authorization": f"Bearer {credentials['access_token']}",
+            "Accept": "application/json",
+            "Notion-Version": "2022-06-28",
+        }    
+
+    def notion_retrieve_auser(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Retrieves user information from the Notion API by user ID.
+        
+        Args:
+            id: The unique identifier of the user whose information is to be retrieved.
+            request_body: A dictionary representing the request body, optional, default is None.
+        
+        Returns:
+            A dictionary containing the user's information from the Notion API.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/users/{id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_list_all_users(self, ) -> dict[str, Any]:
+        """
+        Fetches and returns a list of all users from the Notion API.
+        
+        Args:
+            None: This method does not take any parameters.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API, representing all users data.
+        """
+        url = f"{self.base_url}/v1/users"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_retrieve_your_token_sbot_user(self, ) -> dict[str, Any]:
+        """
+        Retrieves the current user's token data from the Notion API.
+        
+        Args:
+            self: Instance of the class containing the necessary configuration and authentication details for accessing the Notion API.
+        
+        Returns:
+            A dictionary containing the current user's token information as retrieved from the Notion API.
+        """
+        url = f"{self.base_url}/v1/users/me"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_retrieve_adatabase(self, id) -> dict[str, Any]:
+        """
+        Retrieves a Notion database by its unique identifier.
+        
+        Args:
+            id: A string representing the unique identifier of the Notion database to be retrieved.
+        
+        Returns:
+            A dictionary containing the details of the retrieved Notion database.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/databases/{id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_update_adatabase(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Updates a Notion database with the given ID and request body data.
+        
+        Args:
+            self: An instance of the class containing configuration and methods for HTTP requests.
+            id: A string representing the unique identifier of the Notion database to be updated.
+            request_body: An optional dictionary containing the fields and values to update in the database.
+        
+        Returns:
+            A dictionary representing the JSON response from the Notion API after updating the database.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/databases/{id}"
+        query_params = {}
+        response = self._patch(url, data={}, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_query_adatabase(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Executes a query on a Notion database using the Notion API.
+        
+        Args:
+            self: Instance of the class which should contain 'base_url' and '_post' method.
+            id: A string representing the unique identifier of the Notion database to query.
+            request_body: Optional. A dictionary representing the request body for the query. Defaults to None.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API after querying the specified database.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/databases/{id}/query"
+        query_params = {}
+        json_body = request_body if request_body is not None else None
+        response = self._post(url, data=json_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_create_adatabase(self, request_body=None) -> dict[str, Any]:
+        """
+        Creates a new database in Notion using the provided request body.
+        
+        Args:
+            self: Reference to the current instance of the class.
+            request_body: Optional dictionary containing the specifications for creating the Notion database. If None, a default empty request body is used.
+        
+        Returns:
+            A dictionary representing the JSON response from the Notion API, containing data about the newly created database.
+        """
+        url = f"{self.base_url}/v1/databases/"
+        query_params = {}
+        json_body = request_body if request_body is not None else None
+        response = self._post(url, data=json_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_create_apage(self, request_body=None) -> dict[str, Any]:
+        """
+        Creates a new page in Notion by sending a POST request with the specified request body.
+        
+        Args:
+            request_body: Optional; A dictionary containing the data to create a new page in Notion. Defaults to None.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API with the details of the newly created page.
+        """
+        url = f"{self.base_url}/v1/pages/"
+        query_params = {}
+        json_body = request_body if request_body is not None else None
+        response = self._post(url, data=json_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_retrieve_apage(self, id) -> dict[str, Any]:
+        """
+        Retrieves a page from the Notion API using a given page ID.
+        
+        Args:
+            id: The unique identifier of the Notion page to be retrieved.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API, representing the page data.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/pages/{id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_update_page_properties(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Updates the properties of a Notion page identified by a given ID.
+        
+        Args:
+            self: Instance of the class containing the Notion API credentials and methods.
+            id: The unique identifier of the Notion page to update. Must not be None.
+            request_body: An optional dictionary representing the request body to be sent with the update request. Defaults to None, indicating no additional properties to update.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API after the page update request.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/pages/{id}"
+        query_params = {}
+        response = self._patch(url, data={}, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_retrieve_apage_property_item(self, page_id, property_id) -> dict[str, Any]:
+        """
+        Retrieves a specific property item from a page in Notion using the page and property IDs.
+        
+        Args:
+            page_id: The unique identifier for the Notion page from which the property item should be retrieved.
+            property_id: The unique identifier for the property item within the specified page that should be retrieved.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API representing the requested property item.
+        """
+        if page_id is None:
+            raise ValueError("Missing required parameter 'page_id'")
+        if property_id is None:
+            raise ValueError("Missing required parameter 'property_id'")
+        url = f"{self.base_url}/v1/pages/{page_id}/properties/{property_id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_retrieve_block_children(self, id, page_size=None) -> dict[str, Any]:
+        """
+        Retrieves the child blocks of a specified Notion block.
+        
+        Args:
+            self: The instance of the class this method belongs to.
+            id: The unique identifier of the parent block whose children are to be retrieved.
+            page_size: Optional; the number of child blocks to retrieve per request.
+        
+        Returns:
+            A dictionary containing the JSON response with details about the child blocks.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}/children"
+        query_params = {k: v for k, v in [('page_size', page_size)] if v is not None}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_append_block_children(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Appends child blocks to a block in Notion using its API.
+        
+        Args:
+            self: Instance of the class containing Notion API credentials and configuration.
+            id: The unique identifier of the parent block to which child blocks are to be appended.
+            request_body: An optional dictionary containing the block data to append. Defaults to None.
+        
+        Returns:
+            A dictionary representing the response from the Notion API, containing the result of the append operation.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}/children"
+        query_params = {}
+        response = self._patch(url, data={}, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_retrieve_ablock(self, id) -> dict[str, Any]:
+        """
+        Retrieves a block from the Notion API using the specified block ID.
+        
+        Args:
+            id: The unique identifier of the block to retrieve from the Notion API. Must be a non-null string.
+        
+        Returns:
+            A dictionary containing the block data in JSON format as retrieved from the Notion API.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_delete_ablock(self, id) -> dict[str, Any]:
+        """
+        Deletes a block from the Notion database using the specified block ID.
+        
+        Args:
+            id: The unique identifier of the block to be deleted. Must not be None.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API after attempting to delete the block.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}"
+        query_params = {}
+        response = self._delete(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_update_ablock(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Updates a block in Notion with the given ID and request body.
+        
+        Args:
+            id: The unique identifier of the Notion block to update.
+            request_body: The request body containing the updates to be made to the block. Defaults to None if not provided.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API after the block has been updated.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}"
+        query_params = {}
+        response = self._patch(url, data={}, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_search(self, request_body=None) -> dict[str, Any]:
+        """
+        Executes a search request to the Notion API and returns the response in JSON format.
+        
+        Args:
+            request_body: An optional dictionary containing the search parameters for the API request. Defaults to None if not provided.
+        
+        Returns:
+            A dictionary containing the response from the Notion API in JSON format.
+        """
+        url = f"{self.base_url}/v1/search"
+        query_params = {}
+        json_body = request_body if request_body is not None else None
+        response = self._post(url, data=json_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_retrieve_comments(self, block_id=None, page_size=None, request_body=None) -> dict[str, Any]:
+        """
+        Retrieves comments from a Notion block using the Notion API.
+        
+        Args:
+            block_id: Optional; The ID of the block for which to retrieve comments. If None, it retrieves comments for all blocks available to the user.
+            page_size: Optional; The maximum number of comments to retrieve in one request. If None, the default page size will be used.
+            request_body: Optional; A dictionary to include additional parameters in the request body. If None, no extra parameters are added.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API with the comments retrieved.
+        """
+        url = f"{self.base_url}/v1/comments"
+        query_params = {k: v for k, v in [('block_id', block_id), ('page_size', page_size)] if v is not None}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_add_comment_to_page(self, request_body=None) -> dict[str, Any]:
+        """
+        Adds a comment to a specified Notion page using the provided request body.
+        
+        Args:
+            request_body: An optional dictionary containing the details of the comment to be added to the Notion page. If None, no data is sent in the request's body.
+        
+        Returns:
+            A dictionary containing the response data from the Notion API, parsed from JSON format.
+        """
+        url = f"{self.base_url}/v1/comments"
+        query_params = {}
+        json_body = request_body if request_body is not None else None
+        response = self._post(url, data=json_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def list_tools(self):
+        """
+        Returns a list of functions that interact with Notion's API for various operations.
+        
+        Args:
+            None: This method does not take any parameters.
+        
+        Returns:
+            A list of functions that perform specific operations with Notion's API, such as retrieving or updating users, databases, pages, blocks, and comments.
+        """
+        return [
+            self.notion_retrieve_auser,
+            self.notion_list_all_users,
+            self.notion_retrieve_your_token_sbot_user,
+            self.notion_retrieve_adatabase,
+            self.notion_update_adatabase,
+            self.notion_query_adatabase,
+            self.notion_create_adatabase,
+            self.notion_create_apage,
+            self.notion_retrieve_apage,
+            self.notion_update_page_properties,
+            self.notion_retrieve_apage_property_item,
+            self.notion_retrieve_block_children,
+            self.notion_append_block_children,
+            self.notion_retrieve_ablock,
+            self.notion_delete_ablock,
+            self.notion_update_ablock,
+            self.notion_search,
+            self.notion_retrieve_comments,
+            self.notion_add_comment_to_page
+        ]

universal_mcp/cli.py

@@ -66,7 +66,7 @@ def generate(
 def docgen(
     file_path: Path = typer.Argument(..., help="Path to the Python file to process"),
     model: str = typer.Option(
-        "anthropic/claude-3-sonnet-20240229",
+        "anthropic/claude-3-5-sonnet-20241022",
         "--model",
         "-m",
         help="Model to use for generating docstrings",

universal_mcp/utils/openapi.py

@@ -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"]
@@ -198,18 +201,28 @@ def generate_method_code(path, method, operation, tool_name=None):
         func_name = f"{tool_name}_{func_name}"
 
     # 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 +242,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 +257,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"]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.1rc1
+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
@@ -27,6 +27,7 @@ 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'

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

@@ -1,5 +1,5 @@
 universal_mcp/__init__.py,sha256=2gdHpHaDDcsRjZjJ01FLN-1iidN_wbDAolNpxhGoFB4,59
-universal_mcp/cli.py,sha256=rLdE1CRiouPIL2nBYv9EInOk_1uJfUBHmakWHBZ0roc,5555
+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
@@ -12,6 +12,9 @@ universal_mcp/applications/github/app.py,sha256=L201f5MSx1YVx0nqgduZ5gyHPZdX0Ufc
 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
@@ -30,8 +33,8 @@ universal_mcp/utils/api_generator.py,sha256=-wRBpLVfJQXy1R-8FpDNs6b8_eeekVDuPc_u
 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.1rc1.dist-info/METADATA,sha256=WzlkXc7fMZooD6COVYEDNBUCYQBFegz-YPMpEhxWhOo,5871
-universal_mcp-0.1.1rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp-0.1.1rc1.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
-universal_mcp-0.1.1rc1.dist-info/RECORD,,
+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,,