tooluniverse 1.0.2__py3-none-any.whl → 1.0.3__py3-none-any.whl

tooluniverse/compose_scripts/tool_metadata_generator.py

@@ -17,6 +17,7 @@ def compose(arguments, tooluniverse, call_tool):
     """
     import json
     import warnings
+    import uuid
     from collections import Counter
 
     def _parse_agent_output(output, tool_name="Unknown Tool"):
@@ -365,5 +366,10 @@ def compose(arguments, tooluniverse, call_tool):
 
     except Exception as e:
         print(f"An error occurred during single-occurrence tag removal: {e}")
+    
+    # Step 6: Manually set the UUID 'id' field to ensure true randomness
+    for tool_metadata in all_tool_metadata:
+        if 'error' not in tool_metadata:
+            tool_metadata['id'] = str(uuid.uuid4())
 
     return all_tool_metadata

tooluniverse/data/agentic_tools.json

@@ -1162,7 +1162,7 @@
         "type": "AgenticTool",
         "name": "ToolMetadataGenerator",
         "description": "Generates a JSON structure with the metadata of a tool in ToolUniverse, given the JSON configuration of the tool.",
-        "prompt": "You are an expert in processing ToolUniverse tool configurations. Your task is to extract and generate key metadata from a given tool's JSON configuration and return it as a new, structured JSON object.\n\n**Input Tool Configuration:**\n```json\n{tool_config}\n```\n\n**Tool Type Mappings (for simplifying toolType):**\n```json\n{tool_type_mappings}\n```\n\n**Instructions:**\nFrom the input configuration, generate a new JSON object with the specified structure. All fields enclosed in '<','>' are placeholders for instructions; you should generate a specific value for the tool based on its configuration. Fields not in brackets should use the default values provided.\n\n**Output JSON Structure:**\n```json\n{\n    \"id\": \"<generate a new uuid>\",\n    \"name\": \"<extract from tool_config.name>\",\n    \"description\": \"<extract and tool_config.description and slightly summarize it if it is too long>\",\n    \"detailed_description\": \"<extract from tool_config.description>\",\n    \"toolType\": \"<if tool_config.type or tool_config.name appears in tool_type_mappings dict in one of the lists (among the dict's values), extract the corresponding key and set it as the simplified toolType. otherwise, set toolType to be 'API' (the default)>\",\n    \"tags\": [],\n    \"category\": \"<extract from tool_config.type>\",\n    \"lab\": \"Zitnik Lab\",\n    \"source\": \"<extract the name of the database, package, model, or write 'Agentic'>\",\n    \"version\": \"v1.0.0\",\n    \"reviewed\": true,\n    \"isValidated\": true,\n    \"usageStats\": \"100+ uses\",\n    \"capabilities\": [\n      \"<list capabilities strictly derivable from tool_config>\"\n    ],\n    \"limitations\": [\n      \"May require refinement\"\n    ],\n    \"parameters\": {<for each parameter key include an object with type and description>},\n    \"inputSchema\": <echo tool_config.parameter exactly>,\n    \"exampleInput\": <JSON object with example values for each parameter>,\n    \"apiEndpoints\": [\n      {\n        \"method\": \"MCP\",\n        \"url\": \"https://tooluniversemcpserver.onrender.com/mcp/\"\n      }\n    ]\n}\n```\n\nReturn ONLY the final JSON object with no extra commentary.",
+        "prompt": "You are an expert in processing ToolUniverse tool configurations. Your task is to extract and generate key metadata from a given tool's JSON configuration and return it as a new, structured JSON object.\n\n**Input Tool Configuration:**\n```json\n{tool_config}\n```\n\n**Tool Type Mappings (for simplifying toolType):**\n```json\n{tool_type_mappings}\n```\n\n**Instructions:**\nFrom the input configuration, generate a new JSON object with the specified structure. All fields enclosed in '<','>' are placeholders for instructions; you should generate a specific value for the tool based on its configuration. Fields not in brackets should use the default values provided.\n\n**Output JSON Structure:**\n```json\n{\n    \"id\": \"<generate a new uuid>\",\n    \"name\": \"<extract from tool_config.name>\",\n    \"description\": \"<extract and tool_config.description and slightly summarize it if it is too long>\",\n    \"detailed_description\": \"<extract from tool_config.description>\",\n    \"toolType\": \"<if tool_config.type or tool_config.name appears in tool_type_mappings dict in one of the lists (among the dict's values), extract the corresponding key and set it as the simplified toolType. otherwise, set toolType to be 'API' (the default)>\",\n    \"tags\": [],\n    \"category\": \"<extract from tool_config.type>\",\n    \"lab\": \"Zitnik Lab\",\n    \"source\": \"<extract the name of the database, package, model, or write 'Agentic'>\",\n    \"version\": \"v1.0.0\",\n    \"reviewed\": true,\n    \"isValidated\": true,\n    \"usageStats\": \"100+ uses\",\n    \"capabilities\": [\n      \"<list capabilities strictly derivable from tool_config>\"\n    ],\n    \"limitations\": [\n      \"None for now\"\n    ],\n    \"parameters\": {<for each parameter key include an object with type and description>},\n    \"inputSchema\": <echo tool_config.parameter exactly>,\n    \"exampleInput\": <JSON object with example values for each parameter>,\n    \"apiEndpoints\": [\n      {\n        \"method\": \"MCP\",\n        \"url\": \"https://tooluniversemcpserver.onrender.com/mcp/\"\n      }\n    ]\n}\n```\n\nReturn ONLY the final JSON object with no extra commentary.",
         "input_arguments": [
             "tool_config",
             "tool_type_mappings"

tooluniverse/execute_function.py

@@ -1000,9 +1000,9 @@ class ToolUniverse:
         """
         return copy.deepcopy(self.all_tools)
 
