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

tooluniverse/mgnify_tool.py

@@ -0,0 +1,181 @@
+import json
+from typing import Any, Dict
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from tooluniverse.tool_registry import register_tool
+
+
+def _http_get(
+    url: str,
+    headers: Dict[str, str] | None = None,
+    timeout: int = 30,
+) -> Dict[str, Any]:
+    req = Request(url, headers=headers or {})
+    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")}
+
+
+@register_tool(
+    "MGnifyStudiesTool",
+    config={
+        "name": "MGnify_search_studies",
+        "type": "MGnifyStudiesTool",
+        "description": "Search MGnify studies via /studies with optional biome/search filters",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "biome": {
+                    "type": "string",
+                    "description": "Biome identifier, e.g., 'root:Host-associated'",
+                },
+                "search": {
+                    "type": "string",
+                    "description": "Keyword to search in study title/description",
+                },
+                "size": {
+                    "type": "integer",
+                    "default": 10,
+                    "minimum": 1,
+                    "maximum": 100,
+                },
+            },
+        },
+        "settings": {
+            "base_url": "https://www.ebi.ac.uk/metagenomics/api/latest",
+            "timeout": 30,
+        },
+    },
+)
+class MGnifyStudiesTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://www.ebi.ac.uk/metagenomics/api/latest"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query: Dict[str, Any] = {}
+        if arguments.get("biome"):
+            query["biome"] = arguments["biome"]
+        if arguments.get("search"):
+            query["search"] = arguments["search"]
+        if arguments.get("size") is not None:
+            query["size"] = int(arguments["size"])
+        else:
+            query["size"] = 10
+
+        url = f"{base}/studies?{urlencode(query)}"
+        try:
+            api_response = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            # Wrap API response to match schema: data.data should be array
+            # API returns {"data": [...], "links": {...}, "meta": {...}}
+            # Schema expects {"data": {"data": [...]}}
+            if isinstance(api_response, dict) and "data" in api_response:
+                wrapped_data = {"data": api_response.get("data", [])}
+            else:
+                # Fallback if response format is unexpected
+                wrapped_data = {
+                    "data": api_response if isinstance(api_response, list) else []
+                }
+
+            return {
+                "source": "MGnify",
+                "endpoint": "studies",
+                "query": query,
+                "data": wrapped_data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "MGnify",
+                "endpoint": "studies",
+                "success": False,
+            }
+
+
+@register_tool(
+    "MGnifyAnalysesTool",
+    config={
+        "name": "MGnify_list_analyses",
+        "type": "MGnifyAnalysesTool",
+        "description": "List MGnify analyses via /analyses for a given study_accession",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "study_accession": {
+                    "type": "string",
+                    "description": "MGnify study accession, e.g., 'MGYS00000001'",
+                },
+                "size": {
+                    "type": "integer",
+                    "default": 10,
+                    "minimum": 1,
+                    "maximum": 100,
+                },
+            },
+            "required": ["study_accession"],
+        },
+        "settings": {
+            "base_url": "https://www.ebi.ac.uk/metagenomics/api/latest",
+            "timeout": 30,
+        },
+    },
+)
+class MGnifyAnalysesTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://www.ebi.ac.uk/metagenomics/api/latest"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query: Dict[str, Any] = {
+            "study_accession": arguments.get("study_accession"),
+        }
+        if arguments.get("size") is not None:
+            query["size"] = int(arguments["size"])
+        else:
+            query["size"] = 10
+
+        url = f"{base}/analyses?{urlencode(query)}"
+        try:
+            api_response = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            # Wrap API response to match schema: data.data should be array
+            # API returns {"data": [...], "links": {...}, "meta": {...}}
+            # Schema expects {"data": {"data": [...]}}
+            if isinstance(api_response, dict) and "data" in api_response:
+                wrapped_data = {"data": api_response.get("data", [])}
+            else:
+                # Fallback if response format is unexpected
+                wrapped_data = {
+                    "data": api_response if isinstance(api_response, list) else []
+                }
+
+            return {
+                "source": "MGnify",
+                "endpoint": "analyses",
+                "query": query,
+                "data": wrapped_data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "MGnify",
+                "endpoint": "analyses",
+                "success": False,
+            }

