tooluniverse 1.0.9.1__py3-none-any.whl → 1.0.11__py3-none-any.whl

tooluniverse/humanbase_tool.py

@@ -35,19 +35,19 @@ class HumanBaseTool(BaseTool):
         """
         Retrieve the official gene symbol (same as EnrichrTool method)
 
-        Parameters:
+        Parameters
             gene_name (str): The gene name or synonym to query.
 
-        Returns:
+        Returns
             str: The official gene symbol.
         """
         """
         Retrieve the official gene symbol for a given gene name or synonym using the MyGene.info API.
 
-        Parameters:
+        Parameters
             gene_name (str): The gene name or synonym to query.
 
-        Returns:
+        Returns
             str: The official gene symbol if found; otherwise, raises an Exception.
         """
         # URL-encode the gene_name to handle special characters
@@ -96,10 +96,10 @@ class HumanBaseTool(BaseTool):
         """
         Convert gene names to Entrez IDs using NCBI Entrez API.
 
-        Parameters:
+        Parameters
             gene_names (list): List of gene names to convert.
 
-        Returns:
+        Returns
             list: List of Entrez IDs corresponding to the gene names.
         """
         # Define the NCBI Entrez API URL for querying gene information
@@ -149,13 +149,13 @@ class HumanBaseTool(BaseTool):
         """
         Retrieve protein-protein interactions and biological processes from HumanBase.
 
-        Parameters:
+        Parameters
             genes (list): List of gene names to analyze.
             tissue (str): Tissue type for tissue-specific interactions.
             max_node (int): Maximum number of nodes to retrieve.
             interaction (str): Specific interaction type to filter by.
 
-        Returns:
+        Returns
             tuple: (NetworkX Graph of interactions, list of biological processes)
         """
         genes = self.get_entrez_ids(genes)
@@ -243,13 +243,13 @@ class HumanBaseTool(BaseTool):
         """
         Convert NetworkX graph and biological processes to string representation.
 
-        Parameters:
+        Parameters
             graph (networkx.Graph): The network graph.
             bp_collection (list): List of biological processes.
             original_genes (list): Original gene list provided by user.
             tissue (str): Tissue type used for analysis.
 
-        Returns:
+        Returns
             str: Comprehensive string representation of the network data.
         """
         output = []

tooluniverse/interpro_tool.py

