universal-mcp 0.1.21rc2__py3-none-any.whl → 0.1.22rc4__py3-none-any.whl

universal_mcp/utils/openapi/preprocessor.py

@@ -225,10 +225,17 @@ def generate_description_llm(
         if len(param_context_str) > 1000:  # Limit context size
             param_context_str = param_context_str[:1000] + "..."
 
-        user_prompt = f"""Generate a clear, brief description for the API parameter named "{param_name}" located "{param_in}" for the "{method.upper()}" operation at path "{path_key}".
-        Context (parameter details): {param_context_str}
-        Respond ONLY with the *SINGLE LINE* description text."""
-        fallback_text = f"[LLM could not generate description for parameter {param_name} in {method.upper()} {path_key}]"  # More specific fallback
+        current_description = context.get("current_description", None)
+        if current_description and isinstance(current_description, str) and current_description.strip():
+            user_prompt = f"""The current description for the API parameter named '{param_name}' located '{param_in}' for the '{method.upper()}' operation at path '{path_key}' is:\n'{current_description.strip()}'\n\nTask: Rewrite and enrich this description so it is clear, self-contained, and makes sense to a user. If the description is cut off, incomplete, or awkward, make it complete and natural. Ensure it is concise and under {MAX_DESCRIPTION_LENGTH} characters. Do not include any links, HTML, markdown, or any notes or comments about the character limit. Respond ONLY with the improved single-line description."""
+            fallback_text = (
+                f"[LLM could not generate description for parameter {param_name} in {method.upper()} {path_key}]"
+            )
+        else:
+            user_prompt = f"""Generate a clear, brief description for the API parameter named "{param_name}" located "{param_in}" for the "{method.upper()}" operation at path "{path_key}".\nContext (parameter details): {param_context_str}\nRespond ONLY with the *SINGLE LINE* description text."""
+            fallback_text = (
+                f"[LLM could not generate description for parameter {param_name} in {method.upper()} {path_key}]"
+            )
 
     elif description_type == "api_description":
         api_title = context.get("title", "Untitled API")
@@ -236,6 +243,24 @@ def generate_description_llm(
         Respond ONLY with the description text."""
         fallback_text = f"[LLM could not generate description for API '{api_title}']"  # More specific fallback
 
+    elif description_type == "operation_id":
+        path_key = context.get("path_key", "unknown path")
+        method = context.get("method", "unknown method")
+        operation_context_str = json.dumps(
+            context.get("operation_value", {}),
+            indent=None,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        if len(operation_context_str) > 500:
+            operation_context_str = operation_context_str[:500] + "..."
+        user_prompt = f"""Generate a short, unique, and readable operationId for the OpenAPI operation at path '{path_key}' using the '{method.upper()}' method.\n- The operationId MUST be a single word in camelCase or snake_case.\n- It MUST NOT exceed 30 characters.\n- It should be descriptive of the action and resource, e.g., 'getUser', 'createOrder', 'listInvoices', 'deleteUserById'.\n- Do NOT include spaces or special characters.\n- Respond ONLY with the operationId string, with NO explanation, NO notes, NO formatting, NO markdown, and NO extra text.\nContext (operation details): {operation_context_str}"""
+        fallback_text = f"[LLM could not generate operationId for {method.upper()} {path_key}]"
+        logger.info("\n--- LLM OperationId Generation Prompt ---")
+        logger.info(f"System prompt:\n{system_prompt}")
+        logger.info(f"User prompt:\n{user_prompt}")
+        logger.info("--- End LLM OperationId Prompt ---\n")
+
     else:
         logger.error(f"Invalid description_type '{description_type}' passed to generate_description_llm.")
         return "[Invalid description type specified]"
@@ -244,6 +269,10 @@ def generate_description_llm(
         logger.error(f"User prompt was not generated for description_type '{description_type}'.")
         return fallback_text
 
+    # If user_prompt_override is provided in context, use it
+    if context and "user_prompt_override" in context:
+        user_prompt = context["user_prompt_override"]
+
     messages = [
         {"role": "system", "content": system_prompt},
         {"role": "user", "content": user_prompt},
@@ -716,6 +745,7 @@ def process_parameter(
 
         simplified_context = simplify_parameter_context(parameter)
 
+        current_description = parameter.get("description", "")
         generated_description = generate_description_llm(
             description_type="parameter",
             model=llm_model,
@@ -725,6 +755,7 @@ def process_parameter(
                 "param_name": param_name,
                 "param_in": param_in,
                 "parameter_details": simplified_context,
+                "current_description": current_description,
             },
         )
         parameter["description"] = generated_description
@@ -764,6 +795,8 @@ def process_operation(
     method: str,
     llm_model: str,
     enhance_all: bool,  # New flag
+    summaries_only: bool = False,
+    operation_ids_only: bool = False,
 ):
     operation_location_base = f"paths.{path_key}.{method.lower()}"
 
@@ -775,6 +808,26 @@ def process_operation(
         logger.debug(f"Skipping extension operation '{operation_location_base}'.")
         return
 
+    # --- Ensure operationId is present, using LLM if missing, but only if not summaries_only ---
+    if (operation_ids_only or not summaries_only) and (
+        "operationId" not in operation_value or not operation_value["operationId"]
+    ):
+        simplified_context = simplify_operation_context(operation_value)
+        generated_operation_id = generate_description_llm(
+            description_type="operation_id",
+            model=llm_model,
+            context={
+                "path_key": path_key,
+                "method": method,
+                "operation_value": simplified_context,
+            },
+        )
+        operation_value["operationId"] = sanitize_operation_id(generated_operation_id)
+        logger.info(f"Added operationId '{operation_value['operationId']}' to '{operation_location_base}'.")
+
+    if operation_ids_only:
+        return
+
     # --- Process Summary ---
     operation_summary = operation_value.get("summary")
 
@@ -814,24 +867,27 @@ def process_operation(
             )
 
     # --- Process Parameters ---
-    parameters = operation_value.get("parameters")
-    if isinstance(parameters, list):
-        for _i, parameter in enumerate(parameters):
-            process_parameter(
-                parameter,
-                operation_location_base,
-                path_key,
-                method,
-                llm_model,
-                enhance_all,  # Pass enhance_all
+    if not summaries_only:
+        parameters = operation_value.get("parameters")
+        if isinstance(parameters, list):
+            for _i, parameter in enumerate(parameters):
+                process_parameter(
+                    parameter,
+                    operation_location_base,
+                    path_key,
+                    method,
+                    llm_model,
+                    enhance_all,
+                )
+        elif parameters is not None:
+            logger.warning(
+                f"'parameters' field for operation '{operation_location_base}' is not a list. Skipping parameter processing."
             )
-    elif parameters is not None:
-        logger.warning(
-            f"'parameters' field for operation '{operation_location_base}' is not a list. Skipping parameter processing."
-        )
 
 
-def process_paths(paths: dict, llm_model: str, enhance_all: bool):  # New flag
+def process_paths(
+    paths: dict, llm_model: str, enhance_all: bool, summaries_only: bool = False, operation_ids_only: bool = False
+):
     if not isinstance(paths, dict):
         logger.warning("'paths' field is not a dictionary. Skipping path processing.")
         return
@@ -853,7 +909,9 @@ def process_paths(paths: dict, llm_model: str, enhance_all: bool):  # New flag
                     "patch",
                     "trace",
                 ]:
-                    process_operation(operation_value, path_key, method, llm_model, enhance_all)  # Pass enhance_all
+                    process_operation(
+                        operation_value, path_key, method, llm_model, enhance_all, summaries_only, operation_ids_only
+                    )
                 elif method.lower().startswith("x-"):
                     logger.debug(f"Skipping processing of method extension '{method.lower()}' in path '{path_key}'.")
                     continue
@@ -916,18 +974,89 @@ def process_info_section(schema_data: dict, llm_model: str, enhance_all: bool):
             )
 
 
-def preprocess_schema_with_llm(schema_data: dict, llm_model: str, enhance_all: bool):  # New flag
+def find_duplicate_operation_ids(schema_data: dict) -> dict:
+    """Returns a dict mapping duplicate operationIds to a list of (path, method) tuples where they occur."""
+    operation_id_map = {}
+    paths = schema_data.get("paths", {})
+    for path_key, path_value in paths.items():
+        if not isinstance(path_value, dict):
+            continue
+        for method, operation_value in path_value.items():
+            if method.lower() not in ["get", "put", "post", "delete", "options", "head", "patch", "trace"]:
+                continue
+            if not isinstance(operation_value, dict):
+                continue
+            op_id = operation_value.get("operationId")
+            if op_id:
+                operation_id_map.setdefault(op_id, []).append((path_key, method))
+    # Only keep duplicates
+    return {k: v for k, v in operation_id_map.items() if len(v) > 1}
+
+
+def regenerate_duplicate_operation_ids(schema_data: dict, llm_model: str):
+    """For each duplicate operationId, re-run the LLM to generate a new one, providing used operationIds to avoid."""
+    used_operation_ids = set()
+    paths = schema_data.get("paths", {})
+    # First, collect all unique operationIds
+    for _path_key, path_value in paths.items():
+        if not isinstance(path_value, dict):
+            continue
+        for method, operation_value in path_value.items():
+            if method.lower() not in ["get", "put", "post", "delete", "options", "head", "patch", "trace"]:
+                continue
+            if not isinstance(operation_value, dict):
+                continue
+            op_id = operation_value.get("operationId")
+            if op_id:
+                used_operation_ids.add(op_id)
+    # Now, find and fix duplicates
+    duplicates = find_duplicate_operation_ids(schema_data)
+    for _op_id, occurrences in duplicates.items():
+        # Keep the first occurrence, fix the rest
+        for _path_key, method in occurrences[1:]:
+            operation_value = paths[_path_key][method]
+            simplified_context = simplify_operation_context(operation_value)
+            # Prompt LLM with used_operation_ids to avoid
+            avoid_list = list(used_operation_ids)
+            user_prompt = f"Generate a short, unique, and readable operationId for the OpenAPI operation at path '{_path_key}' using the '{method.upper()}' method.\n- The operationId MUST be a single word in camelCase or snake_case.\n- It MUST NOT exceed 30 characters.\n- It should be descriptive of the action and resource, e.g., 'getUser', 'createOrder', 'listInvoices', 'deleteUserById'.\n- Do NOT include spaces or special characters.\n- Respond ONLY with the operationId string, with NO explanation, NO notes, NO formatting, NO markdown, and NO extra text.\n- Avoid these operationIds: {avoid_list}\nContext (operation details): {json.dumps(simplified_context, separators=(',', ':'), sort_keys=True)[:500]}"
+            # Use the same LLM call as before, but override the user_prompt
+            generated_operation_id = generate_description_llm(
+                description_type="operation_id",
+                model=llm_model,
+                context={
+                    "path_key": _path_key,
+                    "method": method,
+                    "operation_value": simplified_context,
+                    "user_prompt_override": user_prompt,
+                },
+            )
+            operation_value["operationId"] = sanitize_operation_id(generated_operation_id)
+            used_operation_ids.add(operation_value["operationId"])
+            logger.info(f"Regenerated duplicate operationId for {_path_key} {method}: {operation_value['operationId']}")
+
+
+def preprocess_schema_with_llm(
+    schema_data: dict, llm_model: str, enhance_all: bool, summaries_only: bool = False, operation_ids_only: bool = False
+):
     """
     Processes the schema to add/enhance descriptions/summaries using an LLM.
     Decides whether to generate based on the 'enhance_all' flag and existing content.
+    If summaries_only is True, only operation summaries (and info.description) are enriched.
+    If operation_ids_only is True, only missing operationIds are generated (never overwritten).
     Assumes basic schema structure validation (info, title) has already passed.
     """
-    logger.info(f"\n--- Starting LLM Generation (enhance_all={enhance_all}) ---")
+    logger.info(
+        f"\n--- Starting LLM Generation (enhance_all={enhance_all}, summaries_only={summaries_only}, operation_ids_only={operation_ids_only}) ---"
+    )
 
-    process_info_section(schema_data, llm_model, enhance_all)
+    # Only process info section if not operation_ids_only
+    if not operation_ids_only:
+        process_info_section(schema_data, llm_model, enhance_all)
 
     paths = schema_data.get("paths")
-    process_paths(paths, llm_model, enhance_all)
+    process_paths(paths, llm_model, enhance_all, summaries_only, operation_ids_only)
+
+    # After process_paths, regenerate_duplicate_operation_ids(schema_data, llm_model)
 
     logger.info("--- LLM Generation Complete ---")
 
@@ -1007,8 +1136,11 @@ def run_preprocessing(
             "  [1] Generate [bold]only missing[/bold] descriptions/summaries [green](default)[/green]",
             "  [2] Generate/Enhance [bold]all[/bold] descriptions/summaries",
             "  [3] [bold red]Quit[/bold red] (exit without changes)",
+            "  [4] Generate/Enhance [bold]only operation summaries[/bold]",
+            "  [5] Generate [bold]only missing operationIds[/bold]",
+            "  [6] [bold]Enrich only parameter descriptions (LLM, ≤250 chars, run after clean-up)[/bold]",
         ]
-        valid_choices = ["1", "2", "3"]
+        valid_choices = ["1", "2", "3", "4", "5", "6"]
         default_choice = "1"  # Default to filling missing
 
     else:  # total_missing_or_fallback == 0
@@ -1027,8 +1159,11 @@ def run_preprocessing(
         prompt_options = [
             "  [2] Generate/Enhance [bold]all[/bold] descriptions/summaries",
             "  [3] [bold red]Quit[/bold red] [green](default)[/green]",
+            "  [4] Generate/Enhance [bold]only operation summaries[/bold]",
+            "  [5] Generate [bold]only missing operationIds[/bold]",
+            "  [6] [bold]Enrich only parameter descriptions (LLM, ≤250 chars, run after clean-up)[/bold]",
         ]
-        valid_choices = ["2", "3"]
+        valid_choices = ["2", "3", "4", "5", "6"]
         default_choice = "3"  # Default to quitting if nothing missing
 
     for option_text in prompt_options:
@@ -1046,19 +1181,50 @@ def run_preprocessing(
             raise typer.Exit(0)
         elif choice == "1":
             enhance_all = False
+            summaries_only = False
+            operation_ids_only = False
             break  # Exit prompt loop
         elif choice == "2":
             enhance_all = True
+            summaries_only = False
+            operation_ids_only = False
+            break  # Exit prompt loop
+        elif choice == "4":
+            enhance_all = True  # or False, doesn't matter since we skip parameters
+            summaries_only = True
+            operation_ids_only = False
+            break  # Exit prompt loop
+        elif choice == "5":
+            enhance_all = False
+            summaries_only = False
+            operation_ids_only = True
             break  # Exit prompt loop
+        elif choice == "6":
+            console.print(
+                "[blue]Enriching only parameter descriptions using the LLM (≤250 chars, only if current description is longer)...[/blue]"
+            )
+            try:
+                enrich_parameter_descriptions(schema_data, model, max_length=250)
+                console.print("[green]Parameter description enrichment complete.[/green]")
+            except Exception as e:
+                console.print(f"[red]Error during parameter description enrichment: {e}[/red]")
+                import traceback
+
+                traceback.print_exc(file=sys.stderr)
+                raise typer.Exit(1) from e
+            enhance_all = summaries_only = operation_ids_only = False
+            break
 
     perform_generation = False
-    if enhance_all or choice == "1" and total_missing_or_fallback > 0:
+    if operation_ids_only or summaries_only or enhance_all or (choice == "1" and total_missing_or_fallback > 0):
         perform_generation = True
 
     if perform_generation:
-        console.print(f"[blue]Starting LLM generation with Enhance All: {enhance_all}[/blue]")
+        console.print(
+            f"[blue]Starting LLM generation with Enhance All: {enhance_all}, Summaries Only: {summaries_only}, OperationIds Only: {operation_ids_only}[/blue]"
+        )
         try:
-            preprocess_schema_with_llm(schema_data, model, enhance_all)
+            preprocess_schema_with_llm(schema_data, model, enhance_all, summaries_only, operation_ids_only)
             console.print("[green]LLM generation complete.[/green]")
         except Exception as e:
             console.print(f"[red]Error during LLM generation: {e}[/red]")
@@ -1091,3 +1257,80 @@ def run_preprocessing(
     console.print("\n[bold green]--- Schema Processing and Saving Complete ---[/bold green]")
     console.print(f"Processed schema saved to: [blue]{output_path}[/blue]")
     console.print("[bold blue]Preprocessor finished successfully.[/bold blue]")
+
+
+def enrich_parameter_descriptions(schema_data: dict, llm_model: str, max_length: int = 250):
+    """
+    Enriches parameter descriptions using the LLM, but ONLY if the current description is longer than max_length chars.
+    Only processes parameter descriptions, does not touch examples or other fields.
+    """
+    MAX_ATTEMPTS = 3
+    paths = schema_data.get("paths")
+    if not isinstance(paths, dict):
+        return
+    for path_key, path_value in paths.items():
+        if not isinstance(path_value, dict):
+            continue
+        for method, operation_value in path_value.items():
+            if not (
+                isinstance(operation_value, dict)
+                and method.lower() in ["get", "put", "post", "delete", "options", "head", "patch", "trace"]
+            ):
+                continue
+            parameters = operation_value.get("parameters")
+            if isinstance(parameters, list):
+                for parameter in parameters:
+                    if isinstance(parameter, dict):
+                        param_name = parameter.get("name")
+                        param_in = parameter.get("in")
+                        # Only enrich if name and in are present
+                        if not (
+                            isinstance(param_name, str)
+                            and param_name.strip()
+                            and isinstance(param_in, str)
+                            and param_in.strip()
+                        ):
+                            continue
+                        current_description = parameter.get("description", "")
+                        if not isinstance(current_description, str) or len(current_description) <= max_length:
+                            continue
+                        logger.info(
+                            f"Enriching parameter description >{max_length} chars: path='{path_key}', method='{method}', param_name='{param_name}', param_in='{param_in}', length={len(current_description)}"
+                        )
+                        simplified_context = simplify_parameter_context(parameter)
+                        attempt = 0
+                        generated_description = current_description
+                        while attempt < MAX_ATTEMPTS:
+                            generated_description = generate_description_llm(
+                                description_type="parameter",
+                                model=llm_model,
+                                context={
+                                    "path_key": path_key,
+                                    "method": method,
+                                    "param_name": param_name,
+                                    "param_in": param_in,
+                                    "parameter_details": simplified_context,
+                                    "current_description": generated_description,
+                                },
+                            )
+                            if isinstance(generated_description, str) and len(generated_description) <= max_length:
+                                break
+                            attempt += 1
+                        # If still too long, truncate
+                        if isinstance(generated_description, str) and len(generated_description) > max_length:
+                            generated_description = generated_description[:max_length].rstrip() + "..."
+                        parameter["description"] = generated_description
+
+
+def sanitize_operation_id(llm_response: str) -> str:
+    """Extracts the first valid operationId from the LLM response."""
+    for line in llm_response.splitlines():
+        line = line.strip()
+        # Skip empty lines and markdown/comments
+        if not line or line.startswith("#") or line.startswith("*") or line.startswith("**"):
+            continue
+        # Only allow valid operationId patterns (alphanumeric, camelCase, snake_case, max 30 chars)
+        if re.match(r"^[a-zA-Z_][a-zA-Z0-9_]{0,29}$", line):
+            return line
+    # Fallback: return the first word
+    return llm_response.strip().split()[0] if llm_response.strip() else ""

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.21rc2.dist-info → universal_mcp-0.1.22rc4.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.21rc2
+Version: 0.1.22rc4
 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
 License-File: LICENSE
 Requires-Python: >=3.11
+Requires-Dist: black>=25.1.0
 Requires-Dist: cookiecutter>=2.6.0
 Requires-Dist: gql[all]>=3.5.2
 Requires-Dist: jinja2>=3.1.3

{universal_mcp-0.1.21rc2.dist-info → universal_mcp-0.1.22rc4.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=7iml45r5jYX8_iiYeTRnMeBTfFb7rdygp5e9f1KiPSw,3361
+universal_mcp/applications/__init__.py,sha256=l19_sMs5766VFWU_7O2niamvvvfQOteysqylbqvjjGQ,3500
 universal_mcp/applications/application.py,sha256=3cQ5BVWmC2gU4fgpM5wZ3ByTe7iGbQriNPVSWxclaiU,17744
 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=QvZlq3G5OU4tHPv9uq9Nv5NFe30NdUsJU-Av474n0_o,13154
+universal_mcp/integrations/integration.py,sha256=uKucut4AKTN2M-K8Aqsm2qtchLqlQRWMU8L287X7VyQ,13043
 universal_mcp/servers/README.md,sha256=ytFlgp8-LO0oogMrHkMOp8SvFTwgsKgv7XhBVZGNTbM,2284
 universal_mcp/servers/__init__.py,sha256=eBZCsaZjiEv6ZlRRslPKgurQxmpHLQyiXv2fTBygHnM,532
-universal_mcp/servers/server.py,sha256=bBCds1sLb3FOiIF3m9XjDe_FRyDpmkD1PGOuUV6Xl3g,12883
+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=OCZuWxLscys6mw1Q5ctQFshv9q3szlikwHhn4j5PMnE,1432
+universal_mcp/tools/adapters.py,sha256=nMoZ9jnv1uKhfq6NmBJ5-a6uwdB_H8RqkdNLIacCRfM,2978
 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/tools/manager.py,sha256=ao_ovTyca8HR4uwHdL_lTWNdquxcqRx6FaLA4U1lZvQ,11242
+universal_mcp/tools/tools.py,sha256=8YBTaJCM38Nhan9Al6Vlq4FtSULrKlxg1q_o8OL1_FM,3322
 universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
-universal_mcp/utils/agentr.py,sha256=YmX6hvFW84keJKTZqP3jPz4rP9DM5wHZ0vTMHfxO6AI,3360
+universal_mcp/utils/agentr.py,sha256=Rzfou8dfS705lNrRwKLXkpNlo4zJs1oPP_2QY46l4Uo,3486
 universal_mcp/utils/common.py,sha256=HEZC2Mhilb8DrGXQG2tboAIw1r4veGilGWjfnPF1lyA,888
-universal_mcp/utils/docstring_parser.py,sha256=6oIeCjOUirFdVpXdGZt5zDKje6jmCY42-GeYOc_7r2I,11317
+universal_mcp/utils/docstring_parser.py,sha256=SKIfAiFHiqxqageayYFlpsexipy8tN7N4RLT6GIzfoQ,7672
 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=6O2y7fcCo2k3ixLr6_9-aAZx2kas3UAxQhqJy1esNkE,18829
+universal_mcp/utils/openapi/api_splitter.py,sha256=S-rT3wsJWUVhU_Tv_ibNNAlQ79SfWOcU6qaa_rFfd5o,20806
 universal_mcp/utils/openapi/docgen.py,sha256=DNmwlhg_-TRrHa74epyErMTRjV2nutfCQ7seb_Rq5hE,21366
-universal_mcp/utils/openapi/openapi.py,sha256=t2iDyJEMF-h3a8ssng0udUmJoF3OHYGkglXV4Kx3s5M,50850
-universal_mcp/utils/openapi/preprocessor.py,sha256=qLYv4ekors5B2OU_YUvXICYQ7XYhAOEPyAnKtnBvNpM,46699
+universal_mcp/utils/openapi/openapi.py,sha256=sfHJWBaC2c-9ZCjTODH7Gt-un_agixOr_ylx9Xld8N4,51139
+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.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,,
+universal_mcp-0.1.22rc4.dist-info/METADATA,sha256=3poFZB1sv1psL8m_KwV8FjNCWsA1tiGzB_X4QdYBaPY,12154
+universal_mcp-0.1.22rc4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.22rc4.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.22rc4.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp-0.1.22rc4.dist-info/RECORD,,