tooluniverse 1.0.11.1__py3-none-any.whl → 1.0.12__py3-none-any.whl

tooluniverse/data/wikipathways_tools.json

@@ -0,0 +1,106 @@
+[
+  {
+    "name": "WikiPathways_search",
+    "type": "WikiPathwaysSearchTool",
+    "description": "Text search across community-curated pathways (disease, metabolic, signaling). Use to discover relevant pathways for a topic/gene set and obtain WPIDs for retrieval/visualization.",
+    "parameter": {
+      "type": "object",
+      "properties": {
+        "query": {
+          "type": "string",
+          "description": "Free-text query (keywords, gene symbols, processes), e.g., 'p53', 'glycolysis'."
+        },
+        "organism": {
+          "type": "string",
+          "description": "Organism filter (scientific name), e.g., 'Homo sapiens'."
+        }
+      },
+      "required": ["query"]
+    },
+    "fields": {
+      "endpoint": "https://webservice.wikipathways.org/findPathwaysByText",
+      "format": "json"
+    },
+    "return_schema": {
+      "type": "object",
+      "description": "WikiPathways search response",
+      "properties": {
+        "status": {"type": "string"},
+        "data": {
+          "type": "object",
+          "properties": {
+            "result": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "id": {"type": "string", "description": "WPID"},
+                  "name": {"type": "string"},
+                  "species": {"type": "string"}
+                }
+              }
+            }
+          }
+        },
+        "url": {"type": "string"}
+      }
+    },
+    "test_examples": [
+      {"query": "p53"},
+      {"query": "metabolism", "organism": "Homo sapiens"}
+    ],
+    "label": ["WikiPathways", "Pathway", "Search"],
+    "metadata": {
+      "tags": ["pathway", "enrichment", "visualization"],
+      "estimated_execution_time": "< 2 seconds"
+    }
+  },
+  {
+    "name": "WikiPathways_get_pathway",
+    "type": "WikiPathwaysGetTool",
+    "description": "Fetch pathway content by WPID (JSON/GPML). Use to programmatically access pathway nodes/edges/metadata for enrichment reporting or network visualization.",
+    "parameter": {
+      "type": "object",
+      "properties": {
+        "wpid": {
+          "type": "string",
+          "description": "WikiPathways identifier (e.g., 'WP254')."
+        },
+        "format": {
+          "type": "string",
+          "enum": ["json", "gpml"],
+          "default": "json",
+          "description": "Response format: 'json' for structured, 'gpml' for GPML XML."
+        }
+      },
+      "required": ["wpid"]
+    },
+    "fields": {
+      "endpoint": "https://webservice.wikipathways.org/getPathway",
+      "format": "json"
+    },
+    "return_schema": {
+      "type": "object",
+      "description": "WikiPathways getPathway response",
+      "properties": {
+        "status": {"type": "string"},
+        "data": {
+          "type": "object",
+          "properties": {
+            "pathway": {"type": "object"},
+            "metadata": {"type": "object"}
+          }
+        },
+        "url": {"type": "string"}
+      }
+    },
+    "test_examples": [
+      {"wpid": "WP254", "format": "json"}
+    ],
+    "label": ["WikiPathways", "Pathway", "Content"],
+    "metadata": {
+      "tags": ["pathway", "content", "gpml"],
+      "estimated_execution_time": "< 2 seconds"
+    }
+  }
+]

tooluniverse/default_config.py

