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

tooluniverse/__init__.py

@@ -9,6 +9,15 @@ from .default_config import default_tool_files
 __version__ = version("tooluniverse")
 from .tool_registry import register_tool, get_tool_registry
 
+# Import tools with graceful fallback
+try:
+    from . import tools
+
+    _TOOLS_AVAILABLE = True
+except ImportError:
+    _TOOLS_AVAILABLE = False
+    tools = None  # type: ignore
+
 # Check if lazy loading is enabled
 # LAZY_LOADING_ENABLED = os.getenv('TOOLUNIVERSE_LAZY_LOADING', 'true').lower() in ('true', '1', 'yes')
 LAZY_LOADING_ENABLED = (
@@ -150,6 +159,9 @@ MCPAutoLoaderTool: Any
 ADMETAITool: Any
 AlphaFoldRESTTool: Any
 ComposeTool: Any
+CellosaurusSearchTool: Any
+CellosaurusQueryConverterTool: Any
+CellosaurusGetCellLineInfoTool: Any
 if not LAZY_LOADING_ENABLED:
     # Import all tool classes immediately (old behavior) with warning suppression  # noqa: E501
     with warnings.catch_warnings():
@@ -224,6 +236,12 @@ if not LAZY_LOADING_ENABLED:
         ODPHPTopicSearch,
         ODPHPOutlinkFetch,
     )
+    from .cellosaurus_tool import (
+        CellosaurusSearchTool,
+        CellosaurusQueryConverterTool,
+        CellosaurusGetCellLineInfoTool,
+    )
+
     # Literature search tools
     from .arxiv_tool import ArXivTool
     from .crossref_tool import CrossrefTool
@@ -318,6 +336,15 @@ else:
     ODPHPMyHealthfinder = _LazyImportProxy("odphp_tool", "ODHPHPMyHealthfinder")
     ODPHPTopicSearch = _LazyImportProxy("odphp_tool", "ODPHPTopicSearch")
     ODPHPOutlinkFetch = _LazyImportProxy("odphp_tool", "ODPHPOutlinkFetch")
+    CellosaurusSearchTool = _LazyImportProxy(
+        "cellosaurus_tool", "CellosaurusSearchTool"
+    )
+    CellosaurusQueryConverterTool = _LazyImportProxy(
+        "cellosaurus_tool", "CellosaurusQueryConverterTool"
+    )
+    CellosaurusGetCellLineInfoTool = _LazyImportProxy(
+        "cellosaurus_tool", "CellosaurusGetCellLineInfoTool"
+    )
     # Literature search tools
     ArXivTool = _LazyImportProxy("arxiv_tool", "ArXivTool")
     CrossrefTool = _LazyImportProxy("crossref_tool", "CrossrefTool")