@@ -0,0 +1,72 @@
+import requests
+from typing import Any, Dict
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("InterProRESTTool")
+class InterProRESTTool(BaseTool):
+    def __init__(self, tool_config: Dict):
+        super().__init__(tool_config)
+        self.base_url = "https://www.ebi.ac.uk/interpro/api"
+        self.session = requests.Session()
+        self.session.headers.update(
+            {"Accept": "application/json", "User-Agent": "ToolUniverse/1.0"}
+        )
+        self.timeout = 30
+
+    def _build_url(self, args: Dict[str, Any]) -> str:
+        """Build URL from endpoint template and arguments"""
+        url = self.tool_config["fields"]["endpoint"]
+        for k, v in args.items():
+            url = url.replace(f"{{{k}}}", str(v))
+        return url
+
+    def _extract_data(self, data: Dict, extract_path: str = None) -> Any:
+        """Extract specific data from API response"""
+        if not extract_path:
+            return data
+
+        # Handle specific InterPro extraction patterns
+        if extract_path == "results":
+            return data.get("results", [])
+        elif extract_path == "count":
+            return data.get("count", 0)
+        elif extract_path == "metadata":
+            return data.get("metadata", {})
+
+        return data
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the InterPro API call"""
+        try:
+            # Build URL from endpoint template
+            url = self._build_url(arguments)
+
+            # Make API request
+            response = self.session.get(url, timeout=self.timeout)
+            response.raise_for_status()
+
+            # Parse JSON response
+            data = response.json()
+
+            # Extract data if specified
+            extract_path = self.tool_config["fields"].get("extract_path")
+            if extract_path:
+                result = self._extract_data(data, extract_path)
+            else:
+                result = data
+
+            return {
+                "status": "success",
+                "data": result,
+                "url": url,
+                "count": len(result) if isinstance(result, list) else 1,
+            }
+
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": f"InterPro API error: {str(e)}",
+                "url": url,
+            }

tooluniverse/jaspar_tool.py

@@ -0,0 +1,30 @@
+import requests
+from typing import Any, Dict
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("JASPARRESTTool")
+class JASPARRESTTool(BaseTool):
+    def __init__(self, tool_config: Dict):
+        super().__init__(tool_config)
+        self.base_url = "https://jaspar.elixir.no/api/v1"
+        self.session = requests.Session()
+        self.session.headers.update({"Accept": "application/json"})
+        self.timeout = 30
+
+    def _build_url(self, args: Dict[str, Any]) -> str:
+        url = self.tool_config["fields"]["endpoint"]
+        for k, v in args.items():
+            url = url.replace(f"{{{k}}}", str(v))
+        return url
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            url = self._build_url(arguments)
+            response = self.session.get(url, timeout=self.timeout)
+            response.raise_for_status()
+            data = response.json()
+            return {"status": "success", "data": data, "url": url}
+        except Exception as e:
+            return {"status": "error", "error": f"JASPAR API error: {str(e)}"}

tooluniverse/kegg_tool.py

@@ -0,0 +1,230 @@
+"""
+KEGG Database REST API Tool
+
+This tool provides access to the KEGG (Kyoto Encyclopedia of Genes and Genomes)
+database for pathway analysis, gene information, and organism data.
+"""
+
+import requests
+from typing import Dict, Any, Optional
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+class KEGGRESTTool(BaseTool):
+    """Base class for KEGG REST API tools."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base_url = "https://rest.kegg.jp"
+        self.session = requests.Session()
+        self.session.headers.update(
+            {"Accept": "text/plain, application/json", "User-Agent": "ToolUniverse/1.0"}
+        )
+        self.timeout = 30
+
+    def _make_request(
+        self, endpoint: str, params: Optional[Dict] = None
+    ) -> Dict[str, Any]:
+        """Make a request to the KEGG API."""
+        url = f"{self.base_url}{endpoint}"
+        try:
+            response = self.session.get(url, params=params, timeout=self.timeout)
+            response.raise_for_status()
+
+            # KEGG API returns text/plain by default, parse as text
+            content = response.text.strip()
+
+            # Try to parse as structured data if possible
+            if content.startswith("{") or content.startswith("["):
+                try:
+                    return {"status": "success", "data": response.json()}
+                except Exception:
+                    pass
+
+            # Return as text data
+            return {
+                "status": "success",
+                "data": content,
+                "url": url,
+                "content_type": response.headers.get("content-type", "text/plain"),
+            }
+
+        except requests.exceptions.RequestException as e:
+            return {
+                "status": "error",
+                "error": f"KEGG API request failed: {str(e)}",
+                "url": url,
+            }
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the tool with given arguments."""
+        return self._make_request(self.endpoint, arguments)
+
+
+@register_tool("KEGGSearchPathway")
+class KEGGSearchPathway(KEGGRESTTool):
+    """Search KEGG pathways by keyword."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = "/find/pathway"
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Search pathways with keyword."""
+        keyword = arguments.get("keyword", "")
+        if not keyword:
+            return {"status": "error", "error": "keyword is required"}
+
+        # KEGG API requires the search term in the URL path
+        endpoint = f"{self.endpoint}/{keyword}"
+        result = self._make_request(endpoint)
+
+        # Parse pathway results
+        if result.get("status") == "success" and isinstance(result.get("data"), str):
+            lines = result["data"].split("\n")
+            pathways = []
+            for line in lines:
+                if "\t" in line:
+                    parts = line.split("\t", 1)
+                    if len(parts) == 2:
+                        pathways.append(
+                            {"pathway_id": parts[0], "description": parts[1]}
+                        )
+            result["data"] = pathways
+            result["count"] = len(pathways)
+
+        return result
+
+
+@register_tool("KEGGGetPathwayInfo")
+class KEGGGetPathwayInfo(KEGGRESTTool):
+    """Get detailed pathway information by pathway ID."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = "/get"
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Get pathway information."""
+        pathway_id = arguments.get("pathway_id", "")
+        if not pathway_id:
+            return {"status": "error", "error": "pathway_id is required"}
+
+        # Add pathway prefix if not present
+        if not pathway_id.startswith("path:"):
+            pathway_id = f"path:{pathway_id}"
+
+        # KEGG API requires the ID in the URL path
+        endpoint = f"{self.endpoint}/{pathway_id}"
+        result = self._make_request(endpoint)
+
+        # Parse pathway data
+        if result.get("status") == "success" and isinstance(result.get("data"), str):
+            lines = result["data"].split("\n")
+            pathway_info = {
+                "pathway_id": pathway_id,
+                "raw_data": result["data"],
+                "lines": len(lines),
+            }
+            result["data"] = pathway_info
+
+        return result
+
+
+@register_tool("KEGGFindGenes")
+class KEGGFindGenes(KEGGRESTTool):
+    """Find genes by keyword in KEGG database."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = "/find/genes"
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Find genes with keyword."""
+        keyword = arguments.get("keyword", "")
+        if not keyword:
+            return {"status": "error", "error": "keyword is required"}
+
+        # KEGG API requires the search term in the URL path
+        # For gene search, we don't need organism prefix in the URL
+        endpoint = f"{self.endpoint}/{keyword}"
+        result = self._make_request(endpoint)
+
+        # Parse gene results
+        if result.get("status") == "success" and isinstance(result.get("data"), str):
+            lines = result["data"].split("\n")
+            genes = []
+            for line in lines:
+                if "\t" in line:
+                    parts = line.split("\t", 1)
+                    if len(parts) == 2:
+                        genes.append({"gene_id": parts[0], "description": parts[1]})
+            result["data"] = genes
+            result["count"] = len(genes)
+
+        return result
+
+
+@register_tool("KEGGGetGeneInfo")
+class KEGGGetGeneInfo(KEGGRESTTool):
+    """Get detailed gene information by gene ID."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = "/get"
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Get gene information."""
+        gene_id = arguments.get("gene_id", "")
+        if not gene_id:
+            return {"status": "error", "error": "gene_id is required"}
+
+        # KEGG API requires the ID in the URL path
+        endpoint = f"{self.endpoint}/{gene_id}"
+        result = self._make_request(endpoint)
+
+        # Parse gene data
+        if result.get("status") == "success" and isinstance(result.get("data"), str):
+            lines = result["data"].split("\n")
+            gene_info = {
+                "gene_id": gene_id,
+                "raw_data": result["data"],
+                "lines": len(lines),
+            }
+            result["data"] = gene_info
+
+        return result
+
+
+@register_tool("KEGGListOrganisms")
+class KEGGListOrganisms(KEGGRESTTool):
+    """List available organisms in KEGG database."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = "/list/organism"
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """List organisms."""
+        result = self._make_request(self.endpoint)
+
+        # Parse organism list
+        if result.get("status") == "success" and isinstance(result.get("data"), str):
+            lines = result["data"].split("\n")
+            organisms = []
+            for line in lines:
+                if "\t" in line:
+                    parts = line.split("\t")
+                    if len(parts) >= 3:
+                        organisms.append(
+                            {
+                                "organism_code": parts[0],
+                                "organism_name": parts[1],
+                                "description": parts[2] if len(parts) > 2 else "",
+                            }
+                        )
+            result["data"] = organisms
+            result["count"] = len(organisms)
+
+        return result

