tooluniverse 1.0.11.1__tar.gz → 1.0.11.2__tar.gz

{tooluniverse-1.0.11.1 → tooluniverse-1.0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tooluniverse
-Version: 1.0.11.1
+Version: 1.0.11.2
 Summary: A comprehensive collection of scientific tools for Agentic AI, offering integration with the ToolUniverse SDK and MCP Server to support advanced scientific workflows.
 Author-email: Shanghua Gao <shanghuagao@gmail.com>
 Project-URL: Homepage, https://github.com/mims-harvard/ToolUniverse

{tooluniverse-1.0.11.1 → tooluniverse-1.0.11.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tooluniverse"
-version = "1.0.11.1"
+version = "1.0.11.2"
 description = "A comprehensive collection of scientific tools for Agentic AI, offering integration with the ToolUniverse SDK and MCP Server to support advanced scientific workflows."
 authors = [
     { name = "Shanghua Gao", email = "shanghuagao@gmail.com" }

{tooluniverse-1.0.11.1 → tooluniverse-1.0.11.2}/src/tooluniverse/alphafold_tool.py

@@ -11,7 +11,7 @@ ALPHAFOLD_BASE_URL = "https://alphafold.ebi.ac.uk/api"
 class AlphaFoldRESTTool(BaseTool):
     """
     AlphaFold Protein Structure Database API tool.
-    Generic wrapper for AlphaFold API endpoints defined in alphafold_tools.json.
+    Generic wrapper for AlphaFold API endpoints from alphafold_tools.json.
     """
 
     def __init__(self, tool_config):
@@ -22,6 +22,7 @@ class AlphaFoldRESTTool(BaseTool):
         self.endpoint_template: str = fields["endpoint"]
         self.required: List[str] = parameter.get("required", [])
         self.output_format: str = fields.get("return_format", "JSON")
+        self.auto_query_params: Dict[str, Any] = fields.get("auto_query_params", {})
 
     def _build_url(self, arguments: Dict[str, Any]) -> str | Dict[str, Any]:
         # Example: endpoint_template = "/annotations/{qualifier}.json"
@@ -40,14 +41,18 @@ class AlphaFoldRESTTool(BaseTool):
         # Now url_path = "/annotations/P69905.json"
 
         # Treat all remaining args as query parameters
-        #   "type" wasn’t a placeholder, so it becomes a query param
+        #   "type" wasn't a placeholder, so it becomes a query param
         query_args = {k: v for k, v in arguments.items() if k not in used}
+
+        # Add auto_query_params from config (e.g., type=MUTAGEN)
+        query_args.update(self.auto_query_params)
+
         if query_args:
             from urllib.parse import urlencode
 
             url_path += "?" + urlencode(query_args)
 
-        # Final result = "https://alphafold.ebi.ac.uk/api/annotations/P69905.json?type=MUTAGEN"
+        # Final example: annotations/P69905.json?type=MUTAGEN
         return ALPHAFOLD_BASE_URL + url_path
 
     def _make_request(self, url: str) -> Dict[str, Any]:
@@ -62,9 +67,37 @@ class AlphaFoldRESTTool(BaseTool):
                 },
             )
         except Exception as e:
-            return {"error": "Request to AlphaFold API failed", "detail": str(e)}
+            return {
+                "error": "Request to AlphaFold API failed",
+                "detail": str(e),
+            }
 
         if resp.status_code == 404:
+            # Try to provide more context about 404 errors
+            # Check if protein exists in AlphaFold DB
+            try:
+                qualifier_match = re.search(r"/annotations/([^/]+)\.json", url)
+                if qualifier_match:
+                    accession = qualifier_match.group(1)
+                    base = ALPHAFOLD_BASE_URL
+                    check_url = f"{base}/uniprot/summary/{accession}.json"
+                    check_resp = requests.get(check_url, timeout=10)
+                    if check_resp.status_code == 200:
+                        return {
+                            "error": "No MUTAGEN annotations available",
+                            "reason": (
+                                "Protein exists in AlphaFold DB but "
+                                "has no MUTAGEN annotations"
+                            ),
+                            "endpoint": url,
+                        }
+                    else:
+                        return {
+                            "error": "Protein not found in AlphaFold DB",
+                            "endpoint": url,
+                        }
+            except Exception:
+                pass  # Fall through to generic error
             return {"error": "Not found", "endpoint": url}
         if resp.status_code != 200:
             return {
@@ -98,9 +131,13 @@ class AlphaFoldRESTTool(BaseTool):
         if self.output_format.upper() == "JSON":
             try:
                 data = resp.json()
-                if not data:
+                if not data or (isinstance(data, dict) and not data):
                     return {
-                        "error": "AlphaFold returned an empty response",
+                        "error": "No MUTAGEN annotations available",
+                        "reason": (
+                            "Protein exists in AlphaFold DB but "
+                            "has no MUTAGEN annotations from UniProt"
+                        ),
                         "endpoint": url,
                         "query": arguments,
                     }
@@ -124,4 +161,7 @@ class AlphaFoldRESTTool(BaseTool):
                 }
 
         # Fallback for non-JSON output
-        return {"data": resp.text, "metadata": {"endpoint": url, "query": arguments}}
+        return {
+            "data": resp.text,
+            "metadata": {"endpoint": url, "query": arguments},
+        }

{tooluniverse-1.0.11.1 → tooluniverse-1.0.11.2}/src/tooluniverse/base_tool.py

@@ -183,7 +183,15 @@ class BaseTool:
         try:
             import jsonschema
 
-            jsonschema.validate(arguments, schema)
+            # Filter out internal control parameters before validation
+            # Only filter known internal parameters, not all underscore-prefixed params
+            # to allow optional streaming parameter _tooluniverse_stream
+            internal_params = {"ctx", "_tooluniverse_stream"}
+            filtered_arguments = {
+                k: v for k, v in arguments.items() if k not in internal_params
+            }
+
+            jsonschema.validate(filtered_arguments, schema)
             return None
         except jsonschema.ValidationError as e:
             return ToolValidationError(

{tooluniverse-1.0.11.1 → tooluniverse-1.0.11.2}/src/tooluniverse/data/alphafold_tools.json

@@ -387,31 +387,26 @@
   },
   {
     "name": "alphafold_get_annotations",
-    "description": "Retrieve AlphaFold variant annotations (e.g., missense mutations) for a given UniProt accession. IMPORTANT: The qualifier must be a UniProt ACCESSION (e.g., 'P69905'), along with an annotation type (currently only 'MUTAGEN'). Do NOT use UniProt entry names as they will cause API errors. To find UniProt accession from a gene/protein name, use `UniProt_search` (e.g., query='gene:TP53' organism='human') or `UniProt_id_mapping` for ID conversion. Use this tool to explore predicted pathogenicity or functional effects of substitutions. For experimentally curated variants, use `UniProt_get_disease_variants_by_accession`. To view the full 3D structure, call `alphafold_get_prediction`; for overall model metadata, use `alphafold_get_summary`.",
+    "description": "Retrieve AlphaFold MUTAGEN annotations for a given UniProt accession. Returns experimental mutagenesis data mapped onto protein structures from UniProt. The qualifier must be a UniProt ACCESSION (e.g., 'P69905'). Note: Not all proteins have MUTAGEN annotations available in the database.",
     "type": "AlphaFoldRESTTool",
     "parameter": {
       "type": "object",
       "properties": {
         "qualifier": {
           "type": "string",
-          "description": "Protein identifier: UniProt ACCESSION (e.g., 'P69905'). Do NOT use entry names. To find accession from gene name: use `UniProt_search` or `UniProt_id_mapping`."
-        },
-        "type": {
-          "type": "string",
-          "description": "Annotation type (currently only 'MUTAGEN' is supported).",
-          "enum": [
-            "MUTAGEN"
-          ]
+          "description": "UniProt ACCESSION (e.g., 'P69905'). Must be an accession number, not an entry name."
         }
       },
       "required": [
-        "qualifier",
-        "type"
+        "qualifier"
       ]
     },
     "fields": {
       "endpoint": "/annotations/{qualifier}.json",
-      "return_format": "JSON"
+      "return_format": "JSON",
+      "auto_query_params": {
+        "type": "MUTAGEN"
+      }
     },
     "return_schema": {
       "type": "object",

{tooluniverse-1.0.11.1 → tooluniverse-1.0.11.2}/src/tooluniverse/data/uniprot_tools.json

@@ -210,28 +210,36 @@
     },
     {
       "name": "UniProt_search",
-      "description": "Search UniProtKB database using flexible query syntax. Supports gene names (e.g., 'gene:TP53'), protein names, organism filters (e.g., 'organism:9606'), and complex queries using AND/OR operators. Returns matching proteins with accession numbers and key information. Use this to find UniProt accessions from gene or protein names.",
+      "description": "Search UniProtKB database with flexible query syntax. Returns protein entries with accession numbers and metadata. Query syntax supports: field searches (gene:TP53, organism_id:9606, reviewed:true), ranges (length:[100 TO 500], mass:[20000 TO 50000]), wildcards (gene:MEIOB*), boolean operators (AND/OR/NOT), and parentheses for grouping. Examples: 'gene:TP53 AND organism_id:9606', 'length:[400 TO 500] AND reviewed:true', 'tissue:brain NOT organism_id:10090'.",
       "parameter": {
         "type": "object",
         "properties": {
           "query": {
             "type": "string",
-            "description": "Search query. Can be simple (e.g., 'MEIOB') or advanced ('gene:TP53 AND organism:9606'). Keywords: gene, protein_name, organism, reviewed, etc."
+            "description": "Search query using UniProt syntax. Simple: 'MEIOB', 'insulin'. Field searches: 'gene:TP53', 'protein_name:insulin', 'organism_id:9606', 'reviewed:true'. Ranges: 'length:[100 TO 500]', 'mass:[20000 TO 50000]'. Wildcards: 'gene:MEIOB*'. Boolean: 'gene:TP53 AND organism_id:9606', 'tissue:brain OR tissue:liver', 'reviewed:true NOT fragment:true'. Use parentheses for grouping: '(organism_id:9606 OR organism_id:10090) AND gene:TP53'. Note: 'organism:' auto-converts to 'organism_id:'."
           },
           "organism": {
             "type": "string",
-            "description": "Optional organism filter. Can use common name ('human') or taxonomy ID ('9606'). Automatically combined with query using AND."
+            "description": "Optional organism filter. Use common names ('human', 'mouse', 'rat', 'yeast') or taxonomy ID ('9606'). Automatically combined with query using AND. Will not duplicate if organism is already in query."
           },
           "limit": {
             "type": "integer",
-            "description": "Maximum number of results to return (default: 25, max: 500)"
+            "description": "Maximum number of results to return (default: 25, max: 500). Accepts string or integer."
+          },
+          "min_length": {
+            "type": "integer",
+            "description": "Minimum sequence length. Auto-converts to 'length:[min TO *]' range query."
+          },
+          "max_length": {
+            "type": "integer",
+            "description": "Maximum sequence length. Auto-converts to 'length:[* TO max]' range query."
           },
           "fields": {
             "type": "array",
             "items": {
               "type": "string"
             },
-            "description": "Optional list of fields to return. Default returns: accession, id, protein_name, gene_names, organism, length"
+            "description": "List of field names to return (e.g., ['accession','gene_primary','length','organism_name']). When specified, returns raw API response with requested fields. Common fields: accession, id, gene_names, gene_primary, protein_name, organism_name, organism_id, length, mass, sequence, reviewed, cc_function. See UniProt API docs for full list. Default (no fields): returns formatted response with accession, id, protein_name, gene_names, organism, length."
           }
         },
         "required": ["query"]

{tooluniverse-1.0.11.1 → tooluniverse-1.0.11.2}/src/tooluniverse/execute_function.py

@@ -354,6 +354,12 @@ class ToolUniverse:
             "TOOLUNIVERSE_STRICT_VALIDATION", "false"
         ).lower() in ("true", "1", "yes")
 
+        # Initialize lenient type coercion feature
+        # Default: True for better user experience
+        self.lenient_type_coercion = os.getenv(
+            "TOOLUNIVERSE_COERCE_TYPES", "true"
+        ).lower() in ("true", "1", "yes")
+
         # Initialize dynamic tools namespace
         self.tools = ToolNamespace(self)
 
@@ -2113,21 +2119,28 @@ class ToolUniverse:
                     )
                     return cached_value
 
+            # Coerce types if lenient coercion is enabled
+            if self.lenient_type_coercion:
+                arguments = self._coerce_arguments_to_schema(function_name, arguments)
+                # Update the original dict so coerced arguments are used
+                function_call_json["arguments"] = arguments
+
             # Validate parameters if requested
             if validate:
                 validation_error = self._validate_parameters(function_name, arguments)
                 if validation_error:
                     return self._create_dual_format_error(validation_error)
-
-            # Check function call format (existing validation)
-            check_status, check_message = self.check_function_call(function_call_json)
-            if check_status is False:
-                error_msg = "Invalid function call: " + check_message
-                return self._create_dual_format_error(
-                    ToolValidationError(
-                        error_msg, details={"check_message": check_message}
+            else:
+                # When validate=False, perform lightweight checks:
+                # 1. Verify tool exists in all_tool_dict
+                # 2. No parameter validation (for performance)
+                if function_name not in self.all_tool_dict:
+                    return self._create_dual_format_error(
+                        ToolValidationError(
+                            f"Tool '{function_name}' not found",
+                            details={"tool_name": function_name},
+                        )
                     )
-                )
 
             # Execute the tool
             tool_arguments = arguments
@@ -2421,6 +2434,123 @@ class ToolUniverse:
         )
         return hashlib.md5(serialized.encode()).hexdigest()
 
+    def _coerce_value_to_type(self, value: Any, schema: dict) -> Any:
+        """
+        Coerce a value to match the schema's expected type.
+
+        This function attempts to convert string values to integers, floats,
+        or booleans when the schema expects those types. This makes the
+        system more lenient with user input from LLMs that provide numeric
+        values as strings.
+
+        Args:
+            value: The value to coerce
+            schema: The JSON schema definition for this value
+
+        Returns:
+            The coerced value (or original if coercion fails or not applicable)
+        """
+        # Only coerce string values
+        if not isinstance(value, str):
+            return value
+
+        # Handle anyOf/oneOf schemas by recursively trying each option
+        if "anyOf" in schema:
+            for option in schema["anyOf"]:
+                coerced = self._coerce_value_to_type(value, option)
+                if coerced is not value:  # Coercion succeeded
+                    return coerced
+            return value
+
+        if "oneOf" in schema:
+            for option in schema["oneOf"]:
+                coerced = self._coerce_value_to_type(value, option)
+                if coerced is not value:  # Coercion succeeded
+                    return coerced
+            return value
+
+        # Handle array types
+        if schema.get("type") == "array" and "items" in schema:
+            if isinstance(value, list):
+                # Recursively coerce array items
+                items_schema = schema["items"]
+                return [
+                    self._coerce_value_to_type(item, items_schema) for item in value
+                ]
+            return value
+
+        # Get the expected type
+        expected_type = schema.get("type")
+
+        # Don't coerce if schema expects string type
+        if expected_type == "string":
+            return value
+
+        # Try to coerce based on expected type
+        if expected_type == "integer":
+            try:
+                # Only parse as int if it represents an integer (not a float)
+                if "." not in value:
+                    return int(value)
+            except (ValueError, TypeError):
+                # If coercion fails, return the original value as per function design
+                pass
+        elif expected_type == "number":
+            try:
+                return float(value)
+            except (ValueError, TypeError):
+                pass
+        elif expected_type == "boolean":
+            # Handle common boolean string representations
+            lower_value = value.lower().strip()
+            if lower_value in ("true", "1", "yes", "on"):
+                return True
+            elif lower_value in ("false", "0", "no", "off"):
+                return False
+
+        return value
+
+    def _coerce_arguments_to_schema(self, function_name: str, arguments: dict) -> dict:
+        """
+        Coerce all arguments for a tool to match their schema expectations.
+
+        Args:
+            function_name: Name of the tool
+            arguments: Dictionary of arguments to coerce
+
+        Returns:
+            New dictionary with coerced arguments
+        """
+        if function_name not in self.all_tool_dict:
+            return arguments
+
+        tool_config = self.all_tool_dict[function_name]
+        parameter_schema = tool_config.get("parameter", {})
+        properties = parameter_schema.get("properties", {})
+
+        if not properties:
+            return arguments
+
+        coerced_args = {}
+        for param_name, param_value in arguments.items():
+            if param_name in properties:
+                param_schema = properties[param_name]
+                coerced_value = self._coerce_value_to_type(param_value, param_schema)
+
+                # Log when coercion occurs
+                if coerced_value != param_value:
+                    self.logger.debug(
+                        f"Coerced parameter '{param_name}' from "
+                        f"{param_value!r} ({type(param_value).__name__}) "
+                        f"to {coerced_value!r} ({type(coerced_value).__name__})"
+                    )
+
+                coerced_args[param_name] = coerced_value
+            else:
+                coerced_args[param_name] = param_value
+
+        return coerced_args
+
     def _validate_parameters(
         self, function_name: str, arguments: dict
     ) -> Optional[ToolError]:

{tooluniverse-1.0.11.1 → tooluniverse-1.0.11.2}/src/tooluniverse/python_executor_tool.py

@@ -206,20 +206,15 @@ class BasePythonExecutor:
         raise TimeoutError("Code execution timed out")
 
     def _execute_with_timeout(self, func, timeout_seconds: int, *args, **kwargs):
-        """Execute function with timeout using signal (Unix only)."""
-        if hasattr(signal, "SIGALRM"):  # Unix systems
-            old_handler = signal.signal(signal.SIGALRM, self._handle_timeout)
-            signal.alarm(timeout_seconds)
-            try:
-                result = func(*args, **kwargs)
-                return result
-            finally:
-                signal.alarm(0)
-                signal.signal(signal.SIGALRM, old_handler)
-        else:  # Windows or other systems
-            # Fallback to threading timeout (simpler but less reliable)
-            import threading
+        """Execute function with timeout using signal or threading."""
+        import threading
+
+        # Check if we're in the main thread
+        is_main_thread = threading.current_thread() is threading.main_thread()
 
+        # Use threading timeout if not in main thread or on Windows
+        if not is_main_thread or not hasattr(signal, "SIGALRM"):
+            # Use threading timeout (works in all threads)
             result_container = [None]
             exception_container = [None]
 
@@ -242,6 +237,41 @@ class BasePythonExecutor:
 
             return result_container[0]
 
+        # Use signal timeout only in main thread on Unix systems
+        else:
+            try:
+                old_handler = signal.signal(signal.SIGALRM, self._handle_timeout)
+                signal.alarm(timeout_seconds)
+                try:
+                    result = func(*args, **kwargs)
+                    return result
+                finally:
+                    signal.alarm(0)
+                    signal.signal(signal.SIGALRM, old_handler)
+            except (ValueError, AttributeError):
+                # Fallback to threading if signal fails for any reason
+                result_container = [None]
+                exception_container = [None]
+
+                def target():
+                    try:
+                        result_container[0] = func(*args, **kwargs)
+                    except Exception as e:
+                        exception_container[0] = e
+
+                thread = threading.Thread(target=target)
+                thread.daemon = True
+                thread.start()
+                thread.join(timeout_seconds)
+
+                if thread.is_alive():
+                    raise TimeoutError("Code execution timed out")
+
+                if exception_container[0]:
+                    raise exception_container[0]
+
+                return result_container[0]
+
     def _format_error_response(
         self,
         error: Exception,

{tooluniverse-1.0.11.1 → tooluniverse-1.0.11.2}/src/tooluniverse/smcp.py

@@ -2230,13 +2230,16 @@ class SMCP(FastMCP):
                         python_type = str
                         # For string type, don't add json_schema_extra - let Pydantic handle it
                     elif param_type == "integer":
-                        python_type = int
+                        # Allow both string and int for lenient coercion
+                        python_type = Union[int, str]
                         # For integer type, don't add json_schema_extra - let Pydantic handle it
                     elif param_type == "number":
-                        python_type = float
+                        # Allow both string and float for lenient coercion
+                        python_type = Union[float, str]
                         # For number type, don't add json_schema_extra - let Pydantic handle it
                     elif param_type == "boolean":
-                        python_type = bool
+                        # Allow both string and bool for lenient coercion
+                        python_type = Union[bool, str]
                         # For boolean type, don't add json_schema_extra - let Pydantic handle it
                     elif param_type == "array":
                         python_type = list
@@ -2334,32 +2337,21 @@ class SMCP(FastMCP):
                             )
                         )
 
-            # Add optional streaming parameter to signature
-            stream_field = Field(
-                description="Set to true to receive incremental streaming output (experimental)."
-            )
-            stream_annotation = Annotated[Union[bool, type(None)], stream_field]
-            param_annotations["_tooluniverse_stream"] = stream_annotation
-            func_params.append(
-                inspect.Parameter(
-                    "_tooluniverse_stream",
-                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                    default=None,
-                    annotation=stream_annotation,
-                )
-            )
-
-            # Note: ctx parameter removed as it causes Pydantic schema issues
-            # FastMCP context injection is handled internally by FastMCP
+            # Add _tooluniverse_stream as an optional parameter for streaming support
+            # This parameter is NOT exposed in the MCP schema (it's in kwargs but not in param_annotations)
+            # Users can pass it to enable streaming, but it won't appear in the tool schema
 
             async def dynamic_tool_function(**kwargs) -> str:
                 """Execute ToolUniverse tool with provided arguments."""
                 try:
                     # Remove ctx if present (legacy support)
                     ctx = kwargs.pop("ctx", None) if "ctx" in kwargs else None
-                    stream_flag = bool(kwargs.get("_tooluniverse_stream"))
+                    # Extract streaming flag (users can optionally pass this)
+                    stream_flag = bool(kwargs.pop("_tooluniverse_stream", False))
 
-                    # Filter out None values for optional parameters (preserve streaming flag)
+                    # Filter out None values for optional parameters
+                    # Note: _tooluniverse_stream was extracted and popped above
+                    # so it won't be in args_dict, which is what we want
                     args_dict = {k: v for k, v in kwargs.items() if v is not None}
 
                     # Validate required parameters (check against args_dict, not filtered_args)
@@ -2409,9 +2401,9 @@ class SMCP(FastMCP):
                         # Assign the function to stream_callback
                         stream_callback = _stream_callback
 
-                        # Ensure downstream tools see the streaming flag
-                        if "_tooluniverse_stream" not in args_dict:
-                            args_dict["_tooluniverse_stream"] = True
+                        # Note: _tooluniverse_stream was extracted from kwargs above
+                        # and is not passed to the tool. The stream_callback is sufficient
+                        # to enable streaming for downstream tools.
 
                     run_callable = functools.partial(
                         self.tooluniverse.run_one_function,

tooluniverse-1.0.11.2/src/tooluniverse/tools/UniProt_search.py

@@ -0,0 +1,98 @@
+"""
+UniProt_search
+
+Search UniProtKB database using flexible query syntax.
+Supports gene names (e.g., 'gene:TP53'), protein names,
+organism filters, and complex queries.
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def UniProt_search(
+    query: str,
+    organism: Optional[str] = None,
+    limit: Optional[int] = None,
+    fields: Optional[list[Any]] = None,
+    min_length: Optional[int] = None,
+    max_length: Optional[int] = None,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Search UniProtKB database with flexible query syntax.
+
+    Search UniProtKB and return protein entries. Supports field searches,
+    ranges, wildcards, boolean operators, and parentheses for grouping.
+
+    Parameters
+    ----------
+    query : str
+        Search query. Examples:
+        - Simple: 'MEIOB', 'insulin'
+        - Field: 'gene:TP53', 'organism_id:9606', 'reviewed:true'
+        - Range: 'length:[100 TO 500]', 'mass:[20000 TO 50000]'
+        - Wildcard: 'gene:MEIOB*'
+        - Boolean: 'gene:TP53 AND organism_id:9606'
+        - Grouped: '(organism_id:9606 OR organism_id:10090) AND
+          gene:TP53'
+    organism : str, optional
+        Organism filter. Use 'human', 'mouse', 'rat', 'yeast' or
+        taxonomy ID like '9606'. Combined with query using AND.
+    limit : int, optional
+        Maximum results to return (default: 25, max: 500).
+        Accepts string or integer.
+    fields : list[str], optional
+        Field names to return. When specified, returns raw API response.
+        Common: accession, id, gene_names, gene_primary, protein_name,
+        organism_name, organism_id, length, mass, sequence, reviewed,
+        cc_function.
+        Default: formatted response with accession, id, protein_name,
+        gene_names, organism, length.
+    min_length : int, optional
+        Minimum sequence length. Converts to 'length:[min TO *]'.
+    max_length : int, optional
+        Maximum sequence length. Converts to 'length:[* TO max]'.
+    stream_callback : callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    dict
+        Search results with total_results, returned count, and results
+        list
+
+    Examples
+    --------
+    >>> UniProt_search("gene:TP53", organism="human", limit=5)
+    >>> UniProt_search("insulin", fields=['accession', 'length'])
+    >>> UniProt_search("gene:MEIOB", min_length=400, max_length=500)
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "UniProt_search",
+            "arguments": {
+                "query": query,
+                "organism": organism,
+                "limit": limit,
+                "fields": fields,
+                "min_length": min_length,
+                "max_length": max_length,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["UniProt_search"]