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

universal_mcp/applications/__init__.py

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

universal_mcp/applications/application.py

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

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

universal_mcp/servers/server.py

@@ -4,7 +4,6 @@ from typing import Any
 import httpx
 from loguru import logger
 from mcp.server.fastmcp import FastMCP
-from mcp.server.fastmcp.server import MCPTool
 from mcp.types import TextContent
 from pydantic import ValidationError
 
@@ -203,23 +202,13 @@ class AgentRServer(BaseServer):
     """
 
     def __init__(self, config: ServerConfig, **kwargs):
-        # Initialize API key and client before calling super().__init__
+        super().__init__(config, **kwargs)
         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)
-        super().__init__(config, **kwargs)
-        self.integration = AgentRIntegration(name="agentr", api_key=self.api_key)
-        # Don't load apps in __init__ for stateless operation
-        self._apps_loaded = False
-
-    def _ensure_apps_loaded(self) -> None:
-        """Ensure apps are loaded, loading them if necessary."""
-        if not self._apps_loaded:
-            self._load_apps()
-            self._apps_loaded = True
+        self._load_apps()
 
     def _fetch_apps(self) -> list[AppConfig]:
         """Fetch available apps from AgentR API with retry logic.
@@ -256,7 +245,7 @@ class AgentRServer(BaseServer):
         """
         try:
             integration = (
-                AgentRIntegration(name=app_config.integration.name, api_key=self.client.api_key)
+                AgentRIntegration(name=app_config.integration.name, api_key=self.api_key)
                 if app_config.integration
                 else None
             )
@@ -292,16 +281,6 @@ class AgentRServer(BaseServer):
             # 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")
 
-    async def list_tools(self) -> list[MCPTool]:
-        """List available tools, ensuring apps are loaded first."""
-        self._ensure_apps_loaded()
-        return await super().list_tools()
-
-    async def call_tool(self, name: str, arguments: dict) -> list[TextContent]:
-        """Call a tool by name, ensuring apps are loaded first."""
-        self._ensure_apps_loaded()
-        return await super().call_tool(name, arguments)
-
 
 class SingleMCPServer(BaseServer):
     """

universal_mcp/tools/adapters.py

@@ -19,11 +19,14 @@ def convert_tool_to_mcp_tool(
 ):
     from mcp.server.fastmcp.server import MCPTool
 