tooluniverse/logging_config.py

@@ -232,7 +232,7 @@ def get_logger(name: Optional[str] = None) -> logging.Logger:
     Args:
         name (str, optional): Logger name (usually __name__)
 
-    Returns:
+    Returns
         logging.Logger: Logger instance
     """
     return _logger_manager.get_logger(name)
@@ -291,7 +291,7 @@ def get_hook_logger(name: str = "HookManager") -> logging.Logger:
     Args:
         name (str): Name of the logger. Defaults to 'HookManager'
 
-    Returns:
+    Returns
         logging.Logger: Configured logger for hook operations
     """
     return get_logger(name)

tooluniverse/mcp_client_tool.py

@@ -8,11 +8,11 @@ supporting all MCP functionality including tools, resources, and prompts.
 import json
 import asyncio
 import websockets
-import aiohttp
-import uuid
 from typing import Dict, List, Any, Optional
 from urllib.parse import urljoin
 import warnings
+from mcp.client.session import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
 from .base_tool import BaseTool
 from .tool_registry import register_tool
 import os
@@ -35,8 +35,6 @@ class BaseMCPClient:
         self.transport = normalized_transport
         self.timeout = timeout
         self.session = None
-        self.mcp_session_id = None
-        self._initialized = False
 
         # Validate transport (accept 'stdio' via normalization above)
         supported_transports = ["http", "websocket"]