@@ -51,6 +51,8 @@ default_tool_files = {
     "fatcat": os.path.join(current_dir, "data", "fatcat_tools.json"),
     "wikidata_sparql": os.path.join(current_dir, "data", "wikidata_sparql_tools.json"),
     "agents": os.path.join(current_dir, "data", "agentic_tools.json"),
+    # Smolagents tool wrapper configs
+    "smolagents": os.path.join(current_dir, "data", "smolagent_tools.json"),
     "tool_discovery_agents": os.path.join(
         current_dir, "data", "tool_discovery_agents.json"
     ),
@@ -181,8 +183,18 @@ default_tool_files = {
     "geo": os.path.join(current_dir, "data", "geo_tools.json"),
     "dbsnp": os.path.join(current_dir, "data", "dbsnp_tools.json"),
     "gnomad": os.path.join(current_dir, "data", "gnomad_tools.json"),
+    # Newly added database tools
+    "gbif": os.path.join(current_dir, "data", "gbif_tools.json"),
+    "obis": os.path.join(current_dir, "data", "obis_tools.json"),
+    "wikipathways": os.path.join(current_dir, "data", "wikipathways_tools.json"),
+    "rnacentral": os.path.join(current_dir, "data", "rnacentral_tools.json"),
+    "encode": os.path.join(current_dir, "data", "encode_tools.json"),
+    "gtex": os.path.join(current_dir, "data", "gtex_tools.json"),
+    "mgnify": os.path.join(current_dir, "data", "mgnify_tools.json"),
+    "gdc": os.path.join(current_dir, "data", "gdc_tools.json"),
     # Ontology tools
     "ols": os.path.join(current_dir, "data", "ols_tools.json"),
+    "optimizer": os.path.join(current_dir, "data", "optimizer_tools.json"),
 }
 
 

tooluniverse/encode_tool.py

@@ -0,0 +1,245 @@
+import json
+from typing import Any, Dict
+from urllib.error import HTTPError
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from tooluniverse.tool_registry import register_tool
+from tooluniverse.exceptions import (
+    ToolError,
+    ToolAuthError,
+    ToolRateLimitError,
+    ToolUnavailableError,
+    ToolValidationError,
+    ToolConfigError,
+    ToolDependencyError,
+    ToolServerError,
+)
+
+
+def _http_get(
+    url: str,
+    headers: Dict[str, str] | None = None,
+    timeout: int = 30,
+) -> Dict[str, Any]:
+    req = Request(url, headers=headers or {})
+    try:
+        with urlopen(req, timeout=timeout) as resp:
+            data = resp.read()
+            try:
+                return json.loads(data.decode("utf-8", errors="ignore"))
+            except Exception:
+                return {"raw": data.decode("utf-8", errors="ignore")}
+    except HTTPError as e:
+        # ENCODE API may return 404 even with valid JSON data
+        # Read the response body from the error
+        try:
+            data = e.read()
+            parsed = json.loads(data.decode("utf-8", errors="ignore"))
+            # If we got valid JSON, return it even though status was 404
+            return parsed
+        except Exception:
+            # If we can't parse, re-raise the original error
+            raise
+
+
+@register_tool(
+    "ENCODESearchTool",
+    config={
+        "name": "ENCODE_search_experiments",
+        "type": "ENCODESearchTool",
+        "description": "Search ENCODE experiments",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "assay_title": {"type": "string"},
+                "target": {"type": "string"},
+                "organism": {"type": "string"},
+                "status": {"type": "string", "default": "released"},
+                "limit": {"type": "integer", "default": 10},
+            },
+        },
+        "settings": {"base_url": "https://www.encodeproject.org", "timeout": 30},
+    },
+)
+class ENCODESearchTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def handle_error(self, exception: Exception) -> ToolError:
+        """Classify exceptions into structured ToolError."""
+        error_str = str(exception).lower()
+        if any(
+            kw in error_str
+            for kw in ["auth", "unauthorized", "401", "403", "api key", "token"]
+        ):
+            return ToolAuthError(f"Authentication failed: {exception}")
+        elif any(
+            kw in error_str for kw in ["rate limit", "429", "quota", "limit exceeded"]
+        ):
+            return ToolRateLimitError(f"Rate limit exceeded: {exception}")
+        elif any(
+            kw in error_str
+            for kw in [
+                "unavailable",
+                "timeout",
+                "connection",
+                "network",
+                "not found",
+                "404",
+            ]
+        ):
+            return ToolUnavailableError(f"Tool unavailable: {exception}")
+        elif any(
+            kw in error_str for kw in ["validation", "invalid", "schema", "parameter"]
+        ):
+            return ToolValidationError(f"Validation error: {exception}")
+        elif any(kw in error_str for kw in ["config", "configuration", "setup"]):
+            return ToolConfigError(f"Configuration error: {exception}")
+        elif any(
+            kw in error_str for kw in ["import", "module", "dependency", "package"]
+        ):
+            return ToolDependencyError(f"Dependency error: {exception}")
+        else:
+            return ToolServerError(f"Unexpected error: {exception}")
+
+    def run(self, arguments: Dict[str, Any]):
+        # Read from fields.endpoint or settings.base_url
+        fields = self.tool_config.get("fields", {})
+        settings = self.tool_config.get("settings", {})
+        endpoint = fields.get(
+            "endpoint",
+            settings.get("base_url", "https://www.encodeproject.org/search/"),
+        )
+        # Extract base URL if endpoint includes /search/
+        if endpoint.endswith("/search/"):
+            base = endpoint[:-7]  # Remove "/search/"
+        else:
+            base = endpoint.rstrip("/")
+        timeout = int(settings.get("timeout", 30))
+
+        query: Dict[str, Any] = {"type": "Experiment", "format": "json"}
+        for key in ("assay_title", "target", "organism", "status", "limit"):
+            if arguments.get(key) is not None:
+                query[key] = arguments[key]
+
+        # ENCODE API expects specific parameter format
+        # Build URL with proper query string
+        url = f"{base}/search/?{urlencode(query, doseq=True)}"
+        try:
+            data = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            return {
+                "source": "ENCODE",
+                "endpoint": "search",
+                "query": query,
+                "data": data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "ENCODE",
+                "endpoint": "search",
+                "success": False,
+            }
+
+
+@register_tool(
+    "ENCODEFilesTool",
+    config={
+        "name": "ENCODE_list_files",
+        "type": "ENCODEFilesTool",
+        "description": "List ENCODE files",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "file_type": {"type": "string"},
+                "assay_title": {"type": "string"},
+                "limit": {"type": "integer", "default": 10},
+            },
+        },
+        "settings": {"base_url": "https://www.encodeproject.org", "timeout": 30},
+    },
+)
+class ENCODEFilesTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def handle_error(self, exception: Exception) -> ToolError:
+        """Classify exceptions into structured ToolError."""
+        error_str = str(exception).lower()
+        if any(
+            kw in error_str
+            for kw in ["auth", "unauthorized", "401", "403", "api key", "token"]
+        ):
+            return ToolAuthError(f"Authentication failed: {exception}")
+        elif any(
+            kw in error_str for kw in ["rate limit", "429", "quota", "limit exceeded"]
+        ):
+            return ToolRateLimitError(f"Rate limit exceeded: {exception}")
+        elif any(
+            kw in error_str
+            for kw in [
+                "unavailable",
+                "timeout",
+                "connection",
+                "network",
+                "not found",
+                "404",
+            ]
+        ):
+            return ToolUnavailableError(f"Tool unavailable: {exception}")
+        elif any(
+            kw in error_str for kw in ["validation", "invalid", "schema", "parameter"]
+        ):
+            return ToolValidationError(f"Validation error: {exception}")
+        elif any(kw in error_str for kw in ["config", "configuration", "setup"]):
+            return ToolConfigError(f"Configuration error: {exception}")
+        elif any(
+            kw in error_str for kw in ["import", "module", "dependency", "package"]
+        ):
+            return ToolDependencyError(f"Dependency error: {exception}")
+        else:
+            return ToolServerError(f"Unexpected error: {exception}")
+
+    def run(self, arguments: Dict[str, Any]):
+        # Read from fields.endpoint or settings.base_url
+        fields = self.tool_config.get("fields", {})
+        settings = self.tool_config.get("settings", {})
+        endpoint = fields.get(
+            "endpoint",
+            settings.get("base_url", "https://www.encodeproject.org/search/"),
+        )
+        # Extract base URL if endpoint includes /search/
+        if endpoint.endswith("/search/"):
+            base = endpoint[:-7]  # Remove "/search/"
+        else:
+            base = endpoint.rstrip("/")
+        timeout = int(settings.get("timeout", 30))
+
+        query: Dict[str, Any] = {"type": "File", "format": "json"}
+        for key in ("file_type", "assay_title", "limit"):
+            if arguments.get(key):
+                query[key] = arguments[key]
+
+        url = f"{base}/search/?{urlencode(query)}"
+        try:
+            data = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            return {
+                "source": "ENCODE",
+                "endpoint": "search",
+                "query": query,
+                "data": data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "ENCODE",
+                "endpoint": "search",
+                "success": False,
+            }

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)
 
