universal-mcp 0.1.20rc1__tar.gz → 0.1.21rc2__tar.gz

{universal_mcp-0.1.20rc1 → universal_mcp-0.1.21rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.20rc1
+Version: 0.1.21rc2
 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.20rc1 → universal_mcp-0.1.21rc2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp"
-version = "0.1.20-rc1"
+version = "0.1.21-rc2"
 description = "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."
 readme = "README.md"
 authors = [

{universal_mcp-0.1.20rc1 → universal_mcp-0.1.21rc2}/src/tests/test_tool.py

@@ -18,7 +18,7 @@ def test_func_metadata_annotated():
         "title": "funcArguments",
         "properties": {
             "a": {"type": "integer", "title": "First integer"},
-            "b": {"type": "integer", "title": "B"},
+            "b": {"type": "integer", "title": "b"},
         },
         "required": ["a", "b"],
     }
@@ -40,8 +40,8 @@ def test_func_metadata_no_annotated():
         "type": "object",
         "title": "funcArguments",
         "properties": {
-            "a": {"type": "integer", "title": "The first integer"},
-            "b": {"type": "integer", "title": "The second integer"},
+            "a": {"type": "integer", "description": "The first integer", "title": "a"},
+            "b": {"type": "integer", "description": "The second integer", "title": "b"},
         },
         "required": ["a", "b"],
     }
@@ -57,7 +57,6 @@ def test_func_metadata_no_args():
         "type": "object",
         "title": "funcArguments",
         "properties": {},
-        # "required": [],
     }
 
 
@@ -88,9 +87,9 @@ def test_func_metadata_required():
         "type": "object",
         "title": "funcArguments",
         "properties": {
-            "a": {"type": "integer", "title": "A"},
-            "b": {"type": "string", "title": "B"},
-            "c": {"type": "number", "title": "C", "default": 1.0},
+            "a": {"type": "integer", "title": "a"},
+            "b": {"type": "string", "title": "b"},
+            "c": {"type": "number", "title": "c", "default": 1.0},
         },
         "required": ["a", "b"],
     }
@@ -106,7 +105,7 @@ def test_func_metadata_none_type():
         "type": "object",
         "title": "funcArguments",
         "properties": {
-            "a": {"type": "null", "title": "A", "default": None},
+            "a": {"type": "null", "title": "a", "default": None},
         },
     }
 

{universal_mcp-0.1.20rc1 → universal_mcp-0.1.21rc2}/src/universal_mcp/servers/server.py

@@ -13,6 +13,7 @@ from universal_mcp.exceptions import ConfigurationError, ToolError
 from universal_mcp.integrations import AgentRIntegration, integration_from_config
 from universal_mcp.stores import BaseStore, store_from_config
 from universal_mcp.tools import ToolManager
+from universal_mcp.tools.adapters import ToolFormat
 from universal_mcp.utils.agentr import AgentrClient
 
 
@@ -56,7 +57,7 @@ class BaseServer(FastMCP):
         Returns:
             List of tool definitions
         """
-        return self._tool_manager.list_tools(format="mcp")
+        return self._tool_manager.list_tools(format=ToolFormat.MCP)
 
     def _format_tool_result(self, result: Any) -> list[TextContent]:
         """Format tool result into TextContent list.

{universal_mcp-0.1.20rc1 → universal_mcp-0.1.21rc2}/src/universal_mcp/tools/adapters.py

@@ -17,7 +17,7 @@ def convert_tool_to_mcp_tool(
     from mcp.server.fastmcp.server import MCPTool
 
     return MCPTool(
-        name=tool.name,
+        name=tool.name[:63],
         description=tool.description or "",
         inputSchema=tool.parameters,
     )

{universal_mcp-0.1.20rc1 → universal_mcp-0.1.21rc2}/src/universal_mcp/tools/func_metadata.py

@@ -192,8 +192,10 @@ class FuncMetadata(BaseModel):
                 _get_typed_annotation(annotation, globalns),
                 param.default if param.default is not inspect.Parameter.empty else PydanticUndefined,
             )
-            if not field_info.title and arg_description and arg_description.get(param.name):
-                field_info.title = arg_description.get(param.name)
+            if not field_info.title:
+                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,

{universal_mcp-0.1.20rc1 → universal_mcp-0.1.21rc2}/src/universal_mcp/utils/openapi/openapi.py

@@ -19,6 +19,7 @@ class Parameters(BaseModel):
     required: bool
     example: str | None = None
     is_file: bool = False
+    schema: dict = {}
 
     def __str__(self):
         return f"{self.name}: ({self.type})"
@@ -79,6 +80,61 @@ def convert_to_snake_case(identifier: str) -> str:
     return result.strip("_").lower()
 
 
+# Added new recursive type mapper
+def _openapi_type_to_python_type(schema: dict, required: bool = True) -> str:
+    """
+    Recursively map OpenAPI schema to Python type hints.
+    """
+    openapi_type = schema.get("type")
+
+    
+    if "$ref" in schema and not openapi_type: 
+        py_type = "dict[str, Any]" 
+    elif openapi_type == "array":
+        items_schema = schema.get("items", {})
+        item_type = _openapi_type_to_python_type(items_schema, required=True) 
+        py_type = f"List[{item_type}]"
+    elif openapi_type == "object":
+        
+        if schema.get("format") in ["binary", "byte"]:
+             py_type = "bytes"
+        else:
+            
+            if "additionalProperties" in schema and isinstance(schema["additionalProperties"], dict):
+                additional_props_schema = schema["additionalProperties"]
+            
+                value_type = _openapi_type_to_python_type(additional_props_schema, required=True)
+                py_type = f"dict[str, {value_type}]"
+            elif not schema.get("properties") and not schema.get("allOf") and not schema.get("oneOf") and not schema.get("anyOf"):
+                
+                py_type = "dict[str, Any]" 
+            else:
+                 
+                py_type = "dict[str, Any]"
+    elif openapi_type == "integer":
+        py_type = "int"
+    elif openapi_type == "number":
+        py_type = "float" 
+    elif openapi_type == "boolean":
+        py_type = "bool"
+    elif openapi_type == "string":
+        if schema.get("format") in ["binary", "byte"]:
+            py_type = "bytes"
+        elif schema.get("format") == "date" or schema.get("format") == "date-time":
+            py_type = "str"
+        else:
+            py_type = "str"
+    else: 
+       
+        py_type = "Any" 
+
+    if not required:
+        if py_type.startswith("Optional[") and py_type.endswith("]"):
+            return py_type
+        return f"Optional[{py_type}]"
+    return py_type
+
+
 def _sanitize_identifier(name: str | None) -> str:
     """Cleans a string to be a valid Python identifier.
 
@@ -235,6 +291,7 @@ def _generate_path_params(path: str) -> list[Parameters]:
                     where="path",
                     required=True,
                     example=None,
+                    schema={"type": "string"}
                 )
             )
         except Exception as e:
@@ -283,6 +340,7 @@ def _generate_query_params(operation: dict[str, Any]) -> list[Parameters]:
                 where=where,
                 required=required,
                 example=str(example_value) if example_value is not None else None,
+                schema=param_schema if param_schema else {"type": type_value}
             )
             query_params.append(parameter)
     return query_params
@@ -318,7 +376,8 @@ def _generate_body_params(schema_to_process: dict[str, Any] | None, overall_body
                 where="body",
                 required=param_required,
                 example=str(param_example) if param_example is not None else None,
-                is_file=current_is_file 
+                is_file=current_is_file,
+                schema=param_schema_details
             )
         )
     # print(f"[DEBUG] Final body_params list generated: {body_params}") # DEBUG
@@ -497,21 +556,34 @@ def _generate_method_code(path, method, operation):
     required_args = []
     optional_args = []
 
+    # Arguments for the function signature with type hints
+    signature_required_args_typed = []
+    signature_optional_args_typed = []
+
     #  Process Path Parameters (Highest Priority)
     for param in path_params:
         # Path param names are sanitized but not suffixed by aliasing.
         if param.name not in required_args:  # param.name is the sanitized name
             required_args.append(param.name)
+            # For signature with types
+            param_py_type = _openapi_type_to_python_type(param.schema, required=True)
+            signature_required_args_typed.append(f"{param.name}: {param_py_type}")
 
     #  Process Query Parameters
     for param in query_params:  # param.name is the potentially aliased name (e.g., id_query)
         arg_name_for_sig = param.name
         current_arg_names_set = set(required_args) | {arg.split("=")[0] for arg in optional_args}
+
+        # For signature with types
+        param_py_type = _openapi_type_to_python_type(param.schema, required=param.required)
+
         if arg_name_for_sig not in current_arg_names_set:
             if param.required:
                 required_args.append(arg_name_for_sig)
+                signature_required_args_typed.append(f"{arg_name_for_sig}: {param_py_type}")
             else:
                 optional_args.append(f"{arg_name_for_sig}=None")
+                signature_optional_args_typed.append(f"{arg_name_for_sig}: {param_py_type} = None")
 
     #  Process Body Parameters / Request Body
     # This list tracks the *final* names of parameters in the signature that come from the request body,
@@ -539,10 +611,16 @@ def _generate_method_code(path, method, operation):
                     final_array_param_name = f"{array_param_name_base}_body_{counter}"
                 counter += 1
 
+            # For signature with types
+            # The schema for an array body is body_schema_to_use itself
+            array_body_py_type = _openapi_type_to_python_type(body_schema_to_use, required=body_required)
+
             if body_required:
                 required_args.append(final_array_param_name)
+                signature_required_args_typed.append(f"{final_array_param_name}: {array_body_py_type}")
             else:
                 optional_args.append(f"{final_array_param_name}=None")
+                signature_optional_args_typed.append(f"{final_array_param_name}: {array_body_py_type} = None")
             final_request_body_arg_names_for_signature.append(final_array_param_name)
 
         # New: Handle raw body parameter (if body_params is empty but body is expected and not array/empty JSON)
@@ -563,10 +641,22 @@ def _generate_method_code(path, method, operation):
                 counter += 1
             raw_body_param_name = temp_raw_body_name
 
+            # For signature with types
+            # Determine type based on selected_content_type for raw body
+            raw_body_schema_for_type = {"type": "string", "format": "binary"} # Default to bytes
+            if selected_content_type and "text" in selected_content_type:
+                raw_body_schema_for_type = {"type": "string"}
+            elif selected_content_type and selected_content_type.startswith("image/"):
+                raw_body_schema_for_type = {"type": "string", "format": "binary"} # image is bytes
+            
+            raw_body_py_type = _openapi_type_to_python_type(raw_body_schema_for_type, required=body_required)
+
             if body_required: # If the raw body itself is required
                 required_args.append(raw_body_param_name)
+                signature_required_args_typed.append(f"{raw_body_param_name}: {raw_body_py_type}")
             else:
                 optional_args.append(f"{raw_body_param_name}=None")
+                signature_optional_args_typed.append(f"{raw_body_param_name}: {raw_body_py_type} = None")
             final_request_body_arg_names_for_signature.append(raw_body_param_name)
 
         elif body_params: # Object body with discernible properties
@@ -575,12 +665,18 @@ def _generate_method_code(path, method, operation):
 
                 # Defensive check against already added args 
                 current_arg_names_set_loop = set(required_args) | {arg.split("=")[0] for arg in optional_args}
+                
+                # For signature with types
+                param_py_type = _openapi_type_to_python_type(param.schema, required=param.required)
+
                 if arg_name_for_sig not in current_arg_names_set_loop:
                     if param.required:
                         required_args.append(arg_name_for_sig)
+                        signature_required_args_typed.append(f"{arg_name_for_sig}: {param_py_type}")
                     else:
                         # Parameters model does not store schema 'default'. Optional params default to None.
                         optional_args.append(f"{arg_name_for_sig}=None")
+                        signature_optional_args_typed.append(f"{arg_name_for_sig}: {param_py_type} = None")
                 final_request_body_arg_names_for_signature.append(arg_name_for_sig)
 
 
@@ -599,17 +695,26 @@ def _generate_method_code(path, method, operation):
                 final_empty_body_param_name = f"{empty_body_param_name_base}_body_{counter}"
             counter += 1
 
-        # Check if it was somehow added by other logic (e.g. if 'request_body' was an explicit param name)
+        # For signature with types
+        # Empty body usually implies an empty JSON object, so dict or Optional[dict]
+        empty_body_py_type = _openapi_type_to_python_type({"type": "object"}, required=False)
 
         if final_empty_body_param_name not in (set(required_args) | {arg.split("=")[0] for arg in optional_args}):
             optional_args.append(f"{final_empty_body_param_name}=None")
+            # Add to typed signature list
+            signature_optional_args_typed.append(f"{final_empty_body_param_name}: {empty_body_py_type} = None")
+
         # Track for docstring, even if it's just 'request_body' or 'request_body_body'
         if final_empty_body_param_name not in final_request_body_arg_names_for_signature:
             final_request_body_arg_names_for_signature.append(final_empty_body_param_name)
 
-    # Combine required and optional arguments
+    # Combine required and optional arguments FOR DOCSTRING (as before, without types)
     args = required_args + optional_args
-    print(f"[DEBUG] Final combined args for signature: {args}") # DEBUG
+    print(f"[DEBUG] Final combined args for DOCSTRING: {args}") # DEBUG
+
+    # Combine required and optional arguments FOR SIGNATURE (with types)
+    signature_args_combined_typed = signature_required_args_typed + signature_optional_args_typed
+    print(f"[DEBUG] Final combined args for SIGNATURE: {signature_args_combined_typed}") # DEBUG
 
     # ----- Build Docstring ----- 
     # This section constructs the entire docstring for the generated method,
@@ -643,43 +748,28 @@ def _generate_method_code(path, method, operation):
             param_details[param_obj.name] = param_obj
 
     # Fetch request body example
-    request_body_example_str = None
+    example_data = None # Initialize example_data here for wider scope
+
     if has_body:
         try:
             json_content = operation["requestBody"]["content"]["application/json"]
-            example_data = None
+            #From direct content definition
             if "example" in json_content:
                 example_data = json_content["example"]
             elif "examples" in json_content and json_content["examples"]:
                 first_example_key = list(json_content["examples"].keys())[0]
                 example_data = json_content["examples"][first_example_key].get("value")
-
-            if example_data is not None:
-                try:
-                    example_json = json.dumps(example_data, indent=2)
-                    indented_example = textwrap.indent(example_json, " " * 8)  # 8 spaces
-                    request_body_example_str = f"\n        Example:\n        ```json\n{indented_example}\n        ```"
-                except TypeError:
-                    request_body_example_str = f"\n        Example: {example_data}"
+            #If not found directly, try from resolved body schema (for nested/referenced examples)
+            if example_data is None and body_schema_to_use and "example" in body_schema_to_use:
+                example_data = body_schema_to_use["example"]
         except KeyError:
-            pass  # No example found
-
-    # Identify the last argument related to the request body
-    last_body_arg_name = None
-    # request_body_params contains the names as they appear in the signature
-    if final_request_body_arg_names_for_signature:  # Use the new list with final aliased names
-        # Find which of these appears last in the combined args list
-        body_args_in_signature = [
-            a.split("=")[0] for a in args if a.split("=")[0] in final_request_body_arg_names_for_signature
-        ]
-        if body_args_in_signature:
-            last_body_arg_name = body_args_in_signature[-1]
+            pass  # No example found or application/json content not present
 
     if signature_arg_names:
         args_doc_lines.append("Args:")
         for arg_signature_str in args:
             arg_name = arg_signature_str.split("=")[0]
-            example_str = None  # Initialize example_str here
+            example_str = None  # Initialize example_str here for each argument
             detail = param_details.get(arg_name)
             if detail:
                 desc = detail.description or "No description provided."
@@ -692,26 +782,22 @@ def _generate_method_code(path, method, operation):
                 if detail.example and not detail.is_file: # Don't show schema example for file inputs
                     example_str = repr(detail.example)
                     arg_line += f" Example: {example_str}."
-
-                # Append the full body example after the last body-related argument
-                if arg_name == last_body_arg_name and request_body_example_str:
-                    # Remove the simple Example: if it exists before adding the detailed one
-                    if example_str and (
-                        f" Example: {example_str}." in arg_line or f" Example: {example_str} ." in arg_line
-                    ):
-                        arg_line = arg_line.replace(
-                            f" Example: {example_str}.", ""
-                        )  # Remove with or without trailing period
-                    arg_line += request_body_example_str  # Append the formatted JSON example
+                # Fallback for body parameters if no direct example was found
+                elif not example_str and detail.where == "body" and example_data and isinstance(example_data, dict) and detail.identifier in example_data:
+                    current_body_param_example = example_data[detail.identifier]
+                    if current_body_param_example is not None: # Ensure the extracted part is not None
+                        try:
+                            arg_line += f" Example: {repr(current_body_param_example)}."
+                        except Exception: # Fallback if repr fails
+                            arg_line += " Example: [Could not represent example]."
 
                 args_doc_lines.append(arg_line)
-            elif arg_name == final_empty_body_param_name and has_empty_body:  # Use potentially suffixed name
+
+            elif arg_name == final_empty_body_param_name and has_empty_body:
                 args_doc_lines.append(
                     f"    {arg_name} (dict | None): Optional dictionary for an empty JSON request body (e.g., {{}})."
                 )
-                if ( arg_name == last_body_arg_name and request_body_example_str ): 
-                    args_doc_lines[-1] += request_body_example_str
-            elif arg_name == raw_body_param_name: # Docstring for raw body parameter
+            elif arg_name == raw_body_param_name: 
                 raw_body_type_hint = "bytes"
                 raw_body_desc = "Raw binary content for the request body."
                 if selected_content_type and "text" in selected_content_type:
@@ -720,13 +806,9 @@ def _generate_method_code(path, method, operation):
                 elif selected_content_type and selected_content_type.startswith("image/"):
                      raw_body_type_hint = "bytes (image data)"
                      raw_body_desc = f"Raw image content ({selected_content_type}) for the request body."
-
                 args_doc_lines.append(
                     f"    {arg_name} ({raw_body_type_hint} | None): {raw_body_desc}"
                 )
-                # Example for raw body is harder to give generically, but if present in spec, could be added.
-                if ( arg_name == last_body_arg_name and request_body_example_str ): 
-                    args_doc_lines[-1] += request_body_example_str
     
     if args_doc_lines:
         docstring_parts.append("\n".join(args_doc_lines))
@@ -765,8 +847,9 @@ def _generate_method_code(path, method, operation):
     # ----- End Build Docstring -----
 
     # --- Construct Method Signature String ---
-    if args:
-        signature = f"    def {func_name}(self, {', '.join(args)}) -> {return_type}:"
+    # Use signature_args_combined_typed for the signature
+    if signature_args_combined_typed:
+        signature = f"    def {func_name}(self, {', '.join(signature_args_combined_typed)}) -> {return_type}:"
     else:
         signature = f"    def {func_name}(self) -> {return_type}:"
 
@@ -988,7 +1071,7 @@ def generate_api_client(schema, class_name: str | None = None):
 
     # Generate class imports
     imports = [
-        "from typing import Any",
+        "from typing import Any, Optional, List",
         "from universal_mcp.applications import APIApplication",
         "from universal_mcp.integrations import Integration",
     ]
@@ -1062,4 +1145,4 @@ if __name__ == "__main__":
 
     schema = load_schema("openapi.yaml")
     code = generate_api_client(schema)
-    print(code)
+    print(code)