@@ -338,6 +365,7 @@ __all__ = [
     "BaseTool",
     "register_tool",
     "get_tool_registry",
+    "tools",
     "MonarchTool",
     "MonarchDiseasesForMultiplePhenoTool",
     "ClinicalTrialsSearchTool",
@@ -402,6 +430,9 @@ __all__ = [
     "ODPHPItemList",
     "ODPHPTopicSearch",
     "ODPHPOutlinkFetch",
+    "CellosaurusSearchTool",
+    "CellosaurusQueryConverterTool",
+    "CellosaurusGetCellLineInfoTool",
     # Literature search tools
     "ArXivTool",
     "CrossrefTool",

tooluniverse/agentic_tool.py

@@ -8,7 +8,7 @@ from typing import Any, Callable, Dict, List, Optional
 from .base_tool import BaseTool
 from .tool_registry import register_tool
 from .logging_config import get_logger
-from .llm_clients import AzureOpenAIClient, GeminiClient, OpenRouterClient
+from .llm_clients import AzureOpenAIClient, GeminiClient, OpenRouterClient, VLLMClient
 
 
 # Global default fallback configuration
@@ -23,6 +23,7 @@ API_KEY_ENV_VARS = {
     "CHATGPT": ["AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT"],
     "OPENROUTER": ["OPENROUTER_API_KEY"],
     "GEMINI": ["GEMINI_API_KEY"],
+    "VLLM": ["VLLM_SERVER_URL"],
 }
 
 
@@ -201,7 +202,9 @@ class AgenticTool(BaseTool):
             f"Tool '{self.name}' failed to initialize with all available APIs"
         )
 
-    def _try_api(self, api_type: str, model_id: str) -> bool:
+    def _try_api(
+        self, api_type: str, model_id: str, server_url: Optional[str] = None
+    ) -> bool:
         """Try to initialize a specific API and model."""
         try:
             if api_type == "CHATGPT":
@@ -210,6 +213,12 @@ class AgenticTool(BaseTool):
                 self._llm_client = OpenRouterClient(model_id, self.logger)
             elif api_type == "GEMINI":
                 self._llm_client = GeminiClient(model_id, self.logger)
+            elif api_type == "VLLM":
+                if not server_url:
+                    server_url = os.getenv("VLLM_SERVER_URL")
+                if not server_url:
+                    raise ValueError("VLLM_SERVER_URL environment variable not set")
+                self._llm_client = VLLMClient(model_id, server_url, self.logger)
             else:
                 raise ValueError(f"Unsupported API type: {api_type}")
 
@@ -243,7 +252,7 @@ class AgenticTool(BaseTool):
 
     # ------------------------------------------------------------------ LLM utilities -----------
     def _validate_model_config(self):
-        supported_api_types = ["CHATGPT", "OPENROUTER", "GEMINI"]
+        supported_api_types = ["CHATGPT", "OPENROUTER", "GEMINI", "VLLM"]
         if self._api_type not in supported_api_types:
             raise ValueError(
                 f"Unsupported API type: {self._api_type}. Supported types: {supported_api_types}"
@@ -415,7 +424,29 @@ class AgenticTool(BaseTool):
                     },
                 }
             else:
-                return f"error: {str(e)} error_type: {type(e).__name__}"
+                from .utils import format_error_response
+
+                return format_error_response(
+                    e,
+                    self.name,
+                    {
+                        "prompt_used": (
+                            formatted_prompt
+                            if "formatted_prompt" in locals()
+                            else "Failed to format prompt"
+                        ),
+                        "input_arguments": {
+                            arg: arguments.get(arg) for arg in self._input_arguments
+                        },
+                        "model_info": {
+                            "api_type": self._api_type,
+                            "model_id": self._model_id,
+                            "temperature": self._temperature,
+                            "max_new_tokens": self._max_new_tokens,
+                        },
+                        "execution_time_seconds": execution_time,
+                    },
+                )
 
     @staticmethod
     def _iter_chunks(text: str, size: int = 800):
@@ -518,6 +549,11 @@ class AgenticTool(BaseTool):
                 self._llm_client = OpenRouterClient(self._model_id, self.logger)
             elif self._api_type == "GEMINI":
                 self._llm_client = GeminiClient(self._gemini_model_id, self.logger)
+            elif self._api_type == "VLLM":
+                server_url = os.getenv("VLLM_SERVER_URL")
+                if not server_url:
+                    raise ValueError("VLLM_SERVER_URL environment variable not set")
+                self._llm_client = VLLMClient(self._model_id, server_url, self.logger)
             else:
                 raise ValueError(f"Unsupported API type: {self._api_type}")
 

tooluniverse/arxiv_tool.py

@@ -83,18 +83,14 @@ class ArXivTool(BaseTool):
                 link = link_el.get("href")
             else:
                 link = entry.findtext("atom:id", default="", namespaces=ns)
-            published = entry.findtext(
-                "atom:published", default="", namespaces=ns
-            )
+            published = entry.findtext("atom:published", default="", namespaces=ns)
             updated = entry.findtext("atom:updated", default="", namespaces=ns)
             authors = [
                 a.findtext("atom:name", default="", namespaces=ns)
                 for a in entry.findall("atom:author", ns)
             ]
             primary_category = ""
-            cat_el = entry.find(
-                "{http://arxiv.org/schemas/atom}primary_category"
-            )
+            cat_el = entry.find("{http://arxiv.org/schemas/atom}primary_category")
             if cat_el is not None:
                 primary_category = cat_el.get("term", "")
 