@@ -1398,8 +1404,12 @@ class ToolUniverse:
             # Validate tools have required fields
             valid_tools = []
             for tool in tools_in_file:
+                # Validate that tool is a dict, has "name" field, and name is a string
                 if isinstance(tool, dict) and "name" in tool:
-                    valid_tools.append(tool)
+                    name_value = tool["name"]
+                    # Ensure name is a string (not a dict/object) - this filters out schema files
+                    if isinstance(name_value, str):
+                        valid_tools.append(tool)
 
             return valid_tools
 
@@ -1422,7 +1432,13 @@ class ToolUniverse:
         for _category, file_path in self.tool_files.items():
             tools_in_category = self._read_tools_from_file(file_path)
             all_tools.extend(tools_in_category)
-            all_tool_names.update([tool["name"] for tool in tools_in_category])
+            # Only add string names to the set (filter out any non-string names as extra safety)
+            tool_names = [
+                tool["name"]
+                for tool in tools_in_category
+                if isinstance(tool.get("name"), str)
+            ]
+            all_tool_names.update(tool_names)
 
         # Also include remote tools
         try:
@@ -1435,7 +1451,13 @@ class ToolUniverse:
                     remote_tools = self._read_tools_from_file(fpath)
                     if remote_tools:
                         all_tools.extend(remote_tools)