-    return MCPTool(
+    logger.debug(f"Converting tool '{tool.name}' to MCP format")
+    mcp_tool = MCPTool(
         name=tool.name[:63],
         description=tool.description or "",
         inputSchema=tool.parameters,
     )
+    logger.debug(f"Successfully converted tool '{tool.name}' to MCP format")
+    return mcp_tool
 
 
 def format_to_mcp_result(result: any) -> list[TextContent]:
@@ -35,9 +38,12 @@ def format_to_mcp_result(result: any) -> list[TextContent]:
     Returns:
         List of TextContent objects
     """
+    logger.debug(f"Formatting result to MCP format, type: {type(result)}")
     if isinstance(result, str):
+        logger.debug("Result is string, wrapping in TextContent")
         return [TextContent(type="text", text=result)]
     elif isinstance(result, list) and all(isinstance(item, TextContent) for item in result):
+        logger.debug("Result is already list of TextContent objects")
         return result
     else:
         logger.warning(f"Tool returned unexpected type: {type(result)}. Wrapping in TextContent.")
@@ -60,26 +66,33 @@ def convert_tool_to_langchain_tool(
         a LangChain tool
     """
 
+    logger.debug(f"Converting tool '{tool.name}' to LangChain format")
+
     async def call_tool(
         **arguments: dict[str, any],
     ):
+        logger.debug(f"Executing LangChain tool '{tool.name}' with arguments: {arguments}")
         call_tool_result = await tool.run(arguments)
+        logger.debug(f"Tool '{tool.name}' execution completed")
         return call_tool_result
 
-    return StructuredTool(
+    langchain_tool = StructuredTool(
         name=tool.name,
         description=tool.description or "",
         coroutine=call_tool,
         response_format="content",
         args_schema=tool.parameters,
     )
+    logger.debug(f"Successfully converted tool '{tool.name}' to LangChain format")
+    return langchain_tool
 
 
 def convert_tool_to_openai_tool(
     tool: Tool,
 ):
     """Convert a Tool object to an OpenAI function."""
-    return {
+    logger.debug(f"Converting tool '{tool.name}' to OpenAI format")
+    openai_tool = {
         "type": "function",
         "function": {
             "name": tool.name,
@@ -87,3 +100,5 @@ def convert_tool_to_openai_tool(
             "parameters": tool.parameters,
         },
     }
+    logger.debug(f"Successfully converted tool '{tool.name}' to OpenAI format")
+    return openai_tool

universal_mcp/tools/func_metadata.py

@@ -14,6 +14,55 @@ from pydantic.fields import FieldInfo
 from pydantic_core import PydanticUndefined
 
 
+def _map_docstring_type_to_python_type(type_str: str | None) -> Any:
+    """Maps common docstring type strings to Python types."""
+    if not type_str:
+        return Any
+    type_str_lower = type_str.lower()
+    mapping = {
+        "str": str,
+        "string": str,
+        "int": int,
+        "integer": int,
+        "float": float,
+        "number": float,
+        "bool": bool,
+        "boolean": bool,
+        "list": list,
+        "array": list,
+        "dict": dict,
+        "object": dict,
+        "any": Any,
+    }
+    return mapping.get(type_str_lower, Any)
+
+
+def _map_docstring_type_to_schema_type(type_str: str | None) -> str:
+    """Maps common docstring type strings to JSON schema type strings."""
+    # This function might not be strictly needed if Pydantic correctly infers
+    # schema types from Python types, but kept for explicitness if used.
+    # The primary use-case now is for json_schema_extra for untyped Any.
+    if not type_str:
+        return "string"
+    type_str_lower = type_str.lower()
+    mapping = {
+        "str": "string",
+        "string": "string",
+        "int": "integer",
+        "integer": "integer",
+        "float": "number",
+        "number": "number",
+        "bool": "boolean",
+        "boolean": "boolean",
+        "list": "array",
+        "array": "array",
+        "dict": "object",
+        "object": "object",
+        "any": "string",
+    }
+    return mapping.get(type_str_lower, "string")
+
+
 def _get_typed_annotation(annotation: Any, globalns: dict[str, Any]) -> Any:
     def try_eval_type(value: Any, globalns: dict[str, Any], localns: dict[str, Any]) -> tuple[Any, bool]:
         try:
@@ -25,8 +74,6 @@ def _get_typed_annotation(annotation: Any, globalns: dict[str, Any]) -> Any:
         annotation = ForwardRef(annotation)
         annotation, status = try_eval_type(annotation, globalns, globalns)
 
-        # This check and raise could perhaps be skipped, and we (FastMCP) just call
-        # model_rebuild right before using it 🤷
         if status is False:
             raise InvalidSignature(f"Unable to evaluate type annotation {annotation}")
 
@@ -34,7 +81,6 @@ def _get_typed_annotation(annotation: Any, globalns: dict[str, Any]) -> Any:
 
 
 def _get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
-    """Get function signature while evaluating forward references"""
     signature = inspect.signature(call)
     globalns = getattr(call, "__globals__", {})
     typed_params = [
@@ -51,13 +97,7 @@ def _get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
 
 
 class ArgModelBase(BaseModel):
-    """A model representing the arguments to a function."""
-
     def model_dump_one_level(self) -> dict[str, Any]:
-        """Return a dict of the model's fields, one level deep.
-
-        That is, sub-models etc are not dumped - they are kept as pydantic models.
-        """
         kwargs: dict[str, Any] = {}
         for field_name in self.__class__.model_fields:
             kwargs[field_name] = getattr(self, field_name)
@@ -70,9 +110,6 @@ class ArgModelBase(BaseModel):
 
 class FuncMetadata(BaseModel):
     arg_model: Annotated[type[ArgModelBase], WithJsonSchema(None)]
-    # We can add things in the future like
-    #  - Maybe some args are excluded from attempting to parse from JSON
-    #  - Maybe some args are special (like context) for dependency injection
 
     async def call_fn_with_arg_validation(
         self,
@@ -82,11 +119,6 @@ class FuncMetadata(BaseModel):
         arguments_to_pass_directly: dict[str, Any] | None,
         context: dict[str, Any] | None = None,
     ) -> Any:
-        """Call the given function with arguments validated and injected.
-
-        Arguments are first attempted to be parsed from JSON, then validated against
-        the argument model, before being passed to the function.
-        """
         arguments_pre_parsed = self.pre_parse_json(arguments_to_validate)
         arguments_parsed_model = self.arg_model.model_validate(arguments_pre_parsed)
         arguments_parsed_dict = arguments_parsed_model.model_dump_one_level()
@@ -102,17 +134,7 @@ class FuncMetadata(BaseModel):
         raise TypeError("fn must be either Callable or Awaitable")
 
     def pre_parse_json(self, data: dict[str, Any]) -> dict[str, Any]:
-        """Pre-parse data from JSON.
-
-        Return a dict with same keys as input but with values parsed from JSON
-        if appropriate.
-
-        This is to handle cases like `["a", "b", "c"]` being passed in as JSON inside
-        a string rather than an actual list. Claude desktop is prone to this - in fact
-        it seems incapable of NOT doing this. For sub-models, it tends to pass
-        dicts (JSON objects) as JSON strings, which can be pre-parsed here.
-        """
-        new_data = data.copy()  # Shallow copy
+        new_data = data.copy()
         for field_name, _field_info in self.arg_model.model_fields.items():
             if field_name not in data:
                 continue
@@ -120,11 +142,8 @@ class FuncMetadata(BaseModel):
                 try:
                     pre_parsed = json.loads(data[field_name])
                 except json.JSONDecodeError:
-                    continue  # Not JSON - skip
+                    continue
                 if isinstance(pre_parsed, str | int | float):
-                    # This is likely that the raw value is e.g. `"hello"` which we
-                    # Should really be parsed as '"hello"' in Python - but if we parse
-                    # it as JSON it'll turn into just 'hello'. So we skip it.
                     continue
                 new_data[field_name] = pre_parsed
         assert new_data.keys() == data.keys()
@@ -139,73 +158,131 @@ class FuncMetadata(BaseModel):
         cls,
         func: Callable[..., Any],
         skip_names: Sequence[str] = (),
-        arg_description: dict[str, str] | None = None,
+        arg_description: dict[str, dict[str, str | None]] | None = None,
     ) -> "FuncMetadata":
-        """Given a function, return metadata including a pydantic model representing its
-        signature.
-
-        The use case for this is
-        ```
-        meta = func_to_pyd(func)
-        validated_args = meta.arg_model.model_validate(some_raw_data_dict)
-        return func(**validated_args.model_dump_one_level())
-        ```
-
-        **critically** it also provides pre-parse helper to attempt to parse things from
-        JSON.
-
-        Args:
-            func: The function to convert to a pydantic model
-            skip_names: A list of parameter names to skip. These will not be included in
-                the model.
-        Returns:
-            A pydantic model representing the function's signature.
-        """
         sig = _get_typed_signature(func)
         params = sig.parameters
         dynamic_pydantic_model_params: dict[str, Any] = {}
         globalns = getattr(func, "__globals__", {})
+        arg_description_map = arg_description or {}
+
         for param in params.values():
             if param.name.startswith("_"):
                 raise InvalidSignature(f"Parameter {param.name} of {func.__name__} cannot start with '_'")
             if param.name in skip_names:
                 continue
-            annotation = param.annotation
-
-            # `x: None` / `x: None = None`
-            if annotation is None:
-                annotation = Annotated[
-                    None,
-                    Field(default=param.default if param.default is not inspect.Parameter.empty else PydanticUndefined),
-                ]
-
-            # Untyped field
-            if annotation is inspect.Parameter.empty:
-                annotation = Annotated[
-                    Any,
-                    Field(),
-                    # 🤷
-                    WithJsonSchema({"title": param.name, "type": "string"}),
-                ]
-
-            field_info = FieldInfo.from_annotated_attribute(
-                _get_typed_annotation(annotation, globalns),
-                param.default if param.default is not inspect.Parameter.empty else PydanticUndefined,
-            )
-            if not field_info.title:
+
+            sig_annotation = param.annotation
+            default_val = param.default if param.default is not inspect.Parameter.empty else PydanticUndefined
+
+            param_doc_info = arg_description_map.get(param.name, {})
+            docstring_description = param_doc_info.get("description")
+            docstring_type_str = param_doc_info.get("type_str")
+
+            annotation_for_field_builder: Any
+
+            if sig_annotation is None:
+                annotation_for_field_builder = type(None)
+            elif sig_annotation is inspect.Parameter.empty:
+                py_type_from_doc = _map_docstring_type_to_python_type(docstring_type_str)
+
+                if py_type_from_doc is Any and not docstring_type_str:
+                    schema_type_for_any = _map_docstring_type_to_schema_type(docstring_type_str)
+                    annotation_for_field_builder = Annotated[
+                        Any, Field(json_schema_extra={"type": schema_type_for_any})
+                    ]
+                else:
+                    annotation_for_field_builder = py_type_from_doc
+            else:  # Parameter has a type hint in the signature
+                annotation_for_field_builder = _get_typed_annotation(sig_annotation, globalns)
+
+            field_info = FieldInfo.from_annotated_attribute(annotation_for_field_builder, default_val)
+
+            if field_info.description is None and docstring_description:
+                field_info.description = docstring_description
+
+            if field_info.title is None:
                 field_info.title = param.name
-            if not field_info.description and arg_description and arg_description.get(param.name):
-                field_info.description = arg_description.get(param.name)
-            dynamic_pydantic_model_params[param.name] = (
-                field_info.annotation,
-                field_info,
-            )
-            continue
+
+            core_type_for_model = field_info.annotation
+
+            dynamic_pydantic_model_params[param.name] = (core_type_for_model, field_info)
 
         arguments_model = create_model(
             f"{func.__name__}Arguments",
             **dynamic_pydantic_model_params,
             __base__=ArgModelBase,
         )
-        resp = FuncMetadata(arg_model=arguments_model)
-        return resp
+        return FuncMetadata(arg_model=arguments_model)
+
+
+if __name__ == "__main__":
+    import sys
+    from pathlib import Path
+
+    current_file = Path(__file__).resolve()
+    package_source_parent_dir = current_file.parent.parent.parent
+
+    if str(package_source_parent_dir) not in sys.path:
+        sys.path.insert(0, str(package_source_parent_dir))
+        print(f"DEBUG: Added to sys.path: {package_source_parent_dir}")
+
+    from universal_mcp.utils.docstring_parser import parse_docstring
+
+    def post_crm_v_objects_emails_create(self, associations, properties) -> dict[str, Any]:
+        """
+
+        Creates an email object in the CRM using the POST method, allowing for the association of metadata with the email and requiring authentication via OAuth2 or private apps to access the necessary permissions.
+
+        Args:
+            associations (array): associations Example: [{Category': 'HUBSPOT_DEFINED', 'associationTypeId': 2}]}].
+            properties (object): No description provided. Example: "{'ncy': 'monthly'}".
+
+        Returns:
+            dict[str, Any]: successful operation
+
+        Raises:
+            HTTPError: Raised when the API request fails (e.g., non-2XX status code).
+            JSONDecodeError: Raised if the response body cannot be parsed as JSON.
+
+        Tags:
+            Basic
+        """
+        request_body_data = None
+        request_body_data = {"associations": associations, "properties": properties}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
+        url = f"{self.main_app_client.base_url}/crm/v3/objects/emails"
+        query_params = {}
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
+        response.raise_for_status()
+        if response.status_code == 204 or not response.content or (not response.text.strip()):
+            return None
+        try:
+            return response.json()
+        except ValueError:
+            return None
+
+    print("--- Testing FuncMetadata with get_weather function ---")
+
+    raw_doc = inspect.getdoc(post_crm_v_objects_emails_create)
+    parsed_doc_info = parse_docstring(raw_doc)
+    arg_descriptions_from_doc = parsed_doc_info.get("args", {})  # Extract just the args part
+
+    print("\n1. Parsed Argument Descriptions from Docstring (for FuncMetadata input):")
+    print(json.dumps(arg_descriptions_from_doc, indent=2))
+
+    # 2. Create FuncMetadata instance
+    # The arg_description parameter expects a dict mapping arg name to its details
+    func_arg_metadata_instance = FuncMetadata.func_metadata(
+        post_crm_v_objects_emails_create, arg_description=arg_descriptions_from_doc
+    )
+
+    print("\n2. FuncMetadata Instance (its __repr__):")
+    print(func_arg_metadata_instance)
+
+    # 3. Get and print the JSON schema for the arguments model
+    parameters_schema = func_arg_metadata_instance.arg_model.model_json_schema()
+    print("\n3. Generated JSON Schema for Parameters (from arg_model.model_json_schema()):")
+    print(json.dumps(parameters_schema, indent=2))
+
+    print("\n--- Test Complete ---")

universal_mcp/tools/tools.py

@@ -53,11 +53,17 @@ class Tool(BaseModel):
         func_arg_metadata = FuncMetadata.func_metadata(fn, arg_description=parsed_doc["args"])
         parameters = func_arg_metadata.arg_model.model_json_schema()
 
+        simple_args_descriptions: dict[str, str] = {}
+        if parsed_doc.get("args"):
+            for arg_name, arg_details in parsed_doc["args"].items():
+                if isinstance(arg_details, dict):
+                    simple_args_descriptions[arg_name] = arg_details.get("description") or ""
+
         return cls(
             fn=fn,
-            name=func_name[:48],
+            name=func_name,
             description=parsed_doc["summary"],
-            args_description=parsed_doc["args"],
+            args_description=simple_args_descriptions,
             returns_description=parsed_doc["returns"],
             raises_description=parsed_doc["raises"],
             tags=parsed_doc["tags"],
@@ -79,8 +85,9 @@ class Tool(BaseModel):
         except NotAuthorizedError as e:
             message = f"Not authorized to call tool {self.name}: {e.message}"
             return message
-        except httpx.HTTPError as e:
-            message = f"HTTP error calling tool {self.name}: {str(e)}"
+        except httpx.HTTPStatusError as e:
+            error_body = e.response.text or "<empty response>"
+            message = f"HTTP {e.response.status_code}: {error_body}"
             raise ToolError(message) from e
         except ValueError as e:
             message = f"Invalid arguments for tool {self.name}: {e}"

universal_mcp/utils/agentr.py

@@ -1,3 +1,5 @@
+import os
+
 import httpx
 from loguru import logger
 
@@ -18,7 +20,9 @@ class AgentrClient:
 
     def __init__(self, api_key: str, base_url: str = "https://api.agentr.dev"):
         self.base_url = base_url.rstrip("/")
-        self.api_key = api_key
+        self.api_key = api_key or os.getenv("AGENTR_API_KEY")
+        if not self.api_key:
+            raise ValueError("No API key provided and AGENTR_API_KEY not found in environment variables")
         self.client = httpx.Client(
             base_url=self.base_url, headers={"X-API-KEY": self.api_key}, timeout=30, follow_redirects=True
         )
@@ -78,3 +82,27 @@ class AgentrClient:
         response.raise_for_status()
         data = response.json()
         return [AppConfig.model_validate(app) for app in data]
+
+    def list_all_apps(self) -> list:
+        """List all apps from AgentR API.
+
+        Returns:
+            List of app names
+        """
+        response = self.client.get("/apps/")
+        response.raise_for_status()
+        return response.json()
+
+    def list_actions(self, app_name: str):
+        """List actions for an app.
+
+        Args:
+            app_name (str): Name of the app to list actions for
+
+        Returns:
+            List of action configurations
+        """
+
+        response = self.client.get(f"/apps/{app_name}/actions/")
+        response.raise_for_status()
+        return response.json()

universal_mcp/utils/docstring_parser.py

@@ -9,7 +9,8 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
 
     Supports multi-line descriptions for each section. Recognizes common section
     headers like 'Args:', 'Returns:', 'Raises:', 'Tags:', etc. Also attempts
-    to parse key-value pairs within 'Args:' and 'Raises:' sections.
+    to parse key-value pairs within 'Args:' and 'Raises:' sections, including
+    type information for arguments if present in the docstring.
 
     Args:
         docstring: The docstring string to parse, or None.
@@ -17,7 +18,9 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
     Returns:
         A dictionary containing the parsed components:
         - 'summary': The first paragraph of the docstring.
-        - 'args': A dictionary mapping argument names to their descriptions.
+        - 'args': A dictionary mapping argument names to their details,
+                  including 'description' and 'type_str' (if found).
+                  Example: {"param_name": {"description": "desc...", "type_str": "str"}}
         - 'returns': The description of the return value.
         - 'raises': A dictionary mapping exception types to their descriptions.
         - 'tags': A list of strings found in the 'Tags:' section.
@@ -31,7 +34,7 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
 
     summary: str = ""
     summary_lines: list[str] = []
-    args: dict[str, str] = {}
+    args: dict[str, dict[str, str | None]] = {}
     returns: str = ""
     raises: dict[str, str] = {}
     tags: list[str] = []
@@ -39,17 +42,20 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
     current_section: str | None = None
     current_key: str | None = None
     current_desc_lines: list[str] = []
+    current_arg_type_str: str | None = None
 
-    key_pattern = re.compile(r"^\s*([\w\.]+)\s*(?:\(.*\))?:\s*(.*)")
+    key_pattern = re.compile(r"^\s*([\w\.]+)\s*(?:\((.*?)\))?:\s*(.*)")
 
     def finalize_current_item():
-        """Processes the collected current_desc_lines and assigns them."""
-        nonlocal returns, tags, args, raises
+        nonlocal returns, tags, args, raises, current_arg_type_str
         desc = " ".join(current_desc_lines).strip()
 
         if current_section == "args" and current_key:
-            if desc:
-                args[current_key] = desc
+            if desc or current_arg_type_str:
+                args[current_key] = {
+                    "description": desc,
+                    "type_str": current_arg_type_str,
+                }
         elif current_section == "raises" and current_key:
             if desc:
                 raises[current_key] = desc
@@ -61,7 +67,6 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
             tags.extend([tag.strip() for tag in desc.split(",") if tag.strip()])
 
     def check_for_section_header(line: str) -> tuple[bool, str | None, str]:
-        """Checks if a line is a recognized section header."""
         stripped_lower = line.strip().lower()
         section_type: str | None = None
         header_content = ""
@@ -79,12 +84,11 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
             parts = re.split(r"[:\s]+", line.strip(), maxsplit=1)
             if len(parts) > 1:
                 header_content = parts[1].strip()
-        elif stripped_lower.startswith(("tags",)):
+        elif stripped_lower.startswith(("tags",)):  # Match "tags" without colon for header content
             section_type = "tags"
             parts = re.split(r"[:\s]+", line.strip(), maxsplit=1)
             if len(parts) > 1:
                 header_content = parts[1].strip()
-
         elif stripped_lower.endswith(":") and stripped_lower[:-1] in (
             "attributes",
             "see also",
@@ -97,7 +101,6 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
             "warnings",
         ):
             section_type = "other"
-
         return section_type is not None, section_type, header_content
 
     in_summary = True
@@ -113,10 +116,8 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
                 in_summary = False
                 summary = " ".join(summary_lines).strip()
                 summary_lines = []
-
                 if not stripped_line:
                     continue
-
             else:
                 summary_lines.append(stripped_line)
                 continue
@@ -133,27 +134,15 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
                 current_section in ["returns", "tags", "other"]
                 and current_desc_lines
                 and original_indentation == 0
-                and stripped_line
+                and stripped_line  # Ensure it's not an empty unindented line (handled by rule 2)
             )
         ):
             should_finalize_previous = True
-        elif (
-            current_section in ["args", "raises"]
-            and current_key is not None
-            or current_section in ["returns", "tags", "other"]
-            and current_desc_lines
-        ):
-            pass
 
         if should_finalize_previous:
             finalize_current_item()
-            if is_new_section_header or (
-                current_section in ["args", "raises"]
-                and current_key is not None
-                and not key_pattern.match(line)
-                and (not stripped_line or original_indentation == 0)
-            ):
-                current_key = None
+            current_key = None
+            current_arg_type_str = None
             current_desc_lines = []
 
         if is_new_section_header:
@@ -169,15 +158,14 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
             match = key_pattern.match(line)
             if match:
                 current_key = match.group(1)
-                current_desc_lines = [match.group(2).strip()]
-            elif current_key is not None:
+                current_arg_type_str = match.group(2).strip() if match.group(2) else None
+                current_desc_lines = [match.group(3).strip()]  # Start new description
+            elif current_key is not None:  # Continuation line for an existing key
                 current_desc_lines.append(stripped_line)
-
         elif current_section in ["returns", "tags", "other"]:
             current_desc_lines.append(stripped_line)
 
-    finalize_current_item()
-
+    finalize_current_item()  # Finalize any pending item at the end of the docstring
     if in_summary:
         summary = " ".join(summary_lines).strip()
 
@@ -191,29 +179,23 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
 
 
 docstring_example = """
-    Starts a crawl job for a given URL using Firecrawl.
-Returns the job ID immediately.
+Creates a new product in the CRM product library to manage the collection of goods and services offered by the company.
 
-    Args:
-        url: The starting URL for the crawl.
-                It can be a very long url that spans multiple lines if needed.
-        params: Optional dictionary of parameters to customize the crawl.
-                See API docs for details.
-        idempotency_key: Optional unique key to prevent duplicate jobs.
+Args:
+    associations (array): associations
+    properties (object): No description provided. Example: "{'description': 'Onboarding service for data product', 'name': '1 year implementation consultation', 'price': '6000.00', 'hs_sku': '191902', 'hs_cost_of_goods_sold': '600.00', 'hs_recurring_billing_period': 'P24M', 'city': 'Cambridge', 'phone': '(877) 929-0687', 'state': 'Massachusetts', 'domain': 'biglytics.net', 'industry': 'Technology', 'amount': '1500.00', 'dealname': 'Custom data integrations', 'pipeline': 'default', 'closedate': '2019-12-07T16:50:06.678Z', 'dealstage': 'presentationscheduled', 'hubspot_owner_id': '910901', 'email': 'bcooper@biglytics.net', 'company': 'Biglytics', 'website': 'biglytics.net', 'lastname': 'Cooper', 'firstname': 'Bryan', 'subject': 'troubleshoot report', 'hs_pipeline': 'support_pipeline', 'hs_pipeline_stage': 'open', 'hs_ticket_priority': 'HIGH', 'quantity': '2', 'hs_product_id': '191902', 'recurringbillingfrequency': 'monthly'}".
 
-    Returns:
-        A dictionary containing the job initiation response on success,
-        or a string containing an error message on failure. This description
-        can also span multiple lines.
+Returns:
+    dict[str, Any]: successful operation
 
 Raises:
-        ValueError: If the URL is invalid.
-        ConnectionError: If connection fails.
+    HTTPError: Raised when the API request fails (e.g., non-2XX status code).
+    JSONDecodeError: Raised if the response body cannot be parsed as JSON.
 
-    Tags:
-        crawl, async_job, start, api,  long_tag_example , another
-        , final_tag
-    """
+Tags:
+    Basic, Another Tag
+    Yet Another Tag
+"""
 
 if __name__ == "__main__":
     import json

universal_mcp/utils/openapi/api_splitter.py

@@ -26,6 +26,21 @@ 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 _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)
 """
 
 

universal_mcp/utils/openapi/openapi.py

@@ -149,7 +149,9 @@ def _sanitize_identifier(name: str | None) -> str:
         return ""
 
     # Initial replacements for common non-alphanumeric characters
-    sanitized = name.replace("-", "_").replace(".", "_").replace("[", "_").replace("]", "").replace("$", "_")
+    sanitized = (
+        name.replace("-", "_").replace(".", "_").replace("[", "_").replace("]", "").replace("$", "_").replace("/", "_")
+    )
 
     # Remove leading underscores, but preserve a single underscore if the name (after initial replace)
     # consisted only of underscores.
@@ -845,8 +847,7 @@ def _generate_method_code(path, method, operation):
 
     raises_section_lines = [
         "Raises:",
-        "    HTTPError: Raised when the API request fails (e.g., non-2XX status code).",
-        "    JSONDecodeError: Raised if the response body cannot be parsed as JSON.",
+        "    HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.",
     ]
     docstring_parts.append("\n".join(raises_section_lines))
 
@@ -967,42 +968,36 @@ def _generate_method_code(path, method, operation):
     # --- Make HTTP Request ---
     # This section generates the actual HTTP call
     # using the prepared URL, query parameters, request body data, files, and content type.
+    # Use convenience methods that automatically handle responses and errors
 
     if method_lower == "get":
-        body_lines.append("        response = self._get(url, params=query_params)")
+        body_lines.append("        return self._get_json(url, params=query_params)")
     elif method_lower == "post":
         if selected_content_type == "multipart/form-data":
             body_lines.append(
-                f"        response = self._post(url, data=request_body_data, files=files_data, params=query_params, content_type='{final_content_type_for_api_call}')"
+                f"        return self._post_json(url, data=request_body_data, files=files_data, params=query_params, content_type='{final_content_type_for_api_call}')"
             )
         else:
             body_lines.append(
-                f"        response = self._post(url, data=request_body_data, params=query_params, content_type='{final_content_type_for_api_call}')"
+                f"        return self._post_json(url, data=request_body_data, params=query_params, content_type='{final_content_type_for_api_call}')"
             )
     elif method_lower == "put":
         if selected_content_type == "multipart/form-data":
             body_lines.append(
-                f"        response = self._put(url, data=request_body_data, files=files_data, params=query_params, content_type='{final_content_type_for_api_call}')"
+                f"        return self._put_json(url, data=request_body_data, files=files_data, params=query_params, content_type='{final_content_type_for_api_call}')"
             )
         else:
             body_lines.append(
-                f"        response = self._put(url, data=request_body_data, params=query_params, content_type='{final_content_type_for_api_call}')"
+                f"        return self._put_json(url, data=request_body_data, params=query_params, content_type='{final_content_type_for_api_call}')"
             )
     elif method_lower == "patch":
-        body_lines.append("        response = self._patch(url, data=request_body_data, params=query_params)")
+        body_lines.append("        return self._patch_json(url, data=request_body_data, params=query_params)")
     elif method_lower == "delete":
-        body_lines.append("        response = self._delete(url, params=query_params)")
+        body_lines.append("        return self._delete_json(url, params=query_params)")
     else:
-        body_lines.append(f"        response = self._{method_lower}(url, data=request_body_data, params=query_params)")
-
-    # --- Handle Response ---
-    body_lines.append("        response.raise_for_status()")
-    body_lines.append("        if response.status_code == 204 or not response.content or not response.text.strip():")
-    body_lines.append("            return None")
-    body_lines.append("        try:")
-    body_lines.append("            return response.json()")
-    body_lines.append("        except ValueError:")
-    body_lines.append("            return None")
+        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
 
     # --- Combine Signature, Docstring, and Body for Final Method Code ---
     method_code = signature + formatted_docstring + "\n" + "\n".join(body_lines)

universal_mcp/utils/testing.py

@@ -0,0 +1,31 @@
+from loguru import logger
+
+from universal_mcp.tools.tools import Tool
+
+
+def check_application_instance(app_instance, app_name):
+    assert app_instance is not None, f"Application object is None for {app_name}"
+    assert (
+        app_instance.name == app_name
+    ), f"Application instance name '{app_instance.name}' does not match expected name '{app_name}'"
+
+    tools = app_instance.list_tools()
+    logger.info(f"Tools for {app_name}: {len(tools)}")
+    assert len(tools) > 0, f"No tools found for {app_name}"
+
+    tools = [Tool.from_function(tool) for tool in tools]
+    seen_names = set()
+    important_tools = []
+
+    for tool in tools:
+        assert tool.name is not None, f"Tool name is None for a tool in {app_name}"
+        assert (
+            0 < len(tool.name) <= 48
+        ), f"Tool name '{tool.name}' for {app_name} has invalid length (must be between 1 and 47 characters)"
+        assert tool.description is not None, f"Tool description is None for tool '{tool.name}' in {app_name}"
+        # assert 0 < len(tool.description) <= 255, f"Tool description for '{tool.name}' in {app_name} has invalid length (must be between 1 and 255 characters)"
+        assert tool.name not in seen_names, f"Duplicate tool name: '{tool.name}' found for {app_name}"
+        seen_names.add(tool.name)
+        if "important" in tool.tags:
+            important_tools.append(tool.name)
+    assert len(important_tools) > 0, f"No important tools found for {app_name}"

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

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

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

@@ -6,40 +6,41 @@ universal_mcp/exceptions.py,sha256=-pbeZhpNieJfnSd2-WM80pU8W8mK8VHXcSjky0BHwdk,6
 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=No_tptWkYFcbE6Z3tMEpqUbpHXlaCOa8__yqWB5sTjY,3360
-universal_mcp/applications/application.py,sha256=3cQ5BVWmC2gU4fgpM5wZ3ByTe7iGbQriNPVSWxclaiU,17744
+universal_mcp/applications/__init__.py,sha256=l19_sMs5766VFWU_7O2niamvvvfQOteysqylbqvjjGQ,3500
+universal_mcp/applications/application.py,sha256=-5uHUJORRjRnOwDbqJO4qSJLrFSGRghaUWOKMqhN5vo,22891
 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=uKucut4AKTN2M-K8Aqsm2qtchLqlQRWMU8L287X7VyQ,13043
+universal_mcp/integrations/integration.py,sha256=2Wv9g5fJ4cbsTNsp4WcFNKdQCnj6rbBhgNQgMDAQ1Os,13057
 universal_mcp/servers/README.md,sha256=ytFlgp8-LO0oogMrHkMOp8SvFTwgsKgv7XhBVZGNTbM,2284
 universal_mcp/servers/__init__.py,sha256=eBZCsaZjiEv6ZlRRslPKgurQxmpHLQyiXv2fTBygHnM,532
-universal_mcp/servers/server.py,sha256=7IiivuINr1CjZ6gX8xMgsoTHOevbiHa9U1pUDJGNRIE,13251
+universal_mcp/servers/server.py,sha256=K7sPdCixYgJmQRxOL1icscL7-52sVsghpRX_D_uREu4,12329
 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=n06Nz18L_4dq3iwBchNq9vHsX7whqFZ0g5iuz_0gyaM,2076
-universal_mcp/tools/func_metadata.py,sha256=XvdXSZEzvgbH70bc-Zu0B47CD7f_rm--vblq4en3n0Q,8181
+universal_mcp/tools/adapters.py,sha256=nMoZ9jnv1uKhfq6NmBJ5-a6uwdB_H8RqkdNLIacCRfM,2978
+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=qiuuLe0mCWtxXp6E5ISDDaNojCrMLfV1r5L8peFoJfg,3327
+universal_mcp/tools/tools.py,sha256=8S_KzARYbG9xbyqhZcI4Wk46tXiZcWlcAMgjChXNEI4,3698
 universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
-universal_mcp/utils/agentr.py,sha256=a7D3I4oKvdovoumeSdChhHBcZNrEtKHHb4L4O8Gm_l0,2870
+universal_mcp/utils/agentr.py,sha256=-brwvgCZgPjvF7wPXw0QfpEsl1ekXQxmcF07-1AQMR4,3663
 universal_mcp/utils/common.py,sha256=HEZC2Mhilb8DrGXQG2tboAIw1r4veGilGWjfnPF1lyA,888
-universal_mcp/utils/docstring_parser.py,sha256=SKIfAiFHiqxqageayYFlpsexipy8tN7N4RLT6GIzfoQ,7672
+universal_mcp/utils/docstring_parser.py,sha256=efEOE-ME7G5Jbbzpn7pN2xNuyu2M5zfZ1Tqu1lRB0Gk,8392
 universal_mcp/utils/installation.py,sha256=ItOfBFhKOh4DLz237jgAz_Fn0uOMdrKXw0n5BaUZZNs,7286
 universal_mcp/utils/singleton.py,sha256=kolHnbS9yd5C7z-tzaUAD16GgI-thqJXysNi3sZM4No,733
+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=S-rT3wsJWUVhU_Tv_ibNNAlQ79SfWOcU6qaa_rFfd5o,20806
+universal_mcp/utils/openapi/api_splitter.py,sha256=hED34exwKcBtKzkz-3jVWzNeFBNGgjxANQeu1FibuOU,21818
 universal_mcp/utils/openapi/docgen.py,sha256=DNmwlhg_-TRrHa74epyErMTRjV2nutfCQ7seb_Rq5hE,21366
-universal_mcp/utils/openapi/openapi.py,sha256=3DWpxVZk9LGGDLrpE7BfSjurd_FJg30oWUiaEv3wjm0,51105
+universal_mcp/utils/openapi/openapi.py,sha256=tUD3HNLGAF808AszHLGGKPqpqLT-PZB_8LwagyvsWKQ,50828
 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.22rc1.dist-info/METADATA,sha256=VAB3kMzP5KOKpWoBC12I7i3gW2JmSJLvx92Go9qINv8,12154
-universal_mcp-0.1.22rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp-0.1.22rc1.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
-universal_mcp-0.1.22rc1.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
-universal_mcp-0.1.22rc1.dist-info/RECORD,,
+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,,