tooluniverse/base_tool.py

@@ -1,23 +1,18 @@
 from .utils import extract_function_call_json, evaluate_function_call
+from .exceptions import (
+    ToolError,
+    ToolValidationError,
+    ToolAuthError,
+    ToolRateLimitError,
+    ToolUnavailableError,
+    ToolConfigError,
+    ToolDependencyError,
+    ToolServerError,
+)
 import json
 from pathlib import Path
-from typing import no_type_check
-
-
-class ToolExecutionError(Exception):
-    """Base exception for tool execution errors."""
-
-
-class ValidationError(Exception):
-    """Exception raised when input validation fails."""
-
-
-class AuthenticationError(Exception):
-    """Exception raised when authentication fails."""
-
-
-class RateLimitError(Exception):
-    """Exception raised when API rate limit is exceeded."""
+from typing import no_type_check, Optional, Dict, Any
+import hashlib
 
 
 class BaseTool:
@@ -122,12 +117,26 @@ class BaseTool:
         return merged_config
 
     @no_type_check
-    def run(self, arguments=None):
+    def run(self, arguments=None, stream_callback=None, use_cache=False, validate=True):
         """Execute the tool.
 
         The default BaseTool implementation accepts an optional arguments
         mapping to align with most concrete tool implementations which expect
         a dictionary of inputs.
+
+        Args:
+            arguments (dict, optional): Tool-specific arguments
+            stream_callback (callable, optional): Callback for streaming responses
+            use_cache (bool, optional): Whether result caching is enabled
+            validate (bool, optional): Whether parameter validation was performed
+
+        Note:
+            These additional parameters (stream_callback, use_cache, validate) are
+            passed from run_one_function() to provide context about the execution.
+            Tools can use these for optimization or special handling.
+
+            For backward compatibility, tools that don't accept these parameters
+            will still work - they will only receive the arguments parameter.
         """
 
     def check_function_call(self, function_call_json):
@@ -144,12 +153,152 @@ class BaseTool:
         Returns:
         list: List of required parameters for the given endpoint.
         """
-        required_params = []
-        parameters = self.tool_config.get("parameter", {}).get("properties", {})
+        schema = self.tool_config.get("parameter", {})
+        required_params = schema.get("required", [])
+        return required_params
+
+    def validate_parameters(self, arguments: Dict[str, Any]) -> Optional[ToolError]:
+        """
+        Validate parameters against tool schema.
 
-        # Check each parameter to see if it is required
-        for param, details in parameters.items():
-            if details.get("required", False):
-                required_params.append(param.lower())
+        This method provides standard parameter validation using jsonschema.
+        Subclasses can override this method to implement custom validation
+        logic.
 