-                        all_tool_names.update([tool["name"] for tool in remote_tools])
+                        # Only add string names to the set (filter out any non-string names as extra safety)
+                        tool_names = [
+                            tool["name"]
+                            for tool in remote_tools
+                            if isinstance(tool.get("name"), str)
+                        ]
+                        all_tool_names.update(tool_names)
         except Exception as e:
             warning(f"Warning: Failed to scan remote tools directory: {e}")
 
@@ -1459,11 +1481,17 @@ class ToolUniverse:
             warning(f"Warning: Data directory not found: {data_dir}")
             return all_tools, all_tool_names
 
-        # Recursively find all JSON files
+        # Recursively find all JSON files, excluding schema files
         json_files = []
         for root, _dirs, files in os.walk(data_dir):
+            # Skip schemas directory (contains JSON schema definition files, not tool configs)
+            if "schemas" in root:
+                continue
             for file in files:
                 if file.lower().endswith(".json"):
+                    # Skip files with "schema" in the name
+                    if "schema" in file.lower():
+                        continue
                     json_files.append(os.path.join(root, file))
 
         self.logger.debug(f"Found {len(json_files)} JSON files to scan")
@@ -1473,7 +1501,13 @@ class ToolUniverse:
             tools_in_file = self._read_tools_from_file(json_file)
             if tools_in_file:
                 all_tools.extend(tools_in_file)
-                all_tool_names.update([tool["name"] for tool in tools_in_file])
+                # Only add string names to the set (filter out any non-string names as extra safety)
+                tool_names = [
+                    tool["name"]
+                    for tool in tools_in_file
+                    if isinstance(tool.get("name"), str)
+                ]
+                all_tool_names.update(tool_names)
                 self.logger.debug(f"Loaded {len(tools_in_file)} tools from {json_file}")
 
         self.logger.info(
@@ -1862,7 +1896,10 @@ class ToolUniverse:
                 continue
 
             tool_instance = self._ensure_tool_instance(job)
-            if not tool_instance or not tool_instance.supports_caching():
+            if (
+                not tool_instance
+                or not getattr(tool_instance, "supports_caching", lambda: True)()
+            ):
                 continue
 
             cache_key = tool_instance.get_cache_key(job.arguments or {})
@@ -2081,7 +2118,10 @@ class ToolUniverse:
 
         if cache_enabled:
             tool_instance = self._get_tool_instance(function_name, cache=True)
-            if tool_instance and tool_instance.supports_caching():
+            if (
+                tool_instance
+                and getattr(tool_instance, "supports_caching", lambda: True)()
+            ):
                 cache_namespace = tool_instance.get_cache_namespace()
                 cache_version = tool_instance.get_cache_version()
                 cache_key = self._make_cache_key(function_name, arguments)
@@ -2113,21 +2153,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
@@ -2198,7 +2245,11 @@ class ToolUniverse:
                 )
 
             # Cache result if enabled
-            if cache_enabled and tool_instance and tool_instance.supports_caching():
+            if (
+                cache_enabled
+                and tool_instance
+                and getattr(tool_instance, "supports_caching", lambda: True)()
+            ):
                 if cache_key is None:
                     cache_key = self._make_cache_key(function_name, arguments)
                 if cache_namespace is None:
@@ -2421,6 +2472,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]: