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

tooluniverse/fatcat_tool.py

@@ -63,4 +63,3 @@ class FatcatScholarTool(BaseTool):
             )
 
         return results
-

tooluniverse/generate_tools.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""Minimal tools generator - one tool, one file."""
+
+from pathlib import Path
+from typing import Dict, Any
+
+
+def json_type_to_python(json_type: str) -> str:
+    """Convert JSON type to Python type."""
+    return {
+        "string": "str",
+        "integer": "int",
+        "number": "float",
+        "boolean": "bool",
+        "array": "list[Any]",
+        "object": "dict[str, Any]",
+    }.get(json_type, "Any")
+
+
+def generate_tool_file(tool_name: str, tool_config: Dict[str, Any], output_dir: Path):
+    """Generate one file for one tool."""
+    schema = tool_config.get("parameter", {}) or {}
+    description = tool_config.get("description", f"Execute {tool_name}")
+    # Wrap long descriptions
+    if len(description) > 100:
+        description = description[:97] + "..."
+    properties = schema.get("properties", {}) or {}
+    required = schema.get("required", []) or []
+
+    # Build parameters - required first, then optional
+    required_params = []
+    optional_params = []
+    kwargs = []
+    doc_params = []
+    mutable_defaults_code = []
+
+    for name, prop in properties.items():
+        py_type = json_type_to_python(prop.get("type", "string"))
+        desc = prop.get("description", "")
+
+        if name in required:
+            required_params.append(f"{name}: {py_type}")
+        else:
+            default = prop.get("default")
+            if default is not None:
+                # Handle mutable defaults to avoid B006 linting error
+                if isinstance(default, (list, dict)):
+                    # Use None as default and handle in function body
+                    optional_params.append(f"{name}: Optional[{py_type}] = None")
+                    mutable_defaults_code.append(
+                        f"    if {name} is None:\n        {name} = {repr(default)}"
+                    )
+                else:
+                    optional_params.append(
+                        f"{name}: Optional[{py_type}] = {repr(default)}"
+                    )
+            else:
+                optional_params.append(f"{name}: Optional[{py_type}] = None")
+
+        kwargs.append(f'"{name}": {name}')
+        # Wrap long descriptions
+        if len(desc) > 80:
+            desc = desc[:77] + "..."
+        doc_params.append(f"    {name} : {py_type}\n        {desc}")
+
+    # Combine required and optional parameters
+    params = required_params + optional_params
+
+    params_str = ",\n    ".join(params) if params else ""
+    kwargs_str = ",\n                ".join(kwargs) if kwargs else ""
+    doc_params_str = "\n".join(doc_params) if doc_params else "    No parameters"
+    mutable_defaults_str = (
+        "\n".join(mutable_defaults_code) if mutable_defaults_code else ""
+    )
+
+    # Infer return type
+    return_schema = tool_config.get("return_schema", {})
+    return_type = (
+        json_type_to_python(return_schema.get("type", "")) if return_schema else "Any"
+    )
+
+    content = f'''"""
+{tool_name}
+
+{description}
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def {tool_name}(
+    {params_str}{"," if params_str else ""}
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> {return_type}:
+    """
+    {description}
+
+    Parameters
+    ----------
+{doc_params_str}
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    {return_type}
+    """
+    # Handle mutable defaults to avoid B006 linting error
+{mutable_defaults_str}
+    return get_shared_client().run_one_function(
+        {{
+            "name": "{tool_name}",
+            "arguments": {{
+                {kwargs_str}
+            }}
+        }},
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate
+    )
+
+
+__all__ = ["{tool_name}"]
+'''
+
+    (output_dir / f"{tool_name}.py").write_text(content)
+
+
+def generate_init(tool_names: list, output_dir: Path):
+    """Generate __init__.py with all imports."""
+    imports = [f"from .{name} import {name}" for name in sorted(tool_names)]
+
+    # Generate the content without f-string escape sequences
+    all_names = ",\n    ".join(f'"{name}"' for name in sorted(tool_names))
+    content = f'''"""
+ToolUniverse Tools
+
+Type-safe Python interface to {len(tool_names)} scientific tools.
+Each tool is in its own module for minimal import overhead.
+
+Usage:
+    from tooluniverse.tools import ArXiv_search_papers
+    result = ArXiv_search_papers(query="machine learning")
+"""
+
+# Import exceptions from main package
+from tooluniverse.exceptions import *
+
+# Import shared client utilities
+from ._shared_client import get_shared_client, reset_shared_client
+
+# Import all tools
+{chr(10).join(imports)}
+
+__all__ = [
+    "get_shared_client",
+    "reset_shared_client",
+    {all_names}
+]
+'''
+
+    (output_dir / "__init__.py").write_text(content)
+
+
+def main():
+    """Generate tools."""
+    from tooluniverse import ToolUniverse
+
+    print("🔧 Generating tools...")
+
+    tu = ToolUniverse()
+    tu.load_tools()
+
+    output = Path("src/tooluniverse/tools")
+    output.mkdir(parents=True, exist_ok=True)
+
+    # Generate all tools
+    for i, (tool_name, tool_config) in enumerate(tu.all_tool_dict.items(), 1):
+        generate_tool_file(tool_name, tool_config, output)
+        if i % 50 == 0:
+            print(f"  Generated {i} tools...")
+
+    # Generate __init__.py
+    generate_init(list(tu.all_tool_dict.keys()), output)
+
+    print(f"✅ Generated {len(tu.all_tool_dict)} tools in {output}")
+
+
+if __name__ == "__main__":
+    main()

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