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

tooluniverse/gnomad_tool.py

@@ -0,0 +1,63 @@
+import requests
+import json
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("GnomadTool")
+class GnomadTool(BaseTool):
+    """
+    Local tool wrapper for gnomAD GraphQL API.
+    Queries variant information including allele frequencies.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base = "https://gnomad.broadinstitute.org/api"
+        self.session = requests.Session()
+        self.session.headers.update({"Content-Type": "application/json"})
+
+    def run(self, arguments):
+        variant_id = arguments.get("variant_id")
+        dataset = arguments.get("dataset", "gnomad_r4")
+
+        if not variant_id:
+            return {"error": "Missing required parameter: variant_id"}
+
+        # GraphQL query for variant with genome frequencies
+        query = """
+        query($variant: String!, $dataset: DatasetId!) {
+            variant(variantId: $variant, dataset: $dataset) {
+                variantId
+                genome {
+                    ac
+                    an
+                    af
+                }
+            }
+        }
+        """
+
+        payload = {
+            "query": query,
+            "variables": {
+                "variant": variant_id,
+                "dataset": dataset,
+            },
+        }
+
+        resp = self.session.post(self.base, data=json.dumps(payload), timeout=30)
+        resp.raise_for_status()
+        data = resp.json()
+
+        if "errors" in data:
+            return {"error": f"GraphQL errors: {data['errors']}"}
+
+        variant = data.get("data", {}).get("variant")
+        if not variant:
+            return {"error": "Variant not found"}
+
+        return {
+            "variantId": variant.get("variantId"),
+            "genome": variant.get("genome", {}),
+        }

tooluniverse/hal_tool.py

@@ -51,7 +51,7 @@ class HALTool(BaseTool):
         docs = data.get("response", {}).get("docs", [])
         results = []
         for d in docs:
-            title = (d.get("title_s") or [None])
+            title = d.get("title_s") or [None]
             if isinstance(title, list):
                 title = title[0]
             authors = d.get("authFullName_s") or []

tooluniverse/llm_clients.py

@@ -328,110 +328,6 @@ class AzureOpenAIClient(BaseLLMClient):
         self.logger.error("Max retries exceeded. Unable to complete the request.")
         return None
 
-    def infer_stream(
-        self,
-        messages: List[Dict[str, str]],
-        temperature: Optional[float],
-        max_tokens: Optional[int],
-        return_json: bool,
-        custom_format: Any = None,
-        max_retries: int = 5,
-        retry_delay: int = 5,
-    ):
-        if return_json or custom_format is not None:
-            yield from super().infer_stream(
-                messages,
-                temperature,
-                max_tokens,
-                return_json,
-                custom_format,
-                max_retries,
-                retry_delay,
-            )
-            return
-
-        retries = 0
-        eff_max = (
-            max_tokens
-            if max_tokens is not None
-            else self._resolve_default_max_tokens(self.model_name)
-        )
-
-        while retries < max_retries:
-            try:
-                kwargs: Dict[str, Any] = {
-                    "model": self.model_name,
-                    "messages": messages,
-                    "stream": True,
-                }
-                if temperature is not None:
-                    kwargs["temperature"] = temperature
-                if eff_max is not None:
-                    kwargs["max_tokens"] = eff_max
-
-                stream = self.client.chat.completions.create(**kwargs)
-                for chunk in stream:
-                    text = AzureOpenAIClient._extract_text_from_chunk(chunk)  # type: ignore[attr-defined]
-                    if text:
-                        yield text
-                return
-            except self._openai.RateLimitError:  # type: ignore[attr-defined]
-                self.logger.warning(
-                    f"OpenRouter streaming rate limit hit. Retrying in {retry_delay} seconds..."
-                )
-                retries += 1
-                time.sleep(retry_delay * retries)
-            except Exception as e:  # noqa: BLE001
-                self.logger.error(f"OpenRouter streaming error: {e}")
-                break
-
-        yield from super().infer_stream(
-            messages,
-            temperature,
-            max_tokens,
-            return_json,
-            custom_format,
-            max_retries,
-            retry_delay,
-        )
-
-    @staticmethod
-    def _extract_text_from_chunk(chunk) -> Optional[str]:
-        try:
-            choices = getattr(chunk, "choices", None)
-        except Exception:
-            choices = None
-        if not choices:
-            return None
-
-        first_choice = choices[0]
-        delta = getattr(first_choice, "delta", None)
-        if delta is None and isinstance(first_choice, dict):
-            delta = first_choice.get("delta")
-        if delta is None:
-            return None
-
-        content = getattr(delta, "content", None)
-        if content is None and isinstance(delta, dict):
-            content = delta.get("content")
-        if not content:
-            return None
-
-        if isinstance(content, str):
-            return content
-
-        if isinstance(content, list):
-            fragments: List[str] = []
-            for item in content:
-                text = getattr(item, "text", None)
-                if text is None and isinstance(item, dict):
-                    text = item.get("text")
-                if text:
-                    fragments.append(text)
-            return "".join(fragments) if fragments else None
-
-        return None
-
     def infer_stream(
         self,
         messages: List[Dict[str, str]],
@@ -663,11 +559,14 @@ class OpenRouterClient(BaseLLMClient):
 
     # Default model limits based on latest OpenRouter offerings
     DEFAULT_MODEL_LIMITS: Dict[str, Dict[str, int]] = {
-        "openai/gpt-5": {"max_output": 128_000, "context_window": 400_000},  
+        "openai/gpt-5": {"max_output": 128_000, "context_window": 400_000},
         "openai/gpt-5-codex": {"max_output": 128_000, "context_window": 400_000},
         "google/gemini-2.5-flash": {"max_output": 65_536, "context_window": 1_000_000},
         "google/gemini-2.5-pro": {"max_output": 65_536, "context_window": 1_000_000},
-        "anthropic/claude-sonnet-4.5": {"max_output": 16_384, "context_window": 1_000_000},
+        "anthropic/claude-sonnet-4.5": {
+            "max_output": 16_384,
+            "context_window": 1_000_000,
+        },
     }
 
     def __init__(self, model_id: str, logger):
@@ -676,7 +575,7 @@ class OpenRouterClient(BaseLLMClient):
             import openai as _openai  # type: ignore
         except Exception as e:  # pragma: no cover
             raise RuntimeError("openai client is not available") from e
-        
+
         self._OpenAI = _OpenAI
         self._openai = _openai
         self.model_name = model_id
@@ -685,14 +584,14 @@ class OpenRouterClient(BaseLLMClient):
         api_key = os.getenv("OPENROUTER_API_KEY")
         if not api_key:
             raise ValueError("OPENROUTER_API_KEY not set")
-        
+
         # Optional headers for OpenRouter
         default_headers = {}
         if site_url := os.getenv("OPENROUTER_SITE_URL"):
             default_headers["HTTP-Referer"] = site_url
         if site_name := os.getenv("OPENROUTER_SITE_NAME"):
             default_headers["X-Title"] = site_name
-        
+
         self.client = self._OpenAI(
             base_url="https://openrouter.ai/api/v1",
             api_key=api_key,
@@ -731,13 +630,13 @@ class OpenRouterClient(BaseLLMClient):
                 mapping = _json.loads(mapping_raw)
             except Exception:
                 mapping = {}
-        
+
         if model_id in mapping:
             try:
                 return int(mapping[model_id])
             except Exception:
                 pass
-        
+
         # Check for prefix match
         for k, v in mapping.items():
             try:
@@ -745,11 +644,11 @@ class OpenRouterClient(BaseLLMClient):
                     return int(v)
             except Exception:
                 continue
-        
+
         # Next: built-in/default-limits map
         if model_id in self._default_limits:
             return int(self._default_limits[model_id].get("max_output", 0)) or None
-        
+
         # Check for prefix match in default limits
         for k, v in self._default_limits.items():
             try:
@@ -757,7 +656,7 @@ class OpenRouterClient(BaseLLMClient):
                     return int(v.get("max_output", 0)) or None
             except Exception:
                 continue
-        
+
         return None
 
     def test_api(self) -> None:
@@ -765,7 +664,7 @@ class OpenRouterClient(BaseLLMClient):
         test_messages = [{"role": "user", "content": "ping"}]
         token_attempts = [1, 4, 16, 32]
         last_error: Optional[Exception] = None
-        
+
         for tok in token_attempts:
             try:
                 self.client.chat.completions.create(
@@ -785,7 +684,7 @@ class OpenRouterClient(BaseLLMClient):
                 ) and tok != token_attempts[-1]:
                     continue
                 break
-        
+
         if last_error:
             raise ValueError(f"OpenRouter API test failed: {last_error}")
         raise ValueError("OpenRouter API test failed: unknown error")
@@ -807,39 +706,39 @@ class OpenRouterClient(BaseLLMClient):
             if custom_format is not None
             else self.client.chat.completions.create
         )
-        
+
         response_format = (
             custom_format
             if custom_format is not None
             else ({"type": "json_object"} if return_json else None)
         )
-        
+
         eff_max = (
             max_tokens
             if max_tokens is not None
             else self._resolve_default_max_tokens(self.model_name)
         )
-        
+
         while retries < max_retries:
             try:
                 kwargs: Dict[str, Any] = {
                     "model": self.model_name,
                     "messages": messages,
                 }
-                
+
                 if response_format is not None:
                     kwargs["response_format"] = response_format
                 if temperature is not None:
                     kwargs["temperature"] = temperature
                 if eff_max is not None:
                     kwargs["max_tokens"] = eff_max
-                
+
                 resp = call_fn(**kwargs)
-                
+
                 if custom_format is not None:
                     return resp.choices[0].message.parsed.model_dump()
                 return resp.choices[0].message.content
-                
+
             except self._openai.RateLimitError:  # type: ignore[attr-defined]
                 self.logger.warning(
                     f"Rate limit exceeded. Retrying in {retry_delay} seconds..."
@@ -849,8 +748,86 @@ class OpenRouterClient(BaseLLMClient):
             except Exception as e:  # noqa: BLE001
                 self.logger.error(f"OpenRouter error: {e}")
                 import traceback
+
                 traceback.print_exc()
                 break
-        
+
         self.logger.error("Max retries exceeded. Unable to complete the request.")
         return None
+
+
+class VLLMClient(BaseLLMClient):
+    def __init__(self, model_name: str, server_url: str, logger):
+        try:
+            from openai import OpenAI
+        except Exception as e:
+            raise RuntimeError("openai package not available for vLLM client") from e
+
+        if not server_url:
+            raise ValueError("VLLM_SERVER_URL must be provided")
+
+        self.model_name = model_name
+        # Ensure server_url ends with /v1 for OpenAI-compatible API
+        if not server_url.endswith("/v1"):
+            server_url = server_url.rstrip("/") + "/v1"
+        self.server_url = server_url
+        self.logger = logger
+
+        self.client = OpenAI(
+            api_key="EMPTY",
+            base_url=self.server_url,
+        )
+
+    def test_api(self) -> None:
+        test_messages = [{"role": "user", "content": "ping"}]
+        try:
+            self.client.chat.completions.create(
+                model=self.model_name,
+                messages=test_messages,
+                max_tokens=8,
+                temperature=0,
+            )
+        except Exception as e:
+            raise ValueError(f"vLLM API test failed: {e}")
+
+    def infer(
+        self,
+        messages: List[Dict[str, str]],
+        temperature: Optional[float],
+        max_tokens: Optional[int],
+        return_json: bool,
+        custom_format: Any = None,
+        max_retries: int = 5,
+        retry_delay: int = 5,
+    ) -> Optional[str]:
+        if custom_format is not None:
+            self.logger.warning("vLLM does not support custom format, ignoring")
+
+        retries = 0
+        while retries < max_retries:
+            try:
+                kwargs: Dict[str, Any] = {
+                    "model": self.model_name,
+                    "messages": messages,
+                }
+
+                if temperature is not None:
+                    kwargs["temperature"] = temperature
+
+                if max_tokens is not None:
+                    kwargs["max_tokens"] = max_tokens
+
+                if return_json:
+                    kwargs["response_format"] = {"type": "json_object"}
+
+                resp = self.client.chat.completions.create(**kwargs)
+                return resp.choices[0].message.content
+
+            except Exception as e:
+                self.logger.error(f"vLLM error: {e}")
+                retries += 1
+                if retries < max_retries:
+                    time.sleep(retry_delay * retries)
+
+        self.logger.error("Max retries exceeded for vLLM request")
+        return None

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

@@ -348,7 +348,10 @@ def _start_server_for_port(port: int, **kwargs):
         try:
             # Enable stateless mode for MCPAutoLoaderTool compatibility
             server.run_simple(
-                transport=config["transport"], host=config["host"], port=port, stateless_http=True
+                transport=config["transport"],
+                host=config["host"],
+                port=port,
+                stateless_http=True,
             )
         except Exception as e:
             print(f"❌ Error running MCP server on port {port}: {e}")

tooluniverse/medrxiv_tool.py

@@ -34,13 +34,15 @@ class MedRxivTool(BaseTool):
         # Format: /medrxiv/{start_date}/{end_date}/{cursor}/json
         from datetime import datetime, timedelta
 
-        # Search last 30 days
+        # Search last 365 days to get more comprehensive results
         end_date = datetime.now()
-        start_date = end_date - timedelta(days=30)
+        start_date = end_date - timedelta(days=365)
 
-        url = (f"{self.base_url}/medrxiv/"
-               f"{start_date.strftime('%Y-%m-%d')}/"
-               f"{end_date.strftime('%Y-%m-%d')}/0/json")
+        url = (
+            f"{self.base_url}/medrxiv/"
+            f"{start_date.strftime('%Y-%m-%d')}/"
+            f"{end_date.strftime('%Y-%m-%d')}/0/json"
+        )
 
         try:
             resp = requests.get(url, timeout=20)
@@ -78,19 +80,36 @@ class MedRxivTool(BaseTool):
             doi = item.get("doi")
             url = f"https://www.medrxiv.org/content/{doi}" if doi else None
 
-            # Filter by query if provided
-            if query and query.lower() not in (title or "").lower():
-                continue
+            # Filter by query if provided - search in both title and abstract
+            if query:
+                title_match = query.lower() in (title or "").lower()
+                abstract_match = (
+                    query.lower() in (item.get("abstract", "") or "").lower()
+                )
+                if not (title_match or abstract_match):
+                    continue
 
             results.append(
                 {
-                    "title": title,
-                    "authors": authors,
+                    "title": title or "Title not available",
+                    "authors": (
+                        authors if authors else "Author information not available"
+                    ),
                     "year": year,
-                    "doi": doi,
-                    "url": url,
-                    "abstract": item.get("abstract", ""),
+                    "doi": doi or "DOI not available",
+                    "url": url or "URL not available",
+                    "abstract": item.get("abstract", "Abstract not available"),
                     "source": "medRxiv",
+                    "data_quality": {
+                        "has_abstract": bool(
+                            item.get("abstract")
+                            and item.get("abstract") != "Abstract not available"
+                        ),
+                        "has_authors": bool(authors),
+                        "has_year": bool(year),
+                        "has_doi": bool(doi),
+                        "has_url": bool(url),
+                    },
                 }
             )