-    def list_built_in_tools(self, mode="config"):
+    def list_built_in_tools(self, mode="config", scan_all=False):
         """
-        List all built-in tool categories and their statistics with two different modes.
+        List all built-in tool categories and their statistics with different modes.
 
         This method provides a comprehensive overview of all available tools in the ToolUniverse,
         organized by categories. It reads directly from the default tool files to gather statistics,
@@ -1012,39 +1012,62 @@ class ToolUniverse:
             mode (str, optional): Organization mode for tools. Defaults to 'config'.
                 - 'config': Organize by config file categories (original behavior)
                 - 'type': Organize by tool types (implementation classes)
+                - 'list_name': Return a list of all tool names
+                - 'list_spec': Return a list of all tool specifications
+            scan_all (bool, optional): Whether to scan all JSON files in data directory recursively.
+                If True, scans all JSON files in data/ and its subdirectories.
+                If False (default), uses predefined tool file mappings.
 
         Returns:
-            dict: A dictionary containing tool statistics with the following structure:
-
-                {
-                    'categories': {
-                        'category_name': {
-                            'count': int,          # Number of tools in this category
-                            'tools': list          # List of tool names (only when mode='type')
-                        },
-                        ...
-                    },
-                    'total_categories': int,        # Total number of tool categories
-                    'total_tools': int,            # Total number of unique tools
-                    'mode': str,                   # The mode used for organization
-                    'summary': str                 # Human-readable summary of statistics
-                }
+            dict or list:
+                - For 'config' and 'type' modes: A dictionary containing tool statistics
+                - For 'list_name' mode: A list of all tool names
+                - For 'list_spec' mode: A list of all tool specifications
 
         Example:
             >>> tool_universe = ToolUniverse()
-            >>> # Group by config file categories
+            >>> # Group by config file categories (predefined files only)
             >>> stats = tool_universe.list_built_in_tools(mode='config')
-            >>> # Group by tool types
-            >>> stats = tool_universe.list_built_in_tools(mode='type')
+            >>> # Scan all JSON files in data directory recursively
+            >>> stats = tool_universe.list_built_in_tools(mode='config', scan_all=True)
+            >>> # Get all tool names from all JSON files
+            >>> tool_names = tool_universe.list_built_in_tools(mode='list_name', scan_all=True)
 
         Note:
             - This method reads directly from tool files and works without calling load_tools()
             - Tools are deduplicated across categories, so the same tool won't be counted multiple times
-            - The summary is automatically printed to console when this method is called
+            - The summary is automatically printed to console when this method is called (except for list_name and list_spec modes)
+            - When scan_all=True, all JSON files in data/ and subdirectories are scanned
         """
-        if mode not in ["config", "type"]:
-            raise ValueError("Mode must be either 'config' or 'type'")
+        if mode not in ["config", "type", "list_name", "list_spec"]:
+            raise ValueError(
+                "Mode must be one of: 'config', 'type', 'list_name', 'list_spec'"
+            )
 
+        # For list_name and list_spec modes, we can return early with just the data
+        if mode in ["list_name", "list_spec"]:
+            all_tools = []
+            all_tool_names = set()  # For deduplication across categories
+
+            if scan_all:
+                # Scan all JSON files in data directory recursively
+                all_tools, all_tool_names = self._scan_all_json_files()
+            else:
+                # Use predefined tool files (original behavior)
+                all_tools, all_tool_names = self._scan_predefined_files()
+
+            # Deduplicate tools by name
+            unique_tools = {}
+            for tool in all_tools:
+                if tool["name"] not in unique_tools:
+                    unique_tools[tool["name"]] = tool
+
+            if mode == "list_name":
+                return sorted(list(unique_tools.keys()))
+            elif mode == "list_spec":
+                return list(unique_tools.values())
+
+        # Original logic for config and type modes
         result = {
             "categories": {},
             "total_categories": 0,
@@ -1053,58 +1076,43 @@ class ToolUniverse:
             "summary": "",
         }
 