tooluniverse/obis_tool.py

@@ -0,0 +1,185 @@
+import json
+from typing import Any, Dict
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from tooluniverse.tool_registry import register_tool
+
+
+def _http_get(
+    url: str,
+    headers: Dict[str, str] | None = None,
+    timeout: int = 30,
+) -> Dict[str, Any]:
+    req = Request(url, headers=headers or {})
+    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")}
+
+
+@register_tool(
+    "OBISTaxaTool",
+    config={
+        "name": "OBIS_search_taxa",
+        "type": "OBISTaxaTool",
+        "description": "Resolve marine taxa by scientific name via OBIS /v3/taxon",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "scientificname": {
+                    "type": "string",
+                    "description": "Scientific name to search, e.g., 'Gadus'",
+                },
+                "size": {
+                    "type": "integer",
+                    "default": 10,
+                    "minimum": 1,
+                    "maximum": 100,
+                },
+            },
+            "required": ["scientificname"],
+        },
+        "settings": {"base_url": "https://api.obis.org/v3", "timeout": 30},
+    },
+)
+class OBISTaxaTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://api.obis.org/v3"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        scientificname = arguments.get("scientificname")
+        size = int(arguments.get("size", 10))
+
+        # Note: OBIS v3 API does not have /taxon endpoint
+        # Use occurrence search with scientificname filter instead
+        # This returns occurrences which can be used to identify taxa
+        query = {
+            "scientificname": scientificname,
+            "size": size,
+        }
+        url = f"{base}/occurrence?{urlencode(query)}"
+        try:
+            data = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            # Extract unique taxa from occurrences
+            if isinstance(data, dict) and "results" in data:
+                results = data.get("results", [])
+                # Extract unique scientific names and taxonomic info
+                taxa_list = []
+                seen_names = set()
+                for occ in results:
+                    sci_name = occ.get("scientificName")
+                    if sci_name and sci_name not in seen_names:
+                        seen_names.add(sci_name)
+                        taxa_list.append(
+                            {
+                                "scientificName": sci_name,
+                                "aphiaID": occ.get("aphiaID"),
+                                "rank": occ.get("taxonRank"),
+                                "kingdom": occ.get("kingdom"),
+                                "phylum": occ.get("phylum"),
+                                "class": occ.get("class_"),
+                                "order": occ.get("order"),
+                                "family": occ.get("family"),
+                                "genus": occ.get("genus"),
+                            }
+                        )
+                        if len(taxa_list) >= size:
+                            break
+                # Return in expected schema format
+                wrapped_data = {
+                    "results": taxa_list,
+                    "total": len(taxa_list),
+                }
+            else:
+                wrapped_data = {"results": [], "total": 0}
+
+            return {
+                "source": "OBIS",
+                "endpoint": "occurrence",  # Note: taxon endpoint not available, using occurrence
+                "query": query,
+                "data": wrapped_data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "OBIS",
+                "endpoint": "occurrence",
+                "success": False,
+            }
+
+
+@register_tool(
+    "OBISOccurrenceTool",
+    config={
+        "name": "OBIS_search_occurrences",
+        "type": "OBISOccurrenceTool",
+        "description": "Search OBIS occurrences via /v3/occurrence",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "scientificname": {
+                    "type": "string",
+                    "description": "Scientific name filter (optional)",
+                },
+                "areaid": {
+                    "type": "string",
+                    "description": "Area identifier filter (optional)",
+                },
+                "size": {
+                    "type": "integer",
+                    "default": 10,
+                    "minimum": 1,
+                    "maximum": 100,
+                },
+            },
+        },
+        "settings": {"base_url": "https://api.obis.org/v3", "timeout": 30},
+    },
+)
+class OBISOccurrenceTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://api.obis.org/v3"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query: Dict[str, Any] = {}
+        for key in ("scientificname", "areaid", "size"):
+            if key in arguments and arguments[key] is not None:
+                query[key] = arguments[key]
+        if "size" not in query:
+            query["size"] = 10
+
+        url = f"{base}/occurrence?{urlencode(query)}"
+        try:
+            data = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            return {
+                "source": "OBIS",
+                "endpoint": "occurrence",
+                "query": query,
+                "data": data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "OBIS",
+                "endpoint": "occurrence",
+                "success": False,
+            }

