tooluniverse 1.0.11__py3-none-any.whl → 1.0.11.2__py3-none-any.whl

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/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/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/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/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]:
@@ -3046,6 +3176,9 @@ class ToolUniverse:
         # Extract tool configuration
         tools_config = config.get("tools", {})
 
+        # Handle tools_file parameter
+        tools_file_param = kwargs.get("tools_file")
+
         # Merge with override parameters
         tool_type = kwargs.get("tool_type") or tools_config.get("categories")
         exclude_tools = kwargs.get("exclude_tools") or tools_config.get(
@@ -3070,6 +3203,7 @@ class ToolUniverse:
             exclude_tools=exclude_tools,
             exclude_categories=exclude_categories,
             include_tools=include_tools,
+            tools_file=tools_file_param,  # KEY FIX: Pass tools_file
             include_tool_types=include_tool_types,
             exclude_tool_types=exclude_tool_types,
         )

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/smcp.py

@@ -386,8 +386,16 @@ class SMCP(FastMCP):
         for uri in space_list:
             print(f"📦 Loading Space: {uri}")
 
-            # Directly call ToolUniverse's method (complete reuse)
-            config = self.tooluniverse.load_space(uri)
+            # Pass filtering parameters from SMCP to load_space
+            config = self.tooluniverse.load_space(
+                uri,
+                exclude_tools=self.exclude_tools,
+                exclude_categories=self.exclude_categories,
+                include_tools=self.include_tools,
+                tools_file=self.tools_file,  # KEY FIX: Pass tools_file filter
+                include_tool_types=self.include_tool_types,
+                exclude_tool_types=self.exclude_tool_types,
+            )
 
             # Get configurations from ToolUniverse (complete reuse)
             self.space_metadata = self.tooluniverse.get_space_metadata()
@@ -2222,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
@@ -2326,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)
@@ -2401,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/tools/UniProt_search.py