-        all_tool_names = set()  # For deduplication across categories
-        all_tools = []  # Store all tools for type-based grouping
-
-        # Read tools from each category file
-        for category, file_path in self.tool_files.items():
-            try:
-                # Read the JSON file for this category
-                tools_in_category = read_json_list(file_path)
-                all_tools.extend(tools_in_category)
+        if scan_all:
+            # Scan all JSON files in data directory recursively
+            all_tools, all_tool_names = self._scan_all_json_files()
 
-                if mode == "config":
-                    tool_names = [tool["name"] for tool in tools_in_category]
-                    result["categories"][category] = {"count": len(tool_names)}
+            # For config mode with scan_all, organize by file names
+            if mode == "config":
+                file_tools_map = {}
+                for tool in all_tools:
+                    # Get the source file for this tool (we need to track this)
+                    # For now, we'll organize by tool type as a fallback
+                    tool_type = tool.get("type", "Unknown")
+                    if tool_type not in file_tools_map:
+                        file_tools_map[tool_type] = []
+                    file_tools_map[tool_type].append(tool)
+
+                for category, tools in file_tools_map.items():
+                    result["categories"][category] = {"count": len(tools)}
+        else:
+            # Use predefined tool files (original behavior)
+            all_tools, all_tool_names = self._scan_predefined_files()
 
-                # Add to global set for deduplication
-                all_tool_names.update([tool["name"] for tool in tools_in_category])
+            # Read tools from each category file
+            for category, file_path in self.tool_files.items():
+                try:
+                    # Read the JSON file for this category
+                    tools_in_category = read_json_list(file_path)
 
-            except Exception as e:
-                warning(
-                    f"Warning: Could not read tools from {category} ({file_path}): {e}"
-                )
-                if mode == "config":
-                    result["categories"][category] = {"count": 0}
+                    if mode == "config":
+                        tool_names = [tool["name"] for tool in tools_in_category]
+                        result["categories"][category] = {"count": len(tool_names)}
 
-        # Also include remote tools for listing purposes (not auto-loaded elsewhere)
-        try:
-            remote_dir = os.path.join(current_dir, "data", "remote_tools")
-            if os.path.isdir(remote_dir):
-                remote_tools = []
-                for fname in os.listdir(remote_dir):
-                    if not fname.lower().endswith(".json"):
-                        continue
-                    fpath = os.path.join(remote_dir, fname)
-                    try:
-                        tools_in_file = read_json_list(fpath)
-                        if isinstance(tools_in_file, dict):
-                            tools_in_file = list(tools_in_file.values())
-                        if isinstance(tools_in_file, list):
-                            remote_tools.extend(tools_in_file)
-                    except Exception as e:
-                        warning(
-                            f"Warning: Could not read remote tools from {fpath}: {e}"
-                        )
-                if remote_tools:
-                    all_tools.extend(remote_tools)
-                    all_tool_names.update([tool["name"] for tool in remote_tools])
+                except Exception as e:
+                    warning(
+                        f"Warning: Could not read tools from {category} ({file_path}): {e}"
+                    )
                     if mode == "config":
-                        result["categories"]["remote_tools"] = {
-                            "count": len(remote_tools)
-                        }
-        except Exception as e:
-            warning(f"Warning: Failed to scan remote tools directory: {e}")
+                        result["categories"][category] = {"count": 0}
 
         # If mode is 'type', organize by tool types instead
         if mode == "type":
@@ -1202,6 +1210,113 @@ class ToolUniverse:
 
         return result
 