tooluniverse/pypi_package_inspector_tool.py

@@ -5,6 +5,7 @@ import time
 from datetime import datetime, timedelta
 from typing import Dict, Any
 from .tool_registry import register_tool
+from .base_tool import BaseTool
 
 
 @register_tool(
@@ -39,7 +40,7 @@ from .tool_registry import register_tool
         },
     },
 )
-class PyPIPackageInspector:
+class PyPIPackageInspector(BaseTool):
     """
     Extracts comprehensive package information from PyPI and GitHub.
     Provides detailed metrics on popularity, maintenance, security,
@@ -47,7 +48,7 @@ class PyPIPackageInspector:
     """
 
     def __init__(self, tool_config: Dict[str, Any] = None):
-        self.tool_config = tool_config or {}
+        BaseTool.__init__(self, tool_config or {})
         self.pypi_api_url = "https://pypi.org/pypi/{package}/json"
         self.pypistats_api_url = "https://pypistats.org/api/packages/{package}/recent"
         self.github_api_url = "https://api.github.com/repos/{owner}/{repo}"

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

@@ -0,0 +1,124 @@
+import json
+from typing import Any, Dict
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from tooluniverse.tool_registry import register_tool
+
+
+def _http_get(
+    url: str, headers: Dict[str, str] | None = None, timeout: int = 30
+) -> Dict[str, Any]:
+    req = Request(url, headers=headers or {})
+    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")}
+
+
+@register_tool(
+    "RNAcentralSearchTool",
+    config={
+        "name": "RNAcentral_search",
+        "type": "RNAcentralSearchTool",
+        "description": "Search RNA records via RNAcentral API",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "query": {"type": "string", "description": "Keyword or accession"},
+                "page_size": {
+                    "type": "integer",
+                    "default": 10,
+                    "minimum": 1,
+                    "maximum": 100,
+                },
+            },
+            "required": ["query"],
+        },
+        "settings": {"base_url": "https://rnacentral.org/api/v1", "timeout": 30},
+    },
+)
+class RNAcentralSearchTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://rnacentral.org/api/v1"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query = {
+            "query": arguments.get("query"),
+            "page_size": int(arguments.get("page_size", 10)),
+        }
+        url = f"{base}/rna/?{urlencode(query)}"
+        try:
+            data = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            return {
+                "source": "RNAcentral",
+                "endpoint": "rna",
+                "query": query,
+                "data": data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "RNAcentral",
+                "endpoint": "rna",
+                "success": False,
+            }
+
+
+@register_tool(
+    "RNAcentralGetTool",
+    config={
+        "name": "RNAcentral_get_by_accession",
+        "type": "RNAcentralGetTool",
+        "description": "Get RNAcentral entry by accession",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "accession": {"type": "string", "description": "RNAcentral accession"}
+            },
+            "required": ["accession"],
+        },
+        "settings": {"base_url": "https://rnacentral.org/api/v1", "timeout": 30},
+    },
+)
+class RNAcentralGetTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://rnacentral.org/api/v1"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        acc = arguments.get("accession")
+        url = f"{base}/rna/{acc}"
+        try:
+            data = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            return {
+                "source": "RNAcentral",
+                "endpoint": "rna/{accession}",
+                "accession": acc,
+                "data": data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "RNAcentral",
+                "endpoint": "rna/{accession}",
+                "accession": acc,
+                "success": False,
+            }

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

@@ -455,7 +455,7 @@ Examples:
 
     try:
         print(f"🚀 Starting {args.name}...", file=sys.stderr)
-        print("📡 Transport: stdio (for Claude Desktop)", file=sys.stderr)
+        print("📡 Transport: stdio", file=sys.stderr)
         print(f"🔍 Search enabled: {not args.no_search}", file=sys.stderr)
 
         if args.categories is not None: