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

tooluniverse/smcp_server.py

@@ -7,6 +7,7 @@ It creates a minimal SMCP server that exposes all ToolUniverse tools as MCP tool
 """
 
 import argparse
+import os
 import sys
 from .smcp import SMCP
 
@@ -134,6 +135,22 @@ def run_stdio_server():
     This function provides compatibility with the original MCP server's run_claude_desktop function.
     It accepts the same arguments as run_smcp_server but forces transport='stdio'.
     """
+    # Set environment variable and reconfigure logging for stdio mode
+    os.environ["TOOLUNIVERSE_STDIO_MODE"] = "1"
+
+    # Import and reconfigure logging to stderr
+    from .logging_config import reconfigure_for_stdio
+
+    reconfigure_for_stdio()
+    # Ensure stdout is line-buffered for immediate JSON-RPC flushing in stdio mode
+    try:
+        import sys as _sys
+
+        if hasattr(_sys.stdout, "reconfigure"):
+            _sys.stdout.reconfigure(line_buffering=True)
+    except Exception:
+        pass
+
     parser = argparse.ArgumentParser(
         description="Start SMCP (Scientific Model Context Protocol) Server with stdio transport",
         formatter_class=argparse.RawDescriptionHelpFormatter,
@@ -297,107 +314,35 @@ Examples:
             from .execute_function import ToolUniverse
 
             tu = ToolUniverse()
-            tool_types = tu.get_tool_types()
+            # Use ToolUniverse API to list categories consistently
+            stats = tu.list_built_in_tools(mode="config", scan_all=False)
 
             print("Available tool categories:", file=sys.stderr)
             print("=" * 50, file=sys.stderr)
 
-            # Group categories for better readability
-            scientific_db = []
-            literature = []
-            software = []
-            special = []
-            clinical = []
-            other = []
-
-            for category in sorted(tool_types):
-                if category in [
-                    "uniprot",
-                    "ChEMBL",
-                    "opentarget",
-                    "pubchem",
-                    "hpa",
-                    "rcsb_pdb",
-                    "reactome",
-                    "go",
-                ]:
-                    scientific_db.append(category)
-                elif category in [
-                    "EuropePMC",
-                    "semantic_scholar",
-                    "pubtator",
-                    "OpenAlex",
-                ]:
-                    literature.append(category)
-                elif category.startswith("software_"):
-                    software.append(category)
-                elif category in [
-                    "special_tools",
-                    "tool_finder",
-                    "tool_composition",
-                    "agents",
-                ]:
-                    special.append(category)
-                elif category in [
-                    "clinical_trials",
-                    "fda_drug_label",
-                    "fda_drug_adverse_event",
-                    "dailymed",
-                    "medlineplus",
-                ]:
-                    clinical.append(category)
-                else:
-                    other.append(category)
-
-            if scientific_db:
-                print("\n🔬 Scientific Databases:", file=sys.stderr)
-                for cat in scientific_db:
-                    print(f"  {cat}", file=sys.stderr)
-
-            if literature:
-                print("\n📚 Literature & Knowledge:", file=sys.stderr)
-                for cat in literature:
-                    print(f"  {cat}", file=sys.stderr)
-
-            if clinical:
-                print("\n🏥 Clinical & Drug Information:", file=sys.stderr)
-                for cat in clinical:
-                    print(f"  {cat}", file=sys.stderr)
-
-            if software:
-                print("\n💻 Software Tools:", file=sys.stderr)
-                for cat in software[:5]:  # Show first 5
-                    print(f"  {cat}", file=sys.stderr)
-                if len(software) > 5:
-                    print(
-                        f"  ... and {len(software, file=sys.stderr) - 5} more software categories"
-                    )
-
-            if special:
-                print("\n🛠 Special & Meta Tools:", file=sys.stderr)
-                for cat in special:
-                    print(f"  {cat}", file=sys.stderr)
-
-            if other:
-                print("\n📂 Other Categories:", file=sys.stderr)
-                for cat in other:
-                    print(f"  {cat}", file=sys.stderr)
+            categories = stats.get("categories", {})
+            # Sort by count desc, then name asc
+            sorted_items = sorted(
+                categories.items(), key=lambda kv: (-kv[1].get("count", 0), kv[0])
+            )
+            for key, info in sorted_items:
+                display = key.replace("_", " ").title()
+                count = info.get("count", 0)
+                print(f"  {display}: {count}", file=sys.stderr)
 
-            print(f"\nTotal: {len(tool_types, file=sys.stderr)} categories available")
-            print("\nCommon combinations:", file=sys.stderr)
             print(
-                "  Scientific research: uniprot ChEMBL opentarget pubchem hpa",
+                f"\nTotal categories: {stats.get('total_categories', 0)}",
                 file=sys.stderr,
             )
             print(
-                "  Drug discovery: ChEMBL fda_drug_label clinical_trials pubchem",
+                f"Total unique tools: {stats.get('total_tools', 0)}",
                 file=sys.stderr,
             )
+
             print(
-                "  Literature analysis: EuropePMC semantic_scholar pubtator",
+                "\nTip: Use --exclude-categories or --include-tools to customize loading",
                 file=sys.stderr,
             )
-            print("  Minimal setup: special_tools tool_finder", file=sys.stderr)
 
         except Exception as e:
             print(f"❌ Error listing categories: {e}", file=sys.stderr)
@@ -415,13 +360,20 @@ Examples:
             print("Available tools:", file=sys.stderr)
             print("=" * 50, file=sys.stderr)
 
-            # Group tools by category
+            # Group tools by category (use ToolUniverse's canonical 'type' field)
             tools_by_category = {}
             for tool in tu.all_tools:
-                tool_type = getattr(tool, "tool_type", "unknown")
+                # Handle both dict and object tool formats
+                if isinstance(tool, dict):
+                    tool_type = tool.get("type", "unknown")
+                    tool_name = tool.get("name", "unknown")
+                else:
+                    tool_type = getattr(tool, "type", "unknown")
+                    tool_name = getattr(tool, "name", "unknown")
+
                 if tool_type not in tools_by_category:
                     tools_by_category[tool_type] = []
-                tools_by_category[tool_type].append(tool.name)
+                tools_by_category[tool_type].append(tool_name)
 
             total_tools = 0
             for category in sorted(tools_by_category.keys()):
@@ -554,7 +506,7 @@ Examples:
             print("🔗 Hooks disabled", file=sys.stderr)
 
         print(f"⚡ Max workers: {args.max_workers}", file=sys.stderr)
-        print()
+        print(file=sys.stderr)
 
         # Create SMCP server with hook support
         server = SMCP(
@@ -769,96 +721,27 @@ Examples:
             from .execute_function import ToolUniverse
 
             tu = ToolUniverse()
-            tool_types = tu.get_tool_types()
+            # Use ToolUniverse API to list categories consistently
+            stats = tu.list_built_in_tools(mode="config", scan_all=False)
 
             print("Available tool categories:")
             print("=" * 50)
 
-            # Group categories for better readability
-            scientific_db = []
-            literature = []
-            software = []
-            special = []
-            clinical = []
-            other = []
-
-            for category in sorted(tool_types):
-                if category in [
-                    "uniprot",
-                    "ChEMBL",
-                    "opentarget",
-                    "pubchem",
-                    "hpa",
-                    "rcsb_pdb",
-                    "reactome",
-                    "go",
-                ]:
-                    scientific_db.append(category)
-                elif category in [
-                    "EuropePMC",
-                    "semantic_scholar",
-                    "pubtator",
-                    "OpenAlex",
-                ]:
-                    literature.append(category)
-                elif category.startswith("software_"):
-                    software.append(category)
-                elif category in [
-                    "special_tools",
-                    "tool_finder",
-                    "tool_composition",
-                    "agents",
-                ]:
-                    special.append(category)
-                elif category in [
-                    "clinical_trials",
-                    "fda_drug_label",
-                    "fda_drug_adverse_event",
-                    "dailymed",
-                    "medlineplus",
-                ]:
-                    clinical.append(category)
-                else:
-                    other.append(category)
-
-            if scientific_db:
-                print("\n🔬 Scientific Databases:")
-                for cat in scientific_db:
-                    print(f"  {cat}")
-
-            if literature:
-                print("\n📚 Literature & Knowledge:")
-                for cat in literature:
-                    print(f"  {cat}")
-
-            if clinical:
-                print("\n🏥 Clinical & Drug Information:")
-                for cat in clinical:
-                    print(f"  {cat}")
-
-            if software:
-                print("\n💻 Software Tools:")
-                for cat in software[:5]:  # Show first 5
-                    print(f"  {cat}")
-                if len(software) > 5:
-                    print(f"  ... and {len(software) - 5} more software categories")
-
-            if special:
-                print("\n🛠 Special & Meta Tools:")
-                for cat in special:
-                    print(f"  {cat}")
-
-            if other:
-                print("\n📂 Other Categories:")
-                for cat in other:
-                    print(f"  {cat}")
-
-            print(f"\nTotal: {len(tool_types)} categories available")
-            print("\nCommon combinations:")
-            print("  Scientific research: uniprot ChEMBL opentarget pubchem hpa")
-            print("  Drug discovery: ChEMBL fda_drug_label clinical_trials pubchem")
-            print("  Literature analysis: EuropePMC semantic_scholar pubtator")
-            print("  Minimal setup: special_tools tool_finder")
+            categories = stats.get("categories", {})
+            # Sort by count desc, then name asc
+            sorted_items = sorted(
+                categories.items(), key=lambda kv: (-kv[1].get("count", 0), kv[0])
+            )
+            for key, info in sorted_items:
+                display = key.replace("_", " ").title()
+                count = info.get("count", 0)
+                print(f"  {display}: {count}")
+
+            print(f"\nTotal categories: {stats.get('total_categories', 0)}")
+            print(f"Total unique tools: {stats.get('total_tools', 0)}")
+            print(
+                "\nTip: Use --exclude-categories or --include-tools to customize loading"
+            )
 
         except Exception as e:
             print(f"❌ Error listing categories: {e}")
@@ -871,30 +754,37 @@ Examples:
             from .execute_function import ToolUniverse
 
             tu = ToolUniverse()
-            tu.load_tools()  # Load all tools to list them
-
-            print("Available tools:")
-            print("=" * 50)
-
-            # Group tools by category
-            tools_by_category = {}
-            for tool in tu.all_tools:
-                tool_type = getattr(tool, "tool_type", "unknown")
-                if tool_type not in tools_by_category:
-                    tools_by_category[tool_type] = []
-                tools_by_category[tool_type].append(tool.name)
+            # Reuse ToolUniverse selection logic directly (applies API key skipping internally)
+            tool_config_files = {}
+            if args.tool_config_files:
+                for config_spec in args.tool_config_files:
+                    if ":" in config_spec:
+                        category, path = config_spec.split(":", 1)
+                        tool_config_files[category] = path
+
+            tu.load_tools(
+                tool_type=(
+                    args.categories
+                    if args.categories and len(args.categories) > 0
+                    else None
+                ),
+                exclude_tools=args.exclude_tools,
+                exclude_categories=args.exclude_categories,
+                include_tools=args.include_tools,
+                tool_config_files=(tool_config_files or None),
+                tools_file=args.tools_file,
+                include_tool_types=args.include_tool_types,
+                exclude_tool_types=args.exclude_tool_types,
+            )
 
-            total_tools = 0
-            for category in sorted(tools_by_category.keys()):
-                tools = sorted(tools_by_category[category])
-                print(f"\n📁 {category} ({len(tools)} tools):")
-                for tool in tools[:10]:  # Show first 10 tools per category
-                    print(f"  {tool}")
-                if len(tools) > 10:
-                    print(f"  ... and {len(tools) - 10} more tools")
-                total_tools += len(tools)
+            # Names of tools that are actually available under current configuration
+            tool_names = tu.get_available_tools(name_only=True)
 
-            print(f"\nTotal: {total_tools} tools available")
+            print("Available tools (for this server configuration):")
+            print("=" * 50)
+            for name in sorted(tool_names)[:200]:  # cap output for readability
+                print(f"  {name}")
+            print(f"\nTotal: {len(tool_names)} tools available")
             print("\nNote: Use --exclude-tools to exclude specific tools by name")
             print("      Use --exclude-categories to exclude entire categories")
 

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/{MultiAgentLiteratureSearch.py → ADMETAnalyzerAgent.py}

@@ -1,33 +1,33 @@
 """
-MultiAgentLiteratureSearch
+ADMETAnalyzerAgent
 
-Multi-agent literature search system that uses AI agents to analyze intent, extract keywords, exe...
+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 MultiAgentLiteratureSearch(
-    query: str,
-    max_iterations: int,
-    quality_threshold: float,
+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:
     """
-    Multi-agent literature search system that uses AI agents to analyze intent, extract keywords, exe...
+    AI agent that analyzes ADMET data and provides insights on drug-likeness and safety profiles
 
     Parameters
     ----------
-    query : str
-        The research query to search for
-    max_iterations : int
-        Maximum number of iterations (default: 3)
-    quality_threshold : float
-        Quality threshold for completion (default: 0.7)
+    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
@@ -43,11 +43,11 @@ def MultiAgentLiteratureSearch(
 
     return get_shared_client().run_one_function(
         {
-            "name": "MultiAgentLiteratureSearch",
+            "name": "ADMETAnalyzerAgent",
             "arguments": {
-                "query": query,
-                "max_iterations": max_iterations,
-                "quality_threshold": quality_threshold,
+                "compounds": compounds,
+                "admet_data": admet_data,
+                "disease_context": disease_context,
             },
         },
         stream_callback=stream_callback,
@@ -56,4 +56,4 @@ def MultiAgentLiteratureSearch(
     )
 
 
-__all__ = ["MultiAgentLiteratureSearch"]
+__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"]