@@ -44,24 +42,9 @@ class BaseMCPClient:
             # 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"""
-        if self.transport == "http" and self.session is None:
-            connector = aiohttp.TCPConnector()
-            timeout = aiohttp.ClientTimeout(total=self.timeout)
-            self.session = aiohttp.ClientSession(connector=connector, timeout=timeout)
-
     async def _close_session(self):
-        """Close HTTP session if exists"""
-        if self.session:
-            try:
-                await self.session.close()
-            except Exception:
-                pass  # Ignore errors during cleanup
-            finally:
-                self.session = None
-                self.mcp_session_id = None
-                self._initialized = False
+        """Placeholder for compatibility; HTTP client calls are scoped per request."""
+        return
 
     def _get_mcp_endpoint(self, path: str) -> str:
         """Get the full MCP endpoint URL"""
@@ -72,115 +55,55 @@ class BaseMCPClient:
             return urljoin(base_url + "/", path)
         return self.server_url
 
-    async def _initialize_mcp_session(self):
-        """Initialize MCP session if needed (for compatibility with different MCP servers)"""
-        if self._initialized:
-            return
-
-        await self._ensure_session()
-
-        # Try to get session ID from server
-        try:
-            url = f"{self.server_url.rstrip('/')}/mcp"
-            test_payload = {"jsonrpc": "2.0", "id": 1, "method": "tools/list"}
-
-            headers = {
-                "Content-Type": "application/json",
-                "Accept": "application/json, text/event-stream",
-            }
-
-            async with self.session.post(
-                url, json=test_payload, headers=headers
-            ) as response:
-                session_id = response.headers.get("mcp-session-id")
-                if session_id:
-                    self.mcp_session_id = session_id
-
-                if response.status in [200, 400, 406, 500]:
-                    self._initialized = True
-                    return
-
-        except Exception:
-            pass
-
-        # Fallback: generate session ID
-        if not self.mcp_session_id:
-            self.mcp_session_id = str(uuid.uuid4()).replace("-", "")
-
-        self._initialized = True
-
     async def _make_mcp_request(
         self, method: str, params: Optional[Dict] = None
     ) -> Dict[str, Any]:
         """Make an MCP JSON-RPC request"""
-        request_id = "1"
-
-        payload = {"jsonrpc": "2.0", "id": request_id, "method": method}
-
-        if params:
-            payload["params"] = params
-
         if self.transport == "http":
-            await self._ensure_session()
-            await self._initialize_mcp_session()  # Ensure session is initialized
-
-            headers = {
-                "Content-Type": "application/json",
-                "Accept": "application/json, text/event-stream",
-            }
-
-            # Add session ID if available
-            if self.mcp_session_id:
-                headers["mcp-session-id"] = self.mcp_session_id
-
             endpoint = self._get_mcp_endpoint("")
-
-            async with self.session.post(
-                endpoint, json=payload, headers=headers
-            ) as response:
-                if response.status != 200:
-                    raise Exception(
-                        f"MCP request failed with status {response.status}: {await response.text()}"
-                    )
-
-                content_type = response.headers.get("content-type", "").lower()
-
-                if "text/event-stream" in content_type:
-                    # Handle Server-Sent Events format
-                    response_text = await response.text()
-
-                    for line in response_text.split("\n"):
-                        line = line.strip()
-                        if line.startswith("data: "):
-                            json_data = line[6:]
-                            try:
-                                result = json.loads(json_data)
-                                break
-                            except json.JSONDecodeError:
-                                continue
-                    else:
-                        raise Exception(
-                            f"Failed to parse SSE response: {response_text}"
+            async with streamablehttp_client(endpoint, timeout=self.timeout) as (
+                read_stream,
+                write_stream,
+                _,
+            ):
+                async with ClientSession(read_stream, write_stream) as session:
+                    await session.initialize()
+
+                    if method == "tools/list":
+                        result = await session.list_tools()
+                    elif method == "tools/call":
+                        if not params or "name" not in params:
+                            raise ValueError("Missing tool name for tools/call")
+                        result = await session.call_tool(
+                            params["name"], params.get("arguments") or {}
                         )
-
-                elif "application/json" in content_type:
-                    result = await response.json()
-                else:
-                    try:
-                        result = await response.json()
-                    except Exception:
-                        response_text = await response.text()
-                        raise Exception(
-                            f"Unexpected content type {content_type}. Response: {response_text}"
+                    elif method == "resources/list":
+                        result = await session.list_resources()
+                    elif method == "resources/read":
+                        if not params or "uri" not in params:
+                            raise ValueError("Missing uri for resources/read")
+                        result = await session.read_resource(params["uri"])
+                    elif method == "prompts/list":
+                        result = await session.list_prompts()
+                    elif method == "prompts/get":
+                        if not params or "name" not in params:
+                            raise ValueError("Missing prompt name for prompts/get")
+                        result = await session.get_prompt(
+                            params["name"], params.get("arguments")
                         )
+                    else:
+                        raise ValueError(f"Unsupported MCP method: {method}")
 
-                if "error" in result:
-                    raise Exception(f"MCP error: {result['error']}")
-
-                return result.get("result", {})
+                    if hasattr(result, "model_dump"):
+                        return result.model_dump(mode="json")
+                    return result
 
         elif self.transport == "websocket":
             async with websockets.connect(self.server_url) as websocket:
+                request_id = "1"
+                payload = {"jsonrpc": "2.0", "id": request_id, "method": method}
+                if params:
+                    payload["params"] = params
                 await websocket.send(json.dumps(payload))
                 response = await websocket.recv()
                 result = json.loads(response)
@@ -575,7 +498,6 @@ class MCPAutoLoaderTool(BaseTool, BaseMCPClient):
     async def discover_tools(self) -> Dict[str, Any]:
         """Discover all available tools from the MCP server"""
         try:
-            await self._initialize_mcp_session()
             tools_response = await self._make_mcp_request("tools/list")
             tools = tools_response.get("tools", [])
 
@@ -631,22 +553,28 @@ class MCPAutoLoaderTool(BaseTool, BaseMCPClient):
         return configs
 
     def register_tools_in_engine(self, engine):
-        """Register discovered tools directly in the ToolUniverse engine"""
+        """Register discovered tools using ToolUniverse public API"""
         try:
             configs = self.generate_proxy_tool_configs()
 
             for config in configs:
-                # Add configuration to engine's all_tools list for validation
-                engine.all_tools.append(config)
+                config["type"]
+                tool_name = config["name"]
 
-                # Create MCPProxyTool instance for execution
-                proxy_tool = MCPProxyTool(config)
+                # Use public API to register tool
+                engine.register_custom_tool(
+                    tool_class=MCPProxyTool,
+                    tool_name=tool_name,
+                    tool_config=config,
+                    instantiate=True,  # Immediately instantiate and cache
+                )
 
-                # Register both config (for validation) and tool instance (for execution)
-                tool_name = config["name"]
-                engine.all_tool_dict[tool_name] = config  # For validation
-                engine.callable_functions[tool_name] = proxy_tool  # For execution
-                self._registered_tools[tool_name] = proxy_tool
+                # Keep reference for tracking
+                # Use the actual key that register_custom_tool uses
+                actual_key = config.get("name", tool_name)
+                self._registered_tools[tool_name] = engine.callable_functions[
+                    actual_key
+                ]
 
             return len(configs)
         except Exception as e: