universal-mcp 0.1.20rc2__py3-none-any.whl → 0.1.21rc2__py3-none-any.whl

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/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/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,
@@ -742,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}:"
 
@@ -965,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",
     ]
@@ -1039,4 +1145,4 @@ if __name__ == "__main__":
 
     schema = load_schema("openapi.yaml")
     code = generate_api_client(schema)
-    print(code)
+    print(code)

{universal_mcp-0.1.20rc2.dist-info → universal_mcp-0.1.21rc2.dist-info}/METADATA

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

@@ -13,14 +13,14 @@ universal_mcp/integrations/__init__.py,sha256=X8iEzs02IlXfeafp6GMm-cOkg70QdjnlTR
 universal_mcp/integrations/integration.py,sha256=QvZlq3G5OU4tHPv9uq9Nv5NFe30NdUsJU-Av474n0_o,13154
 universal_mcp/servers/README.md,sha256=ytFlgp8-LO0oogMrHkMOp8SvFTwgsKgv7XhBVZGNTbM,2284
 universal_mcp/servers/__init__.py,sha256=eBZCsaZjiEv6ZlRRslPKgurQxmpHLQyiXv2fTBygHnM,532
-universal_mcp/servers/server.py,sha256=6xRUxTJHiX0AqEWbAZ6eb6jEkvuBX5Qpkb53hmKcfc0,12822
+universal_mcp/servers/server.py,sha256=bBCds1sLb3FOiIF3m9XjDe_FRyDpmkD1PGOuUV6Xl3g,12883
 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=OCZuWxLscys6mw1Q5ctQFshv9q3szlikwHhn4j5PMnE,1432
-universal_mcp/tools/func_metadata.py,sha256=zIDXgIBvu5Gh8aNlg-Q7cZZos9Iky75MS0Me0BraXeM,8086
+universal_mcp/tools/func_metadata.py,sha256=XvdXSZEzvgbH70bc-Zu0B47CD7f_rm--vblq4en3n0Q,8181
 universal_mcp/tools/manager.py,sha256=iwywaTjVGvBCJJasfwDWrASUleYqxenm4S-0txdhCF0,8076
 universal_mcp/tools/tools.py,sha256=qiuuLe0mCWtxXp6E5ISDDaNojCrMLfV1r5L8peFoJfg,3327
 universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
@@ -33,13 +33,13 @@ universal_mcp/utils/openapi/__inti__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 universal_mcp/utils/openapi/api_generator.py,sha256=FjtvbnWuI1P8W8wXuKLCirUtsqQ4HI_TuQrhpA4SqTs,4749
 universal_mcp/utils/openapi/api_splitter.py,sha256=6O2y7fcCo2k3ixLr6_9-aAZx2kas3UAxQhqJy1esNkE,18829
 universal_mcp/utils/openapi/docgen.py,sha256=DNmwlhg_-TRrHa74epyErMTRjV2nutfCQ7seb_Rq5hE,21366
-universal_mcp/utils/openapi/openapi.py,sha256=EQME-VC5ccXpukIF0h96YsQOZj6oWip8W7a0bRN3s_k,45677
+universal_mcp/utils/openapi/openapi.py,sha256=t2iDyJEMF-h3a8ssng0udUmJoF3OHYGkglXV4Kx3s5M,50850
 universal_mcp/utils/openapi/preprocessor.py,sha256=qLYv4ekors5B2OU_YUvXICYQ7XYhAOEPyAnKtnBvNpM,46699
 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.20rc2.dist-info/METADATA,sha256=WiatokzuBAxnApe-BKs-hr-fWMO8mqPUUZwCE6RjHdI,12125
-universal_mcp-0.1.20rc2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp-0.1.20rc2.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
-universal_mcp-0.1.20rc2.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
-universal_mcp-0.1.20rc2.dist-info/RECORD,,
+universal_mcp-0.1.21rc2.dist-info/METADATA,sha256=I-PuM1PTi5y1lEFg2VRp8OYec60vuKApGAJgz2t3AGs,12125
+universal_mcp-0.1.21rc2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.21rc2.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.21rc2.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp-0.1.21rc2.dist-info/RECORD,,