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

tooluniverse/compose_scripts/output_summarizer.py

@@ -81,31 +81,37 @@ def compose(arguments: Dict[str, Any], tooluniverse, call_tool) -> Dict[str, Any
             else:
                 print(f"❌ Chunk {i+1} summarization failed")
 
-        # Step 3: Merge summaries
+        # Step 3: Merge summaries (or gracefully fall back)
         if chunk_summaries:
             final_summary = _merge_summaries(
                 chunk_summaries, query_context, tool_name, max_summary_length, call_tool
             )
+            print(
+                f"✅ Summarization completed. Final length: {len(final_summary)} characters"
+            )
+            return {
+                "success": True,
+                "original_length": len(tool_output),
+                "summary_length": len(final_summary),
+                "chunks_processed": len(chunks),
+                "summary": final_summary,
+                "tool_name": tool_name,
+            }
         else:
-            final_summary = "Unable to generate summary due to processing errors."
+            # Treat as a non-fatal failure so upstream falls back to original output
             print("❌ No chunk summaries were generated. This usually indicates:")
             print("   1. ToolOutputSummarizer tool is not available")
             print("   2. The output_summarization tools are not loaded")
             print("   3. There was an error in the summarization process")
             print("   Please check that the SMCP server is started with hooks enabled.")
-
-        print(
-            f"✅ Summarization completed. Final length: {len(final_summary)} characters"
-        )
-
-        return {
-            "success": True,
-            "original_length": len(tool_output),
-            "summary_length": len(final_summary),
-            "chunks_processed": len(chunks),
-            "summary": final_summary,
-            "tool_name": tool_name,
-        }
+            return {
+                "success": False,
+                "error": "No chunk summaries generated",
+                "original_length": len(tool_output),
+                "chunks_processed": len(chunks),
+                "original_output": tool_output,
+                "tool_name": tool_name,
+            }
 
     except Exception as e:
         error_msg = f"Error in output summarization: {str(e)}"

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/data/output_summarization_tools.json

@@ -73,7 +73,7 @@
           "type": "integer",
           "description": "Size of each chunk for processing",
           "required": false,
-          "default": 2000
+          "default": 30000
         },
         "focus_areas": {
           "type": "string",
@@ -85,7 +85,7 @@
           "type": "integer",
           "description": "Maximum length of final summary",
           "required": false,
-          "default": 3000
+          "default": 10000
         }
       },
       "required": ["tool_output", "query_context", "tool_name"]

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,