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

tooluniverse/data/smolagent_tools.json

@@ -0,0 +1,206 @@
+[
+  {
+    "type": "SmolAgentTool",
+    "name": "advanced_literature_search_agent",
+    "description": "Advanced multi-agent literature search system. Required pipeline: (1) query_planner must produce a structured plan and immediately dispatch each sub-query to multi_database_searcher; (2) multi_database_searcher must call ToolUniverse literature tools (PubMed_search_articles, EuropePMC_search_articles, SemanticScholar_search_papers, openalex_literature_search, ArXiv_search_papers, BioRxiv_search_preprints, MedRxiv_search_preprints, Crossref_search_works, DBLP_search_publications, DOAJ_search_articles, CORE_search_papers, PMC_search_papers) and return raw results; (3) result_analyzer must deduplicate and score results; (4) literature_synthesizer must generate a structured markdown report (Executive Summary, Key Findings, Trends, Methods, Top Papers with rationale, Gaps, References). Do not skip any stage; do not answer directly without calling tools.",
+    "parameter": {
+      "type": "object",
+      "properties": {
+        "query": {
+          "type": "string",
+          "description": "Research query or topic to search in academic literature. The agent will automatically determine search strategy, database selection, filters, and result limits based on the query content and research domain."
+        }
+      },
+      "required": ["query"]
+    },
+    "settings": {
+      "agent_type": "ManagedAgent",
+      "available_tools": [],
+      "model": {
+        "provider": "AzureOpenAIModel",
+        "model_id": "gpt-5",
+        "api_key": "env:AZURE_OPENAI_API_KEY",
+        "azure_endpoint": "https://azure-ai.hms.edu",
+        "api_version": "2024-10-21"
+      },
+      "agent_init_params": {
+        "max_steps": 50,
+        "stream_outputs": true,
+        "verbosity_level": 1,
+        "planning_interval": 2,
+        "max_execution_time": 600
+      },
+      "sub_agents": [
+        {
+          "name": "query_planner",
+          "description": "Strategic query planning agent that analyzes intent, decomposes into prioritized sub-queries, and generates optimized search terms and target databases. After outputting the plan, immediately invoke multi_database_searcher with the sub-queries (no summaries). Output: JSON plan and explicit call instruction for multi_database_searcher.",
+          "agent_type": "CodeAgent",
+          "available_tools": [],
+          "model": {
+            "provider": "AzureOpenAIModel",
+            "model_id": "gpt-5",
+            "api_key": "env:AZURE_OPENAI_API_KEY",
+            "azure_endpoint": "https://azure-ai.hms.edu",
+            "api_version": "2024-10-21"
+          },
+          "agent_init_params": {
+            "add_base_tools": true,
+            "additional_authorized_imports": ["json", "datetime", "collections"],
+            "max_steps": 10,
+            "stream_outputs": true,
+            "verbosity_level": 1
+          }
+        },
+        {
+          "name": "multi_database_searcher",
+          "description": "Multi-database parallel search specialist. Must call the following ToolUniverse tools for each sub-query (as applicable): PubMed_search_articles, EuropePMC_search_articles, SemanticScholar_search_papers, openalex_literature_search, ArXiv_search_papers, BioRxiv_search_preprints, MedRxiv_search_preprints, Crossref_search_works, DBLP_search_publications, DOAJ_search_articles, CORE_search_papers, PMC_search_papers. Adapt queries to each API and return structured JSON with raw items (title, abstract, authors, doi, year, venue, citations, url). Do not summarize.",
+          "agent_type": "CodeAgent",
+          "available_tools": [
+            "PubMed_search_articles",
+            "EuropePMC_search_articles",
+            "SemanticScholar_search_papers",
+            "openalex_literature_search",
+            "ArXiv_search_papers",
+            "BioRxiv_search_preprints",
+            "MedRxiv_search_preprints",
+            "Crossref_search_works",
+            "DBLP_search_publications",
+            "DOAJ_search_articles",
+            "CORE_search_papers",
+            "PMC_search_papers"
+          ],
+          "model": {
+            "provider": "AzureOpenAIModel",
+            "model_id": "gpt-5",
+            "api_key": "env:AZURE_OPENAI_API_KEY",
+            "azure_endpoint": "https://azure-ai.hms.edu",
+            "api_version": "2024-10-21"
+          },
+          "agent_init_params": {
+            "add_base_tools": true,
+            "additional_authorized_imports": ["json", "concurrent.futures", "datetime", "urllib.parse", "re"],
+            "max_steps": 25,
+            "stream_outputs": true,
+            "verbosity_level": 1,
+            "max_tool_threads": 5
+          }
+        },
+        {
+          "name": "result_analyzer",
+          "description": "Intelligent result analysis agent. Input: multi_database_searcher raw results. Steps: deduplicate (DOI, normalized title similarity, author matching), compute composite relevance score (keyword match, normalized citations, venue impact, recency, cross-source frequency), filter low-quality (<0.3), rank and cluster by themes, identify high-impact and recent breakthroughs. Output: ranked, deduplicated list with scores, themes, and quality flags. Then instruct literature_synthesizer to produce the final report.",
+          "agent_type": "CodeAgent",
+          "available_tools": [],
+          "model": {
+            "provider": "AzureOpenAIModel",
+            "model_id": "gpt-5",
+            "api_key": "env:AZURE_OPENAI_API_KEY",
+            "azure_endpoint": "https://azure-ai.hms.edu",
+            "api_version": "2024-10-21"
+          },
+          "agent_init_params": {
+            "add_base_tools": true,
+            "additional_authorized_imports": ["json", "collections", "re", "difflib", "datetime", "math"],
+            "max_steps": 15,
+            "stream_outputs": true,
+            "verbosity_level": 1
+          }
+        },
+        {
+          "name": "literature_synthesizer",
+          "description": "Literature synthesis and report generation specialist. Input: result_analyzer ranked list. Produce a structured markdown report with sections: Executive Summary, Key Findings, Research Trends, Methodology Overview, Top Papers with rationale (10–15), Research Gaps, References (with DOIs/URLs). Use only analyzed items; do not invent citations.",
+          "agent_type": "CodeAgent",
+          "available_tools": [],
+          "model": {
+            "provider": "AzureOpenAIModel",
+            "model_id": "gpt-5",
+            "api_key": "env:AZURE_OPENAI_API_KEY",
+            "azure_endpoint": "https://azure-ai.hms.edu",
+            "api_version": "2024-10-21"
+          },
+          "agent_init_params": {
+            "add_base_tools": true,
+            "additional_authorized_imports": ["json", "collections", "datetime", "statistics"],
+            "max_steps": 20,
+            "stream_outputs": true,
+            "verbosity_level": 1
+          }
+        }
+      ]
+    }
+  },
+  {
+    "type": "SmolAgentTool",
+    "name": "open_deep_research_agent",
+    "description": "Research manager agent that decomposes the user task, delegates focused subtasks to domain sub‑agents (web researcher, synthesizer), enforces evidence use, requires numeric outputs with units, and returns a concise final answer with citations. It should: (1) draft a brief plan, (2) ask web_researcher to gather authoritative facts (URLs + extracted numbers), (3) validate consistency across sources, (4) instruct synthesizer to compute/compose the final result, and (5) output only the final, unit‑aware answer plus one short rationale line.",
+    "parameter": {
+      "type": "object",
+      "properties": {
+        "task": {"type": "string", "description": "Research query/task to execute"}
+      },
+      "required": ["task"]
+    },
+    "settings": {
+      "agent_type": "ManagedAgent",
+      "available_tools": [],
+      "model": {
+        "provider": "AzureOpenAIModel",
+        "model_id": "gpt-5",
+        "api_key": "env:AZURE_OPENAI_API_KEY",
+        "azure_endpoint": "https://azure-ai.hms.edu",
+        "api_version": "2024-10-21"
+      },
+      "agent_init_params": {
+        "max_steps": 30,
+        "stream_outputs": true,
+        "verbosity_level": 1,
+        "planning_interval": 1
+      },
+      "sub_agents": [
+        {
+          "name": "web_researcher",
+          "description": "Web research specialist that (a) formulates robust search queries, (b) selects authoritative sources (official sites, Wikipedia with corroboration, reputable databases), (c) visits pages and extracts exact figures (units, context), (d) records 1–2 key quotes/snippets and the canonical URL, and (e) returns a short, source‑linked note ready for synthesis.",
+          "agent_type": "CodeAgent",
+          "available_tools": [
+            {"type": "smolagents", "class": "WebSearchTool", "import_path": "smolagents.default_tools"},
+            {"type": "smolagents", "class": "VisitWebpageTool", "import_path": "smolagents.default_tools"}
+          ],
+          "model": {
+            "provider": "AzureOpenAIModel",
+            "model_id": "gpt-5",
+            "api_key": "env:AZURE_OPENAI_API_KEY",
+            "azure_endpoint": "https://azure-ai.hms.edu",
+            "api_version": "2024-10-21"
+          },
+          "agent_init_params": {
+            "add_base_tools": true,
+            "additional_authorized_imports": ["requests", "bs4", "lxml"],
+            "max_steps": 12,
+            "stream_outputs": true,
+            "verbosity_level": 1,
+            "planning_interval": 1
+          }
+        },
+        {
+          "name": "synthesizer",
+          "description": "Synthesis specialist that reads prior research notes, performs any light calculation (unit conversion, division, rounding), resolves minor conflicts by favoring higher‑authority sources, and produces a single, precise answer with units and 1–2 citations. Keep prose minimal; prioritize the final numeric result and rationale.",
+          "agent_type": "ToolCallingAgent",
+          "available_tools": [
+            {"type": "smolagents", "class": "WebSearchTool", "import_path": "smolagents.default_tools"}
+          ],
+          "model": {
+            "provider": "AzureOpenAIModel",
+            "model_id": "gpt-5",
+            "api_key": "env:AZURE_OPENAI_API_KEY",
+            "azure_endpoint": "https://azure-ai.hms.edu",
+            "api_version": "2024-10-21"
+          },
+          "agent_init_params": {
+            "max_steps": 8,
+            "stream_outputs": false,
+            "planning_interval": 1
+          }
+        }
+      ]
+    }
+  }
+]

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,
+            }