@@ -1,7 +1,9 @@
 """
 UniProt_search
 
-Search UniProtKB database using flexible query syntax. Supports gene names (e.g., 'gene:TP53'), p...
+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
@@ -13,25 +15,48 @@ def UniProt_search(
     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 using flexible query syntax. Supports gene names (e.g., 'gene:TP53'), p...
+    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. Can be simple (e.g., 'MEIOB') or advanced ('gene:TP53 AND organ...
-    organism : str
-        Optional organism filter. Can use common name ('human') or taxonomy ID ('9606...
-    limit : int
-        Maximum number of results to return (default: 25, max: 500)
-    fields : list[Any]
-        Optional list of fields to return. Default returns: accession, id, protein_na...
-    stream_callback : Callable, optional
+        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
@@ -40,7 +65,15 @@ def UniProt_search(
 
     Returns
     -------
-    Any
+    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
 
@@ -52,6 +85,8 @@ def UniProt_search(
                 "organism": organism,
                 "limit": limit,
                 "fields": fields,
+                "min_length": min_length,
+                "max_length": max_length,
             },
         },
         stream_callback=stream_callback,

tooluniverse/uniprot_tool.py

@@ -1,7 +1,7 @@
 import time
 import requests
-from typing import Any, Dict
-from .base_tool import BaseTool
+from typing import Any, Dict, Optional
+from .base_tool import BaseTool, ToolError
 from .tool_registry import register_tool
 
 
@@ -13,6 +13,21 @@ class UniProtRESTTool(BaseTool):
         self.extract_path = tool_config["fields"].get("extract_path")
         self.timeout = 15  # Increase timeout for large entries
 
+    def validate_parameters(self, arguments: Dict[str, Any]) -> Optional[ToolError]:
+        """
+        Validate parameters with automatic type coercion for limit.
+        """
+        # Coerce limit to integer if passed as string
+        if "limit" in arguments and isinstance(arguments["limit"], str):
+            try:
+                arguments["limit"] = int(arguments["limit"])
+            except (ValueError, TypeError):
+                # Let schema validation handle the error
+                pass
+
+        # Call parent validation
+        return super().validate_parameters(arguments)
+
     def _build_url(self, args: Dict[str, Any]) -> str:
         url = self.endpoint
         for k, v in args.items():
@@ -107,8 +122,19 @@ class UniProtRESTTool(BaseTool):
         """Handle search queries with flexible parameters"""
         query = arguments.get("query", "")
         organism = arguments.get("organism", "")
-        limit = min(arguments.get("limit", 25), 500)
         fields = arguments.get("fields")
+        min_length = arguments.get("min_length")
+        max_length = arguments.get("max_length")
+
+        # Coerce limit to integer if passed as string
+        limit_value = arguments.get("limit", 25)
+        if isinstance(limit_value, str):
+            limit_value = int(limit_value)
+        limit = min(limit_value, 500)
+
+        # Normalize query: replace 'organism:' with 'organism_id:'
+        # for UniProt API compatibility
+        query = query.replace("organism:", "organism_id:")
 
         # Build query string
         query_parts = [query]
@@ -121,7 +147,18 @@ class UniProtRESTTool(BaseTool):
                 "yeast": "559292",
             }
             taxon_id = organism_map.get(organism.lower(), organism)
-            query_parts.append(f"organism_id:{taxon_id}")
+
+            # Check if query already includes organism_id filter
+            # to avoid duplication
+            if "organism_id:" not in query.lower():
+                query_parts.append(f"organism_id:{taxon_id}")
+            # If it does, skip adding the organism filter
+
+        # Auto-convert length parameters to range syntax
+        if min_length or max_length:
+            min_val = min_length if min_length else "*"
+            max_val = max_length if max_length else "*"
+            query_parts.append(f"length:[{min_val} TO {max_val}]")
 
         full_query = " AND ".join(query_parts)
 
@@ -141,6 +178,16 @@ class UniProtRESTTool(BaseTool):
 
             # Extract results
             results = data.get("results", [])
+
+            # If custom fields requested, return raw API response for flexibility
+            if fields and isinstance(fields, list):
+                return {
+                    "total_results": data.get("resultsFound", 0),
+                    "returned": len(results),
+                    "results": results,  # Return raw results when custom fields used
+                }
+
+            # Otherwise, use formatted extraction logic
             formatted_results = []
 
             for entry in results:

{tooluniverse-1.0.11.dist-info → tooluniverse-1.0.11.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tooluniverse
-Version: 1.0.11
+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.dist-info → tooluniverse-1.0.11.2.dist-info}/RECORD

@@ -1,9 +1,9 @@
 tooluniverse/__init__.py,sha256=RcmpZgvV5Olhnu24jhZ6KFmLMN6oHby-vS52yt4HIhc,19251
 tooluniverse/admetai_tool.py,sha256=k83iqy8_BeE2R_xPJlZ-xaEwaTwNvGc0u4ZUMV7ocwk,3469
 tooluniverse/agentic_tool.py,sha256=jN7UC6uQp7fxpDYqJf_2BWOb3b9z1oZufFQCRXBVeDM,27723
-tooluniverse/alphafold_tool.py,sha256=NkKQttC0MfuetCTTcWTFEG2MdhyKwy3jb5TR4odiqAw,4658
+tooluniverse/alphafold_tool.py,sha256=c1XyFornqv1QYJkPcZd2Tmlevnm1PuwnNvB6sxjerMg,6350
 tooluniverse/arxiv_tool.py,sha256=60e5moGt3XnwZeKx_nrvRZrwAavE11ok0j78AI5F6Xs,3610
-tooluniverse/base_tool.py,sha256=B268ek7tmA3jH56tPhQEMmG2J_Q5xqhH_6GGES56lbk,12861
+tooluniverse/base_tool.py,sha256=QsoCPiEND2zWzVa-zDc7MmtrF3grmdKkb1X4OjDvc-4,13293
 tooluniverse/biogrid_tool.py,sha256=tszza6Kf1-PKsoVw5GIqLak20FvhFY_PFSVY9XxDuIQ,4274
 tooluniverse/biorxiv_tool.py,sha256=uffhxXMOWR6b2jzxka-Qss1LjliQTuX-skIIc7RAaPs,4133
 tooluniverse/blast_tool.py,sha256=BPvkxeMWboLpwLJmO3yi4u0Dx1vvKOqKVO5tLa4xvGM,4960
@@ -33,7 +33,7 @@ tooluniverse/enrichr_tool.py,sha256=beM7xZiZ6FdHgYQUSNb_jfkcbrNC8CumXNJgPE9e1PI,
 tooluniverse/ensembl_tool.py,sha256=Fjn7dABWpZ55DOQi0sBH2j84nPwSmU4yog3D2pBHAT4,4970
 tooluniverse/europe_pmc_tool.py,sha256=-3CAq5tDhS5NoeHifevadBgP_MHDZJdwNmM5SvjbAa8,6080
 tooluniverse/exceptions.py,sha256=3svVCG7H_G_8E1mco74KWi44u1M7V1JojVycSEWdi_o,5386
-tooluniverse/execute_function.py,sha256=76QpMQokYxAqHWC5Gewrv8VZa17n8PEFLfYSyNXxWRw,128247
+tooluniverse/execute_function.py,sha256=Kg-f_jXFKqoEcxlvFzdIY7wN77nln9prdGP-2h9X4_I,133347
 tooluniverse/extended_hooks.py,sha256=bBI9SZM6IFiHblsZscBotOFNwlkUNi1hrp3cS7JVuZk,15372
 tooluniverse/fatcat_tool.py,sha256=-QEOYbv6KEcrOiOa27Ms1xm0sySB-vW4rWEinsS6EDw,2051
 tooluniverse/file_download_tool.py,sha256=jFH8cFNvcd6snO2lMw1NCdZAPoQ5zoEHi7MGIeTTut4,9354
@@ -82,7 +82,7 @@ tooluniverse/pubchem_tool.py,sha256=14C_5uz0RNzv5HaSAXHlq13TZLtlkhmJhr7RrjI91Yk,
 tooluniverse/pubmed_tool.py,sha256=EYPL_fsUdHuL-yFFULavWZu8lPp23wVKIJ-avDLlFeQ,6146
 tooluniverse/pubtator_tool.py,sha256=WdFufeT3hY2lCq6vb9SLF44UYJ48PiZ1mf4bSfpI7mg,7151
 tooluniverse/pypi_package_inspector_tool.py,sha256=EvBA9TY3s-FHKy6QNpl8b5Q_7dlFCO85AQ8BcKi5Xpw,21653
-tooluniverse/python_executor_tool.py,sha256=8h3sE7nu3WsTNswYZ1h56--fTi7ey1WeQxbHG7dcIA4,26661
+tooluniverse/python_executor_tool.py,sha256=vBTvJagjUf4xPyppG90XRr8peCDGt-eZZfyFOVUNtiI,27773
 tooluniverse/rcsb_pdb_tool.py,sha256=8N6bvlD2KIHfNum_FvbXwIa96mKvHorno5ZdjAHgmrc,1550
 tooluniverse/reactome_tool.py,sha256=ngmJXCcQfsu5d8XcX258ZHW4DIBi45sSjYNwUBk8nxo,4481
 tooluniverse/regulomedb_tool.py,sha256=jPKd1rce0Yfn3Gns8MmcV0vgxmUTyjCH5sjfeQNyx0I,1117
@@ -91,7 +91,7 @@ tooluniverse/remote_tool.py,sha256=Sa7YNeitFaHyUS6P5gY79kqJdp4i6zHSr5VbM1SdQpI,3
 tooluniverse/restful_tool.py,sha256=H7alq_vO3G4iVgZIZrrWh9vq2ForJN52Fl7_QOq7yaM,4409
 tooluniverse/screen_tool.py,sha256=JuSj-qhFUSuYsHlyQzdXdOhVhEzVoJjSql1dWpLOp4A,1580
 tooluniverse/semantic_scholar_tool.py,sha256=gaDDL5Xy4Ij3qNqipZvwRfOBSyzGyIN8AANT-pYKHvI,3227
-tooluniverse/smcp.py,sha256=wO92aE65RIBZqvCCEmul-z3wFsCcv9xJqRhWEHVwE7E,107395
+tooluniverse/smcp.py,sha256=USjjf86NPBmR7xSQ0mGhekcEmADPZcS2rlL73sB9Dkw,107771
 tooluniverse/smcp_server.py,sha256=kLJesbeWOSL1eBhVlv5k1WCTG4BRLTpDEkfySyaFG-8,35214
 tooluniverse/string_tool.py,sha256=3rio0Lt97FuU6fbpykq3ETqD9pA4h_gPR0uXKRb7Zu4,3936
 tooluniverse/tool_finder_embedding.py,sha256=JDSPlI51grK51aX3072qc4mhbYVrhKaOLnY3hA7hDjM,11274
@@ -100,7 +100,7 @@ tooluniverse/tool_finder_llm.py,sha256=Pg2IFG8icLMxDUlFdx-L6Fw5ntAbCYo4cbPi5f54a
 tooluniverse/tool_graph_web_ui.py,sha256=68s1MPXTcT6bzdFfuat9gvSNjSgwHxNC-TztfH3raeQ,27987
 tooluniverse/tool_registry.py,sha256=DYA97MzFgIZ_8oAy0CTqg99pfz_bIS-0A-gbyLkiQuw,15616
 tooluniverse/unified_guideline_tools.py,sha256=Vhnqis4je3JZDJb7KfynAMX2D2yvW9I71_9mIsG1COU,88376
-tooluniverse/uniprot_tool.py,sha256=SXhvFyO5HR0xb3LIBpUKWbrjQ-sk5vQKjptXHkR8-Zk,14362
+tooluniverse/uniprot_tool.py,sha256=3aZSxKC75hz90UEjiEKxOAEekIIA3O3MsIj09xd7VEE,16336
 tooluniverse/unpaywall_tool.py,sha256=eqdsZZMRCOsMQjMzJRzkNk9xSwIWlsRrrPiTrIBDsFg,2070
 tooluniverse/url_tool.py,sha256=ofaAXpt5i6cUnAssM-jtJp73_cH1XaiByS9ZcGM9GI0,10023
 tooluniverse/uspto_tool.py,sha256=jvpCIQkNOI7v5F2CVttoHm8EKYnFgGUQzs9xXxZWEUE,8991
@@ -132,7 +132,7 @@ tooluniverse/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 tooluniverse/data/admetai_tools.json,sha256=08LCNSCZJxL6ZuPF1mVfbdlh9f2X5tnEwIYU7RcLLSM,6497
 tooluniverse/data/adverse_event_tools.json,sha256=gmO2euqIvLqc9lfmf9h9W0_TR33AYpMg_M1tzBNKm7w,12084
 tooluniverse/data/agentic_tools.json,sha256=vRoYpQZKdzaE7QvumwM47T18plgaiiNgrymwYIQS6wU,58360
-tooluniverse/data/alphafold_tools.json,sha256=fXyHxv_FuCfEkaP9IAJx_bU8a5BzDD73djD5ZO-F0r8,14856
+tooluniverse/data/alphafold_tools.json,sha256=G5C6GhU4rIesRaZbkuJAH3w__UtosvWedJ9XiJ0J54w,14177
 tooluniverse/data/arxiv_tools.json,sha256=v4FNgFMhNX2WBNajje1xpa5250kvifm_RXY1WzPGgFw,2591
 tooluniverse/data/biorxiv_tools.json,sha256=i7iNyLJDRCPlNd6QjQ9Ml0rUwkcBPjXLG3QOa6cT2sI,2007
 tooluniverse/data/blast_tools.json,sha256=8tMAZrXUpRGY_UxWAu3lGBdzZRSwy_D_huFMux747qk,3898
@@ -218,7 +218,7 @@ tooluniverse/data/tool_discovery_agents.json.backup,sha256=LXKpggu1F32PcyUHQQOTf
 tooluniverse/data/toolfinderkeyword_defaults.json,sha256=bydTVd0IUSDiilNQ6kZU-cn4lPqOfInfUAxhh8yMXqY,1050
 tooluniverse/data/txagent_client_tools.json,sha256=GdQk5H6uP_Uj9Ejz3nMdzNhZJV42t75aiRW8oWtkzRw,409
 tooluniverse/data/unified_guideline_tools.json,sha256=SzBhv6MCojmdtV6tGyZ5sUqskrr5zS_SQC5TXowVUAo,30688
-tooluniverse/data/uniprot_tools.json,sha256=nhJQ9E_kVKB16ehQNwRos8-QRbZJSXYODwgCr120xas,11101
+tooluniverse/data/uniprot_tools.json,sha256=8Hx39uBXsXXKeBlcljDZw9wLTklcx32kh8QIuIFjaWY,12361
 tooluniverse/data/unpaywall_tools.json,sha256=7ciTSVOeaCwmIA88Lrm_t17mNDqCxPZMtI1pHYsaRco,3123
 tooluniverse/data/url_fetch_tools.json,sha256=Z_wFzpj9XLUnrELk5KLFpj5pvxifOy2JepPhvmhVTJs,2719
 tooluniverse/data/uspto_downloader_tools.json,sha256=hMHwvP_hvuFg-upZAAXufywYKx031iQ0xuMyHfzu0uA,349
@@ -639,7 +639,7 @@ tooluniverse/tools/UniProt_get_recommended_name_by_accession.py,sha256=IxvU5rSqA
 tooluniverse/tools/UniProt_get_sequence_by_accession.py,sha256=NTqhL5XoApu6BFNaPPXjlaDk33Vu6rDkVsdXLOByU38,1171
 tooluniverse/tools/UniProt_get_subcellular_location_by_accession.py,sha256=oxANci3oT5W7_EB6nCtIPA75QADMFMOihs8ihziO9dI,1315
 tooluniverse/tools/UniProt_id_mapping.py,sha256=_dnr9B3YZg3Uw2u4N95z2l5cBzMb8sVt5K0pXkqkzSA,1742
-tooluniverse/tools/UniProt_search.py,sha256=XFrxQnYTZLjUygEBpszaCtJTcPCqgQOuige0N8SfpIQ,1769
+tooluniverse/tools/UniProt_search.py,sha256=ZhpY3rfdJb_mPFK3Kh6J4HjPWVlNPfeI5lfH58LYVPM,3213
 tooluniverse/tools/UnifiedToolGenerator.py,sha256=acNEyvmkFUxfrSLVC2hg6TOsa51gCdzmJGRCeNMYBPQ,1646
 tooluniverse/tools/Unpaywall_check_oa_status.py,sha256=ZQKQQ0f9dSQcEcI26-QCmSh3yCRmsGlQIGGHOMZuXz0,1409
 tooluniverse/tools/WHO_Guideline_Full_Text.py,sha256=GkM3_FjGc4t-VWYIdhW1t6zd_dRCyGv4ZQBKi78A5ZE,1236
@@ -974,9 +974,9 @@ tooluniverse/tools/visualize_molecule_3d.py,sha256=0fFkjGz0hrNyRBiXRV_FY8yWXR47j
 tooluniverse/tools/visualize_protein_structure_3d.py,sha256=ifTkgPvtNtvJ9q8d7zmSqSnd32oFmRcKkoO8p1SdVUU,2358
 tooluniverse/tools/web_api_documentation_search.py,sha256=AVw0w3LylreiKB6pCGooVUvZ1jydsuJnAzxD8HVf6vg,1707
 tooluniverse/tools/web_search.py,sha256=IjpR7Z6glY4DYX39YhSk6UP4bj5_f1LYAdr8WU9uaFk,1866
-tooluniverse-1.0.11.dist-info/licenses/LICENSE,sha256=0P0qDClpVzrnQUe3QAu7V-alszSBa-6hVHXyn9Xe60k,11351
-tooluniverse-1.0.11.dist-info/METADATA,sha256=w7fOeaTbP6NbMRL6tWhhJVbPp-6I10KQBMQvVhtW4i0,21362
-tooluniverse-1.0.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tooluniverse-1.0.11.dist-info/entry_points.txt,sha256=SAdqP4tU4mMOtp1YWaOHTwnIHhnoiD1wmfKGlSfNSy0,647
-tooluniverse-1.0.11.dist-info/top_level.txt,sha256=zZ8YeCJ5FAkEwdd_mxsFtSCQMBDgBdxrrmHo3RNBiWs,13
-tooluniverse-1.0.11.dist-info/RECORD,,
+tooluniverse-1.0.11.2.dist-info/licenses/LICENSE,sha256=0P0qDClpVzrnQUe3QAu7V-alszSBa-6hVHXyn9Xe60k,11351
+tooluniverse-1.0.11.2.dist-info/METADATA,sha256=a6BEnz8gyH38Qls_S_YtBbqFGJ3NI9JIghMOVAHX6GE,21364
+tooluniverse-1.0.11.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tooluniverse-1.0.11.2.dist-info/entry_points.txt,sha256=SAdqP4tU4mMOtp1YWaOHTwnIHhnoiD1wmfKGlSfNSy0,647
+tooluniverse-1.0.11.2.dist-info/top_level.txt,sha256=zZ8YeCJ5FAkEwdd_mxsFtSCQMBDgBdxrrmHo3RNBiWs,13
+tooluniverse-1.0.11.2.dist-info/RECORD,,