tooluniverse 1.0.7__py3-none-any.whl → 1.0.8__py3-none-any.whl

tooluniverse/markitdown_tool.py

@@ -0,0 +1,159 @@
+"""
+MarkItDown Tool for ToolUniverse
+
+Simple implementation following Microsoft's official MCP pattern.
+Supports http:, https:, file:, data: URIs.
+"""
+
+import os
+import subprocess
+import sys
+import urllib.parse
+import urllib.request
+import tempfile
+from typing import Dict, Any
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("MarkItDownTool")
+class MarkItDownTool(BaseTool):
+    """MarkItDown tool for converting files to Markdown."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.tool_name = tool_config.get("name", "MarkItDownTool")
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute MarkItDown tool."""
+        try:
+            return self._convert_to_markdown(arguments)
+        except Exception as e:
+            return {"error": str(e)}
+
+    def _convert_to_markdown(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Convert a resource described by URI to Markdown using markitdown CLI."""
+        uri = arguments.get("uri")
+        output_path = arguments.get("output_path")
+        enable_plugins = arguments.get("enable_plugins", False)
+
+        if not uri:
+            return {"error": "URI is required"}
+
+        try:
+            # Parse URI
+            parsed_uri = urllib.parse.urlparse(uri)
+            scheme = parsed_uri.scheme.lower()
+
+            # Handle different URI schemes
+            if scheme in ["http", "https"]:
+                # Download from URL
+                temp_file = self._download_from_url(uri)
+                if not temp_file:
+                    return {"error": f"Failed to download from URL: {uri}"}
+                input_path = temp_file
+                cleanup_temp = True
+
+            elif scheme == "file":
+                # Local file
+                file_path = urllib.request.url2pathname(parsed_uri.path)
+                if not os.path.exists(file_path):
+                    return {"error": f"File not found: {file_path}"}
+                input_path = file_path
+                cleanup_temp = False
+
+            elif scheme == "data":
+                # Data URI
+                temp_file = self._handle_data_uri(uri)
+                if not temp_file:
+                    return {"error": f"Failed to process data URI: {uri}"}
+                input_path = temp_file
+                cleanup_temp = True
+
+            else:
+                return {
+                    "error": f"Unsupported URI scheme: {scheme}. Supported schemes: http, https, file, data"
+                }
+
+            # Build markitdown command
+            cmd = [sys.executable, "-m", "markitdown", input_path]
+            if enable_plugins:
+                cmd.append("--use-plugins")
+            if output_path:
+                cmd.extend(["-o", output_path])
+
+            # Execute command
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+
+            if result.returncode != 0:
+                error_msg = f"MarkItDown failed: {result.stderr}"
+                if cleanup_temp and os.path.exists(input_path):
+                    os.unlink(input_path)
+                return {"error": error_msg}
+
+            # Get markdown content
+            if output_path and os.path.exists(output_path):
+                with open(output_path, "r", encoding="utf-8") as f:
+                    markdown_content = f.read()
+            else:
+                markdown_content = result.stdout
+
+            # Clean up temporary file if needed
+            if cleanup_temp and os.path.exists(input_path):
+                os.unlink(input_path)
+
+            # Prepare response
+            response = {
+                "markdown_content": markdown_content,
+                "file_info": {
+                    "original_uri": uri,
+                    "uri_scheme": scheme,
+                    "output_file": output_path if output_path else None,
+                },
+            }
+
+            # If no output_path specified, also return the content as a string for convenience
+            if not output_path:
+                response["content"] = markdown_content
+
+            return response
+
+        except Exception as e:
+            return {"error": f"URI processing failed: {str(e)}"}
+
+    def _download_from_url(self, url: str) -> str:
+        """Download content from URL to temporary file."""
+        try:
+            with urllib.request.urlopen(url, timeout=30) as response:
+                content = response.read()
+
+            # Create temporary file
+            with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+                temp_file.write(content)
+                return temp_file.name
+        except Exception:
+            return None
+
+    def _handle_data_uri(self, data_uri: str) -> str:
+        """Handle data URI and save to temporary file."""
+        try:
+            # Parse data URI: data:[<mediatype>][;base64],<data>
+            if "," not in data_uri:
+                return None
+
+            header, data = data_uri.split(",", 1)
+
+            # Check if base64 encoded
+            if ";base64" in header:
+                import base64
+
+                content = base64.b64decode(data)
+            else:
+                content = data.encode("utf-8")
+
+            # Create temporary file
+            with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+                temp_file.write(content)
+                return temp_file.name
+        except Exception:
+            return None

tooluniverse/mcp_client_tool.py

@@ -26,18 +26,23 @@ class BaseMCPClient:
 
     def __init__(self, server_url: str, transport: str = "http", timeout: int = 30):
         self.server_url = os.path.expandvars(server_url)
-        self.transport = transport
+        # Normalize transport for backward compatibility: treat 'stdio' as HTTP
+        normalized_transport = (
+            transport.lower() if isinstance(transport, str) else "http"
+        )
+        if normalized_transport == "stdio":
+            normalized_transport = "http"
+        self.transport = normalized_transport
         self.timeout = timeout
         self.session = None
         self.mcp_session_id = None
         self._initialized = False
 
-        # Validate transport
+        # Validate transport (accept 'stdio' via normalization above)
         supported_transports = ["http", "websocket"]
         if self.transport not in supported_transports:
-            raise ValueError(
-                f"Invalid transport '{self.transport}'. Supported: {supported_transports}"
-            )
+            # Keep message concise to satisfy line length rules
+            raise ValueError("Invalid transport")
 
     async def _ensure_session(self):
         """Ensure HTTP session is available for HTTP transport"""

tooluniverse/smcp.py

@@ -2265,22 +2265,17 @@ class SMCP(FastMCP):
 
                     # Filter out None values for optional parameters (preserve streaming flag)
                     args_dict = {k: v for k, v in kwargs.items() if v is not None}
-                    filtered_args = {
-                        k: v
-                        for k, v in args_dict.items()
-                        if k != "_tooluniverse_stream"
-                    }
 
-                    # Validate required parameters
+                    # Validate required parameters (check against args_dict, not filtered_args)
                     missing_required = [
-                        param for param in required_params if param not in filtered_args
+                        param for param in required_params if param not in args_dict
                     ]
                     if missing_required:
                         return json.dumps(
                             {
                                 "error": f"Missing required parameters: {missing_required}",
                                 "required": required_params,
-                                "provided": list(filtered_args.keys()),
+                                "provided": list(args_dict.keys()),
                             },
                             indent=2,
                         )
@@ -2289,9 +2284,12 @@ class SMCP(FastMCP):
 
                     loop = asyncio.get_event_loop()
 
+                    # Initialize stream_callback to None by default
+                    stream_callback = None
+
                     if stream_flag and ctx is not None:
 
-                        def stream_callback(chunk: str) -> None:
+                        def _stream_callback(chunk: str) -> None:
                             if not chunk:
                                 return
                             try:
@@ -2312,6 +2310,9 @@ class SMCP(FastMCP):
                                     f"Failed to dispatch stream chunk for {tool_name}: {cb_error}"
                                 )
 
+                        # 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

tooluniverse/string_tool.py

@@ -0,0 +1,112 @@
+"""
+STRING Database REST API Tool
+
+This tool provides access to protein-protein interaction data from the STRING
+database. STRING is a database of known and predicted protein-protein
+interactions.
+"""
+
+import requests
+from typing import Dict, Any, List
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+STRING_BASE_URL = "https://string-db.org/api"
+
+
+@register_tool("STRINGRESTTool")
+class STRINGRESTTool(BaseTool):
+    """
+    STRING Database REST API tool.
+    Generic wrapper for STRING API endpoints defined in ppi_tools.json.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        fields = tool_config.get("fields", {})
+        parameter = tool_config.get("parameter", {})
+
+        self.endpoint_template: str = fields.get("endpoint", "/tsv/network")
+        self.required: List[str] = parameter.get("required", [])
+        self.output_format: str = fields.get("return_format", "TSV")
+
+    def _build_url(self, arguments: Dict[str, Any]) -> str | Dict[str, Any]:
+        """Build URL for STRING API request."""
+        url_path = self.endpoint_template
+        return STRING_BASE_URL + url_path
+
+    def _build_params(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Build parameters for STRING API request."""
+        params = {}
+
+        # Map protein IDs to STRING format
+        if "protein_ids" in arguments:
+            protein_ids = arguments["protein_ids"]
+            if isinstance(protein_ids, list):
+                params["identifiers"] = "\r".join(protein_ids)
+            else:
+                params["identifiers"] = str(protein_ids)
+
+        # Add other parameters
+        if "species" in arguments:
+            params["species"] = arguments["species"]
+        if "confidence_score" in arguments:
+            params["required_score"] = int(arguments["confidence_score"] * 1000)
+        if "limit" in arguments:
+            params["limit"] = arguments["limit"]
+        if "network_type" in arguments:
+            params["network_type"] = arguments["network_type"]
+
+        return params
+
+    def _make_request(self, url: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Perform a GET request and handle common errors."""
+        try:
+            response = requests.get(url, params=params, timeout=30)
+            response.raise_for_status()
+
+            if self.output_format == "TSV":
+                return self._parse_tsv_response(response.text)
+            else:
+                return response.json()
+
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Request failed: {str(e)}"}
+        except Exception as e:
+            return {"error": f"Unexpected error: {str(e)}"}
+
+    def _parse_tsv_response(self, text: str) -> Dict[str, Any]:
+        """Parse TSV response from STRING API."""
+        lines = text.strip().split("\n")
+        if len(lines) < 2:
+            return {"data": [], "error": "No data returned"}
+
+        # Parse header
+        header = lines[0].split("\t")
+
+        # Parse data rows
+        data = []
+        for line in lines[1:]:
+            if line.strip():
+                values = line.split("\t")
+                row = {}
+                for i, value in enumerate(values):
+                    if i < len(header):
+                        row[header[i]] = value
+                data.append(row)
+
+        return {"data": data, "header": header}
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the tool with given arguments."""
+        # Validate required parameters
+        for param in self.required:
+            if param not in arguments:
+                return {"error": f"Missing required parameter: {param}"}
+
+        url = self._build_url(arguments)
+        if isinstance(url, dict) and "error" in url:
+            return url
+
+        params = self._build_params(arguments)
+        return self._make_request(url, params)

tooluniverse/tools/ADMETAnalyzerAgent.py

@@ -0,0 +1,59 @@
+"""
+ADMETAnalyzerAgent
+
+AI agent that analyzes ADMET data and provides insights on drug-likeness and safety profiles
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ADMETAnalyzerAgent(
+    compounds: str,
+    admet_data: str,
+    disease_context: Optional[str] = "",
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    AI agent that analyzes ADMET data and provides insights on drug-likeness and safety profiles
+
+    Parameters
+    ----------
+    compounds : str
+        List of compounds to analyze (comma-separated)
+    admet_data : str
+        ADMET data from computational tools to analyze
+    disease_context : str
+        Disease context for ADMET evaluation
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ADMETAnalyzerAgent",
+            "arguments": {
+                "compounds": compounds,
+                "admet_data": admet_data,
+                "disease_context": disease_context,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ADMETAnalyzerAgent"]

tooluniverse/tools/ArXiv_search_papers.py

@@ -10,9 +10,9 @@ from ._shared_client import get_shared_client
 
 def ArXiv_search_papers(
     query: str,
-    limit: int,
-    sort_by: str,
-    sort_order: str,
+    limit: Optional[int] = 10,
+    sort_by: Optional[str] = "relevance",
+    sort_order: Optional[str] = "descending",
     *,
     stream_callback: Optional[Callable[[str], None]] = None,
     use_cache: bool = False,

tooluniverse/tools/CMA_Guidelines_Search.py

@@ -0,0 +1,52 @@
+"""
+CMA_Guidelines_Search
+
+Search Canadian Medical Association (CMA) Infobase guidelines. Contains over 1200 evidence-based ...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def CMA_Guidelines_Search(
+    query: str,
+    limit: int,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> list[Any]:
+    """
+    Search Canadian Medical Association (CMA) Infobase guidelines. Contains over 1200 evidence-based ...
+
+    Parameters
+    ----------
+    query : str
+        Medical condition, treatment, or clinical topic to search for in CMA guidelin...
+    limit : int
+        Maximum number of guidelines to return (default: 10)
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    list[Any]
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "CMA_Guidelines_Search",
+            "arguments": {"query": query, "limit": limit},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["CMA_Guidelines_Search"]

tooluniverse/tools/CORE_search_papers.py

@@ -11,9 +11,9 @@ from ._shared_client import get_shared_client
 def CORE_search_papers(
     query: str,
     limit: int,
-    year_from: int,
-    year_to: int,
-    language: str,
+    year_from: Optional[int] = None,
+    year_to: Optional[int] = None,
+    language: Optional[str] = None,
     *,
     stream_callback: Optional[Callable[[str], None]] = None,
     use_cache: bool = False,

tooluniverse/tools/ClinVar_search_variants.py

@@ -0,0 +1,52 @@
+"""
+ClinVar_search_variants
+
+Search ClinVar via NCBI E-utilities (esearch→esummary) and return concise variant records for a q...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ClinVar_search_variants(
+    query: str,
+    retmax: Optional[int] = 5,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> list[Any]:
+    """
+    Search ClinVar via NCBI E-utilities (esearch→esummary) and return concise variant records for a q...
+
+    Parameters
+    ----------
+    query : str
+        ClinVar search term (e.g., BRCA1).
+    retmax : int
+        Max records.
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    list[Any]
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ClinVar_search_variants",
+            "arguments": {"query": query, "retmax": retmax},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ClinVar_search_variants"]

tooluniverse/tools/ClinicalTrialDesignAgent.py

@@ -0,0 +1,63 @@
+"""
+ClinicalTrialDesignAgent
+
+AI agent that designs clinical trial protocols based on preclinical data and regulatory requirements
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ClinicalTrialDesignAgent(
+    drug_name: str,
+    indication: str,
+    preclinical_data: Optional[str] = "",
+    target_population: Optional[str] = "General adult population",
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    AI agent that designs clinical trial protocols based on preclinical data and regulatory requirements
+
+    Parameters
+    ----------
+    drug_name : str
+        Name of the drug candidate
+    indication : str
+        Disease indication
+    preclinical_data : str
+        Preclinical efficacy and safety data
+    target_population : str
+        Target patient population
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ClinicalTrialDesignAgent",
+            "arguments": {
+                "drug_name": drug_name,
+                "indication": indication,
+                "preclinical_data": preclinical_data,
+                "target_population": target_population,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ClinicalTrialDesignAgent"]

tooluniverse/tools/CompoundDiscoveryAgent.py

@@ -0,0 +1,59 @@
+"""
+CompoundDiscoveryAgent
+
+AI agent that analyzes potential drug compounds using multiple strategies and LLM reasoning
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def CompoundDiscoveryAgent(
+    disease_name: str,
+    targets: str,
+    context: Optional[str] = "",
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    AI agent that analyzes potential drug compounds using multiple strategies and LLM reasoning
+
+    Parameters
+    ----------
+    disease_name : str
+        Name of the disease
+    targets : str
+        List of therapeutic targets (comma-separated)
+    context : str
+        Additional context or specific requirements
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "CompoundDiscoveryAgent",
+            "arguments": {
+                "disease_name": disease_name,
+                "targets": targets,
+                "context": context,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["CompoundDiscoveryAgent"]

tooluniverse/tools/DOAJ_search_articles.py

@@ -10,8 +10,8 @@ from ._shared_client import get_shared_client
 
 def DOAJ_search_articles(
     query: str,
-    max_results: int,
-    type: str,
+    max_results: Optional[int] = 10,
+    type: Optional[str] = "articles",
     *,
     stream_callback: Optional[Callable[[str], None]] = None,
     use_cache: bool = False,