-        return required_params
+        Args:
+            arguments: Dictionary of arguments to validate
+
+        Returns:
+            ToolError if validation fails, None if validation passes
+        """
+        schema = self.tool_config.get("parameter", {})
+
+        if not schema:
+            return None  # No schema to validate against
+
+        try:
+            import jsonschema
+
+            jsonschema.validate(arguments, schema)
+            return None
+        except jsonschema.ValidationError as e:
+            return ToolValidationError(
+                f"Parameter validation failed: {e.message}",
+                details={
+                    "validation_error": str(e),
+                    "path": list(e.absolute_path) if e.absolute_path else [],
+                    "schema": schema,
+                },
+            )
+        except Exception as e:
+            return ToolValidationError(f"Validation error: {str(e)}")
+
+    def handle_error(self, exception: Exception) -> ToolError:
+        """
+        Classify a raw exception into a structured ToolError.
+
+        This method provides standard error classification. Subclasses can
+        override this method to implement custom error handling logic.
+
+        Args:
+            exception: The raw exception to classify
+
+        Returns:
+            Structured ToolError instance
+        """
+        error_str = str(exception).lower()
+
+        if any(
+            keyword in error_str
+            for keyword in ["auth", "unauthorized", "401", "403", "api key", "token"]
+        ):
+            return ToolAuthError(f"Authentication failed: {exception}")
+        elif any(
+            keyword in error_str
+            for keyword in ["rate limit", "429", "quota", "limit exceeded"]
+        ):
+            return ToolRateLimitError(f"Rate limit exceeded: {exception}")
+        elif any(
+            keyword in error_str
+            for keyword in [
+                "unavailable",
+                "timeout",
+                "connection",
+                "network",
+                "not found",
+                "404",
+            ]
+        ):
+            return ToolUnavailableError(f"Tool unavailable: {exception}")
+        elif any(
+            keyword in error_str
+            for keyword in ["validation", "invalid", "schema", "parameter"]
+        ):
+            return ToolValidationError(f"Validation error: {exception}")
+        elif any(
+            keyword in error_str for keyword in ["config", "configuration", "setup"]
+        ):
+            return ToolConfigError(f"Configuration error: {exception}")
+        elif any(
+            keyword in error_str
+            for keyword in ["import", "module", "dependency", "package"]
+        ):
+            return ToolDependencyError(f"Dependency error: {exception}")
+        else:
+            return ToolServerError(f"Unexpected error: {exception}")
+
+    def get_cache_key(self, arguments: Dict[str, Any]) -> str:
+        """
+        Generate a cache key for this tool call.
+
+        This method provides standard cache key generation. Subclasses can
+        override this method to implement custom caching logic.
+
+        Args:
+            arguments: Dictionary of arguments for the tool call
+
+        Returns:
+            String cache key
+        """
+        # Include tool name and arguments in cache key
+        cache_data = {
+            "tool_name": self.tool_config.get("name", self.__class__.__name__),
+            "arguments": arguments,
+        }
+        serialized = json.dumps(cache_data, sort_keys=True)
+        return hashlib.md5(serialized.encode()).hexdigest()
+
+    def supports_streaming(self) -> bool:
+        """
+        Check if this tool supports streaming responses.
+
+        Returns:
+            True if tool supports streaming, False otherwise
+        """
+        return self.tool_config.get("supports_streaming", False)
+
+    def supports_caching(self) -> bool:
+        """
+        Check if this tool's results can be cached.
+
+        Returns:
+            True if tool results can be cached, False otherwise
+        """
+        return self.tool_config.get("cacheable", True)
+
+    def get_tool_info(self) -> Dict[str, Any]:
+        """
+        Get comprehensive information about this tool.
+
+        Returns:
+            Dictionary containing tool metadata
+        """
+        return {
+            "name": self.tool_config.get("name", self.__class__.__name__),
+            "description": self.tool_config.get("description", ""),
+            "supports_streaming": self.supports_streaming(),
+            "supports_caching": self.supports_caching(),
+            "required_parameters": self.get_required_parameters(),
+            "parameter_schema": self.tool_config.get("parameter", {}),
+            "tool_type": self.__class__.__name__,
+        }

tooluniverse/biorxiv_tool.py

@@ -6,7 +6,7 @@ from .tool_registry import register_tool
 @register_tool("BioRxivTool")
 class BioRxivTool(BaseTool):
     """
-    Search bioRxiv preprints using the public bioRxiv API.
+    Search bioRxiv preprints using bioRxiv's API (same interface as medRxiv).
 
     Arguments:
         query (str): Search term
@@ -16,7 +16,7 @@ class BioRxivTool(BaseTool):
     def __init__(
         self,
         tool_config,
-        base_url="https://api.medrxiv.org/details",
+        base_url="https://api.biorxiv.org/details",
     ):
         super().__init__(tool_config)
         self.base_url = base_url
@@ -30,17 +30,19 @@ class BioRxivTool(BaseTool):
         return self._search(query, max_results)
 
     def _search(self, query, max_results):
-        # Use date range search for recent preprints
+        # Use date range search for preprints
         # Format: /biorxiv/{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}/biorxiv/"
-               f"{start_date.strftime('%Y-%m-%d')}/"
-               f"{end_date.strftime('%Y-%m-%d')}/0/json")
+        url = (
+            f"{self.base_url}/biorxiv/"
+            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 BioRxivTool(BaseTool):
             doi = item.get("doi")
             url = f"https://www.biorxiv.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": "bioRxiv",
+                    "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),
+                    },
                 }
             )