+    def _scan_predefined_files(self):
+        """
+        Scan predefined tool files (original behavior).
+
+        Returns:
+            tuple: (all_tools, all_tool_names) where all_tools is a list of tool configs
+                   and all_tool_names is a set of tool names for deduplication
+        """
+        all_tools = []
+        all_tool_names = set()
+
+        # Read tools from each category file
+        for category, file_path in self.tool_files.items():
+            try:
+                # Read the JSON file for this category
+                tools_in_category = read_json_list(file_path)
+                all_tools.extend(tools_in_category)
+                all_tool_names.update([tool["name"] for tool in tools_in_category])
+            except Exception as e:
+                warning(
+                    f"Warning: Could not read tools from {category} ({file_path}): {e}"
+                )
+
+        # Also include remote tools
+        try:
+            remote_dir = os.path.join(current_dir, "data", "remote_tools")
+            if os.path.isdir(remote_dir):
+                remote_tools = []
+                for fname in os.listdir(remote_dir):
+                    if not fname.lower().endswith(".json"):
+                        continue
+                    fpath = os.path.join(remote_dir, fname)
+                    try:
+                        tools_in_file = read_json_list(fpath)
+                        if isinstance(tools_in_file, dict):
+                            tools_in_file = list(tools_in_file.values())
+                        if isinstance(tools_in_file, list):
+                            remote_tools.extend(tools_in_file)
+                    except Exception as e:
+                        warning(
+                            f"Warning: Could not read remote tools from {fpath}: {e}"
+                        )
+                if remote_tools:
+                    all_tools.extend(remote_tools)
+                    all_tool_names.update([tool["name"] for tool in remote_tools])
+        except Exception as e:
+            warning(f"Warning: Failed to scan remote tools directory: {e}")
+
+        return all_tools, all_tool_names
+
+    def _scan_all_json_files(self):
+        """
+        Recursively scan all JSON files in the data directory and its subdirectories.
+
+        Returns:
+            tuple: (all_tools, all_tool_names) where all_tools is a list of tool configs
+                   and all_tool_names is a set of tool names for deduplication
+        """
+        all_tools = []
+        all_tool_names = set()
+
+        # Get the data directory path
+        data_dir = os.path.join(current_dir, "data")
+
+        if not os.path.exists(data_dir):
+            warning(f"Warning: Data directory not found: {data_dir}")
+            return all_tools, all_tool_names
+
+        # Recursively find all JSON files
+        json_files = []
+        for root, _dirs, files in os.walk(data_dir):
+            for file in files:
+                if file.lower().endswith(".json"):
+                    json_files.append(os.path.join(root, file))
+
+        self.logger.debug(f"Found {len(json_files)} JSON files to scan")
+
+        # Read tools from each JSON file
+        for json_file in json_files:
+            try:
+                tools_in_file = read_json_list(json_file)
+
+                # Handle different data formats
+                if isinstance(tools_in_file, dict):
+                    # Convert dict of tools to list of tools
+                    tools_in_file = list(tools_in_file.values())
+                elif not isinstance(tools_in_file, list):
+                    # Skip files that don't contain tool configurations
+                    continue
+
+                # Add tools to our collection
+                for tool in tools_in_file:
+                    if isinstance(tool, dict) and "name" in tool:
+                        all_tools.append(tool)
+                        all_tool_names.add(tool["name"])
+
+                self.logger.debug(f"Loaded {len(tools_in_file)} tools from {json_file}")
+
+            except Exception as e:
+                warning(f"Warning: Could not read tools from {json_file}: {e}")
+                continue
+
+        self.logger.info(
+            f"Scanned {len(json_files)} JSON files, found {len(all_tools)} tools"
+        )
+        return all_tools, all_tool_names
+
     def refresh_tool_name_desc(
         self,
         enable_full_desc=False,

tooluniverse/scripts/filter_tool_files.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""
+Script to filter tool files by removing tools that don't exist in the current tool universe.
+
+This script:
+1. Gets all valid tool names from ToolUniverse using scan_all=True
+2. Filters tool_relationship_graph_FINAL.json to keep only valid tools
+3. Filters v4_all_tools_final.json to keep only valid tools
+4. Preserves all other data structure and content
+"""
+
+import json
+from pathlib import Path
+
+# Import after modifying sys.path
+from tooluniverse import ToolUniverse
+
+
+def load_json_file(file_path):
+    """Load JSON file and return the data."""
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"Error loading {file_path}: {e}")
+        return None
+
+
+def save_json_file(file_path, data):
+    """Save data to JSON file."""
+    try:
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        print(f"Successfully saved filtered data to {file_path}")
+        return True
+    except Exception as e:
+        print(f"Error saving {file_path}: {e}")
+        return False
+
+
+def filter_tool_relationship_graph(data, valid_tool_names):
+    """
+    Filter tool_relationship_graph_FINAL.json to keep only valid tools.
+
+    Args:
+        data: The loaded JSON data
+        valid_tool_names: Set of valid tool names
+
+    Returns:
+        Filtered data
+    """
+    if not isinstance(data, dict):
+        print("Warning: tool_relationship_graph data is not a dict")
+        return data
+
+    filtered_data = {}
+
+    # Handle nodes array
+    if "nodes" in data and isinstance(data["nodes"], list):
+        filtered_nodes = []
+        for node in data["nodes"]:
+            if isinstance(node, dict) and "name" in node:
+                if node["name"] in valid_tool_names:
+                    filtered_nodes.append(node)
+                else:
+                    print(f"Removing node from relationship graph: {node['name']}")
+            else:
+                # Keep non-tool nodes (if any)
+                filtered_nodes.append(node)
+        filtered_data["nodes"] = filtered_nodes
+        print(
+            f"Nodes: {len(data['nodes'])} -> {len(filtered_nodes)} ({len(data['nodes']) - len(filtered_nodes)} removed)"
+        )
+
+    # Handle edges array
+    if "edges" in data and isinstance(data["edges"], list):
+        filtered_edges = []
+        for edge in data["edges"]:
+            if isinstance(edge, dict) and "source" in edge and "target" in edge:
+                # Keep edge if both source and target are valid tools
+                if (
+                    edge["source"] in valid_tool_names
+                    and edge["target"] in valid_tool_names
+                ):
+                    filtered_edges.append(edge)
+                else:
+                    print(
+                        f"Removing edge from relationship graph: {edge.get('source', 'unknown')} -> {edge.get('target', 'unknown')}"
+                    )
+            else:
+                # Keep non-tool edges (if any)
+                filtered_edges.append(edge)
+        filtered_data["edges"] = filtered_edges
+        print(
+            f"Edges: {len(data['edges'])} -> {len(filtered_edges)} ({len(data['edges']) - len(filtered_edges)} removed)"
+        )
+
+    # Keep other fields as-is (like stats, metadata, etc.)
+    for key, value in data.items():
+        if key not in ["nodes", "edges"]:
+            filtered_data[key] = value
+
+    return filtered_data
+
+
+def filter_v4_all_tools(data, valid_tool_names):
+    """
+    Filter v4_all_tools_final.json to keep only valid tools.
+
+    Args:
+        data: The loaded JSON data
+        valid_tool_names: Set of valid tool names
+
+    Returns:
+        Filtered data
+    """
+    if not isinstance(data, list):
+        print("Warning: v4_all_tools data is not a list")
+        return data
+
+    filtered_data = []
+
+    for tool in data:
+        if isinstance(tool, dict) and "name" in tool:
+            if tool["name"] in valid_tool_names:
+                filtered_data.append(tool)
+            else:
+                print(f"Removing tool from v4_all_tools: {tool['name']}")
+        else:
+            # Keep non-tool entries (if any)
+            filtered_data.append(tool)
+
+    return filtered_data
+
+
+def main():
+    """Main function to filter the tool files."""
+    print("Starting tool file filtering process...")
+
+    # Initialize ToolUniverse and get all valid tool names
+    print("Getting all valid tool names from ToolUniverse...")
+    tu = ToolUniverse()
+    all_tool_names = tu.list_built_in_tools(mode="list_name", scan_all=True)
+    valid_tool_names = set(all_tool_names)
+    print(f"Found {len(valid_tool_names)} valid tools")
+
+    # Define file paths
+    project_root = Path(__file__).parent.parent.parent.parent
+    web_dir = project_root / "web"
+
+    relationship_graph_file = web_dir / "tool_relationship_graph_FINAL.json"
+    v4_tools_file = web_dir / "v4_all_tools_final.json"
+
+    # Check if files exist
+    if not relationship_graph_file.exists():
+        print(f"Error: {relationship_graph_file} not found")
+        return
+
+    if not v4_tools_file.exists():
+        print(f"Error: {v4_tools_file} not found")
+        return
+
+    # Process tool_relationship_graph_FINAL.json
+    print(f"\nProcessing {relationship_graph_file.name}...")
+    relationship_data = load_json_file(relationship_graph_file)
+    if relationship_data is not None:
+        len(relationship_data.get("nodes", []))
+        len(relationship_data.get("edges", []))
+        filtered_relationship_data = filter_tool_relationship_graph(
+            relationship_data, valid_tool_names
+        )
+
+        # Save filtered data
+        save_json_file(relationship_graph_file, filtered_relationship_data)
+
+    # Process v4_all_tools_final.json
+    print(f"\nProcessing {v4_tools_file.name}...")
+    v4_data = load_json_file(v4_tools_file)
+    if v4_data is not None:
+        original_count = len(v4_data)
+        filtered_v4_data = filter_v4_all_tools(v4_data, valid_tool_names)
+        filtered_count = len(filtered_v4_data)
+        print(
+            f"V4 tools: {original_count} -> {filtered_count} tools ({original_count - filtered_count} removed)"
+        )
+
+        # Save filtered data
+        save_json_file(v4_tools_file, filtered_v4_data)
+
+    print("\nTool file filtering completed!")
+
+
+if __name__ == "__main__":
+    main()

tooluniverse/test/test_list_built_in_tools.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""
+Basic test for list_built_in_tools including scan_all option.
+Run directly: python tests/test_list_built_in_tools.py
+"""
+
+from tooluniverse import ToolUniverse  # noqa: E402
+
+
+def main():
+    tu = ToolUniverse()
+
+    # Use predefined files (original behavior)
+    tool_names = tu.list_built_in_tools(mode="list_name", scan_all=False)
+    print(f"predefined tool names: {len(tool_names)}")
+
+    # Scan all JSON files
+    all_tool_names = tu.list_built_in_tools(mode="list_name", scan_all=True)
+    print(f"all tool names (scan_all): {len(all_tool_names)}")
+
+    # Get all tool specifications
+    all_tool_specs = tu.list_built_in_tools(mode="list_spec", scan_all=True)
+    print(f"all tool specs (scan_all): {len(all_tool_specs)}")
+
+    # Organize all tools by type
+    type_stats = tu.list_built_in_tools(mode="type", scan_all=True)
+    print(
+        f"type stats -> total_categories: {type_stats['total_categories']}, total_tools: {type_stats['total_tools']}"
+    )
+
+
+if __name__ == "__main__":
+    main()

{tooluniverse-1.0.2.dist-info → tooluniverse-1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tooluniverse
-Version: 1.0.2
+Version: 1.0.3
 Summary: A comprehensive collection of scientific tools for Agentic AI, offering integration with the ToolUniverse SDK and MCP Server to support advanced scientific workflows.
 Author-email: Shanghua Gao <shanghuagao@gmail.com>
 Project-URL: Homepage, https://github.com/mims-harvard/TxAgent
@@ -63,7 +63,7 @@ Provides-Extra: all
 Requires-Dist: tooluniverse[dev,docs,graph]; extra == "all"
 Dynamic: license-file
 
-# ToolUniverse: Democratizing AI scientists
+# <img src="docs/_static/logo.png" alt="ToolUniverse Logo" height="28" style="vertical-align: middle; margin-right: 8px;" /> ToolUniverse: Democratizing AI scientists
 
 [![ToolUniverse-PIP](https://img.shields.io/badge/PyPI-ToolUniverse-blue)](https://pypi.org/project/tooluniverse/)
 [![ToolUniverse](https://img.shields.io/badge/Code-ToolUniverse-purple)](https://github.com/mims-harvard/ToolUniverse)
@@ -96,7 +96,7 @@ ToolUniverse is an ecosystem for creating AI scientist systems from any open or
 
 
 ## 🤖 Building AI Scientists with ToolUniverse in 5 minutes
-- **[Overview](https://zitniklab.hms.harvard.edu/bioagent/guide/building_ai_scientists/index.html)**: Create AI research assistants from any LLM
+- **[Overview](https://zitniklab.hms.harvard.edu/bioagent/guide/building_ai_scientists/index.html)**: Create AI scientists from any LLM
 - **[Claude Desktop Integration](https://zitniklab.hms.harvard.edu/bioagent/guide/building_ai_scientists/claude_desktop.html)**: Native MCP integration with Claude Desktop App
 - **[Claude Code Integration](https://zitniklab.hms.harvard.edu/bioagent/guide/building_ai_scientists/claude_code.html)**: AI scientist development in Claude Code environment
 - **[Gemini CLI Integration](https://zitniklab.hms.harvard.edu/bioagent/guide/building_ai_scientists/gemini_cli.html)**: Command-line scientific research with Google Gemini
@@ -109,7 +109,7 @@ ToolUniverse is an ecosystem for creating AI scientist systems from any open or
 
 AI scientists are emerging computational systems that serve as collaborative partners in discovery. However, these systems remain difficult to build because they are bespoke, tied to rigid workflows, and lack shared environments that unify tools, data, and analysts into a common ecosystem.
 
-ToolUniverse addresses this challenge by providing a standardized ecosystem that transforms any AI model into a powerful research scientist. By abstracting capabilities behind a unified interface, ToolUniverse wraps around any AI model (LLM, AI agent, or large reasoning model) and enables users to create and refine entirely custom AI research assistants without additional training or finetuning.
+ToolUniverse addresses this challenge by providing a standardized ecosystem that transforms any AI model into a powerful research scientist. By abstracting capabilities behind a unified interface, ToolUniverse wraps around any AI model (LLM, AI agent, or large reasoning model) and enables users to create and refine entirely custom AI scientists without additional training or finetuning.
 
 **Key Features:**
 
@@ -212,7 +212,7 @@ tooluniverse-smcp
 
 
 ---
-**Hypercholesterolemia Drug Discovery** [[Tutorial]]((https://zitniklab.hms.harvard.edu/bioagent/tutorials/tooluniverse_case_study.html)) [[Code]](https://colab.research.google.com/drive/1UwJ6RwyUoqI5risKQ365EeFdDQWOeOCv?usp=sharing)
+**Hypercholesterolemia Drug Discovery** [[Tutorial]](https://zitniklab.hms.harvard.edu/bioagent/tutorials/tooluniverse_case_study.html) [[Code]](https://colab.research.google.com/drive/1UwJ6RwyUoqI5risKQ365EeFdDQWOeOCv?usp=sharing)
 
 ---
 
@@ -316,4 +316,4 @@ ToolUniverse is developed by the [Zitnik Lab](https://zitniklab.hms.harvard.edu/
 
 ---
 
-*Democratizing AI agents for science - one tooluniverse at a time.*
+*Democratizing AI agents for science with ToolUniverse.*

{tooluniverse-1.0.2.dist-info → tooluniverse-1.0.3.dist-info}/RECORD

@@ -16,7 +16,7 @@ tooluniverse/embedding_database.py,sha256=ua-yIyv3dPq2GHdyZmiwZyaUlkKYyV3nslB4H9
 tooluniverse/embedding_sync.py,sha256=Cq3g64MjNXXpiImrzPMNsCTvGZeEI9009OlHOD3EloI,14669
 tooluniverse/enrichr_tool.py,sha256=YXuHwoG_Hi-kUWK7cY_X21b5pbqoREdG7fJxKq050Jg,9472
 tooluniverse/europe_pmc_tool.py,sha256=aYTkDE_KMnpkYYMG5ojYZQ1QYsYB_Msf3pvNwY1Zz6w,1645
-tooluniverse/execute_function.py,sha256=kYmS-Efv1O-RtmeZaYL6TOq1yGtXRHX8KaYuQ8JYpyI,78094
+tooluniverse/execute_function.py,sha256=T5y0OQdsPyz0hvrl9pqIfWjPi2OBJ1fhpuDPzjlKPac,82979
 tooluniverse/extended_hooks.py,sha256=1Cg0rETh6_D21YFVqD-FhL7y4inZAGyQ6vMtHyugueg,15376
 tooluniverse/gene_ontology_tool.py,sha256=l89XYdBEBm3eN3dG0lR4oV01H16_9IUB6a2c7W_c7Lg,7180
 tooluniverse/graphql_tool.py,sha256=y7ztNyb9hn4OdSGKhLsHev_snkNgbAwJZL8ZGHm0LEk,8980
@@ -62,11 +62,11 @@ tooluniverse/compose_scripts/tool_description_optimizer.py,sha256=L6Kd8e6Af8pD6d
 tooluniverse/compose_scripts/tool_discover.py,sha256=RKzCmhDWzDCsAl2KCcEQRNH96mOf_2bTQOH2EVGvpC8,24976
 tooluniverse/compose_scripts/tool_graph_composer.py,sha256=lmGeN94Mc9SZCeYo8ez55tKYLS1-dI3JDm-onKB5DZA,15566
 tooluniverse/compose_scripts/tool_graph_generation.py,sha256=zPVN58GufflVCo8Ak3V9_DpNjS9oLrhQ5A_JCN9TCzY,10052
-tooluniverse/compose_scripts/tool_metadata_generator.py,sha256=GCd_zKxN5n7vz_5Zlj7nP2KpGzfi0baRfOnKt9ZQsRI,19004
+tooluniverse/compose_scripts/tool_metadata_generator.py,sha256=JAcLhXnmsZMzRjNRFM1fsxBtkjgY92LTzMGpgEq4s2k,19235
 tooluniverse/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tooluniverse/data/admetai_tools.json,sha256=08LCNSCZJxL6ZuPF1mVfbdlh9f2X5tnEwIYU7RcLLSM,6497
 tooluniverse/data/adverse_event_tools.json,sha256=EDU_X8r4YtMnVt7SJpyimdo3FlcSNFSdvckWLShDODA,12752
-tooluniverse/data/agentic_tools.json,sha256=2LVwit3QqoHQRja2f_8KvRh9evyIV62fpYqo4WyiIeM,103309
+tooluniverse/data/agentic_tools.json,sha256=ABlMWxS06u-xqGHEDDEizUpprQ4MfDg1NXSKSWTo8x4,103299
 tooluniverse/data/alphafold_tools.json,sha256=--JO9z9fQM95t5dphrBoKKr28HKWg7iQOUm1hQYhEOk,10628
 tooluniverse/data/boltz_tools.json,sha256=_pMSRBkO3uj4vjYnQ7H6qbZFa4rzc9Looj6zHRyIkMg,303
 tooluniverse/data/chembl_tools.json,sha256=aQfFyFlUNz_y9ZTO3dNje4QGhqt7rLv6j5YdMJR2-x8,747
@@ -135,6 +135,7 @@ tooluniverse/remote/pinnacle/pinnacle_tool.py,sha256=Oprd2RyMCZF-NsMjkZMpPOB2apC
 tooluniverse/remote/transcriptformer/transcriptformer_tool.py,sha256=ZU_TT340LBwjTuowTaQV6QcANcsjYimA4CVSJHdU0c0,25229
 tooluniverse/remote/uspto_downloader/uspto_downloader_mcp_server.py,sha256=gsfs-a3RZ7kwauO3uWNJjEOEi2ctHva3iRUtEYqjS6U,2352
 tooluniverse/remote/uspto_downloader/uspto_downloader_tool.py,sha256=hkDmSVh2-KEc56YhmgtwrgIwkYMFXR2fN1jrIL9vVlk,4460
+tooluniverse/scripts/filter_tool_files.py,sha256=IZZIeSmBfHKntno790er1hQHSDcrxfdIHZwZ-Lvq7I4,6415
 tooluniverse/scripts/generate_tool_graph.py,sha256=X_TpGcJ29CFH49Djzsz4gs8VvjDe0CcF6KFWU_hJHDI,12727
 tooluniverse/scripts/visualize_tool_graph.py,sha256=4USGnUVdffJfOxourBKELldGhhk5HV7ZeHHREhyKqOc,25812
 tooluniverse/test/mcp_server_test.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -158,6 +159,7 @@ tooluniverse/test/test_gwas_tool.py,sha256=_VXaf8K_1uO-oKlacJP6VTt4u5cjtX3w92G_e
 tooluniverse/test/test_hpa.py,sha256=53lx0rXx0-aT1LRm9IEeBbV5cXaYlp3Ol5bmeRz10Hc,30006
 tooluniverse/test/test_humanbase_tool.py,sha256=4KQnaehJwGtePEwb5my3yldZnMWQHfvCGEpzm-AWLH0,564
 tooluniverse/test/test_idmap_tools.py,sha256=bP_AKhZG1lX9vQKrrrzuZ1iXIMWIWjAriB66pbFCE5M,1743
+tooluniverse/test/test_list_built_in_tools.py,sha256=fLnCHCwoF1kWd28joMPwrYXi0b1e8EqfuIVq6GzZCvA,1035
 tooluniverse/test/test_mcp_server.py,sha256=n3C3UuU9D-E6m6PbooWUgWwshLzncXDEmn0U9ugapaY,6631
 tooluniverse/test/test_mcp_tool.py,sha256=q6a9MCjFggK6KRy8F9h14tV2BezNVj63v6tDFaST-ys,8290
 tooluniverse/test/test_medlineplus.py,sha256=hQ2QyeHmF8BkCXMn9vW0SNImAcqd5jkZz_FhaZbZS7A,7332
@@ -176,9 +178,9 @@ tooluniverse/test/test_tools_find.py,sha256=vP9EV04iXXmejoY2rDhEM0Yc9uHEO2qEmd8s
 tooluniverse/test/test_uniprot_tools.py,sha256=V0x7aQjjlE-wS5alFWviHNwC3saHiEE5pMMqAcbokaw,2582
 tooluniverse/test/test_uspto_tool.py,sha256=y2VQBMbiHCTAmvXhBosHrc1innstUl9UMWNoPaBv-RY,2311
 tooluniverse/test/test_xml_tool.py,sha256=tx-w_psZ801C2kM6aDbBzR8QV3Vgu1p2zP6zExhjpVs,3602
-tooluniverse-1.0.2.dist-info/licenses/LICENSE,sha256=Unq9Y3buGL9J0vFop03FYZiVweytt1xdgLIh2n9ck2c,1115
-tooluniverse-1.0.2.dist-info/METADATA,sha256=SEmSfNFe6gFqwsmk5IyQbtAF2EVknHL2nm7Y7McWUUM,18270
-tooluniverse-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tooluniverse-1.0.2.dist-info/entry_points.txt,sha256=Z_znqzUc_XR9ZIXViavqNAwBkwM4XYfC9h7LoBbAAog,600
-tooluniverse-1.0.2.dist-info/top_level.txt,sha256=zZ8YeCJ5FAkEwdd_mxsFtSCQMBDgBdxrrmHo3RNBiWs,13
-tooluniverse-1.0.2.dist-info/RECORD,,
+tooluniverse-1.0.3.dist-info/licenses/LICENSE,sha256=Unq9Y3buGL9J0vFop03FYZiVweytt1xdgLIh2n9ck2c,1115
+tooluniverse-1.0.3.dist-info/METADATA,sha256=QijTmbm2I8zn-L7IVLeRuuDUcmpk8l-ZkWUQOhNK200,18362
+tooluniverse-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tooluniverse-1.0.3.dist-info/entry_points.txt,sha256=Z_znqzUc_XR9ZIXViavqNAwBkwM4XYfC9h7LoBbAAog,600
+tooluniverse-1.0.3.dist-info/top_level.txt,sha256=zZ8YeCJ5FAkEwdd_mxsFtSCQMBDgBdxrrmHo3RNBiWs,13
+tooluniverse-1.0.3.dist-info/RECORD,,