tooluniverse 1.0.10__py3-none-any.whl → 1.0.11.1__py3-none-any.whl

tooluniverse/data/agentic_tools.json

@@ -39,63 +39,6 @@
       "return_json": false
     }
   },
-  {
-    "type": "AgenticTool",
-    "name": "CodeQualityAnalyzer",
-    "description": "Analyzes code quality from multiple dimensions including algorithmic correctness, functional implementation capability, performance characteristics, and best practices. Provides detailed feedback and improvement suggestions.",
-    "prompt": "You are an expert software engineer and code quality analyst. Please analyze the following code implementation and provide comprehensive quality assessment.\n\n## CODE TO ANALYZE\nTool Name: {tool_name}\nTool Description: {tool_description}\nTool Parameters: {tool_parameters}\nImplementation Code: {implementation_code}\nTest Cases: {test_cases}\nTest Execution Results: {test_execution_results}\n\n## ANALYSIS REQUIREMENTS\nPlease provide a comprehensive analysis covering the following dimensions:\n\n### 1. ALGORITHMIC CORRECTNESS (0-10)\n- Mathematical accuracy and logical correctness\n- Algorithm efficiency and time/space complexity\n- Edge case handling and boundary conditions\n- Error propagation and numerical stability\n- Correctness of domain-specific calculations\n\n### 2. FUNCTIONAL IMPLEMENTATION CAPABILITY (0-10)\n- Completeness of required functionality\n- Parameter validation and input handling\n- Return value accuracy and format consistency\n- Integration with external libraries/APIs\n- Feature completeness vs. requirements\n\n### 3. PERFORMANCE CHARACTERISTICS (0-10)\n- Time complexity analysis\n- Space complexity analysis\n- Memory usage optimization\n- Computational efficiency\n- Scalability considerations\n\n### 4. CODE QUALITY AND STRUCTURE (0-10)\n- Code readability and maintainability\n- Function and variable naming\n- Code organization and modularity\n- Documentation quality\n- Adherence to coding standards\n\n### 5. ERROR HANDLING AND ROBUSTNESS (0-10)\n- Exception handling coverage\n- Input validation robustness\n- Error message clarity and usefulness\n- Graceful degradation strategies\n- Recovery mechanisms\n\n### 6. TESTING AND VALIDATION (0-10)\n- Test coverage completeness\n- Test case quality and relevance\n- Edge case testing\n- Performance testing\n- Integration testing considerations\n- **IMPORTANT**: When test_execution_results are provided, use them to validate actual code behavior and adjust scoring accordingly\n\n### 7. SECURITY AND SAFETY (0-10)\n- Input sanitization and validation\n- Resource usage limits\n- Access control considerations\n- Data privacy protection\n- Security best practices\n\n### 8. MAINTAINABILITY AND EXTENSIBILITY (0-10)\n- Code modularity and reusability\n- Configuration flexibility\n- Future enhancement readiness\n- Dependency management\n- Technical debt assessment\n\n## TEST EXECUTION ANALYSIS\nWhen test_execution_results are provided:\n- Analyze actual test outcomes vs. expected results\n- Identify discrepancies between code behavior and test expectations\n- Use real execution data to validate code correctness\n- Adjust quality scores based on actual performance\n- Provide specific feedback on test failures and their implications\n\n## OUTPUT FORMAT\nProvide your analysis in the following JSON format:\n\n```json\n{\n  \"overall_score\": <0-10>,\n  \"scores\": {\n    \"algorithmic_correctness\": <0-10>,\n    \"functional_capability\": <0-10>,\n    \"performance\": <0-10>,\n    \"code_quality\": <0-10>,\n    \"error_handling\": <0-10>,\n    \"testing\": <0-10>,\n    \"security\": <0-10>,\n    \"maintainability\": <0-10>\n  },\n  \"feedback\": {\n    \"strengths\": [\"list of code strengths\"],\n    \"weaknesses\": [\"list of specific weaknesses\"],\n    \"critical_issues\": [\"list of critical issues that must be fixed\"],\n    \"improvement_opportunities\": [\"list of areas for improvement\"]\n  },\n  \"algorithm_analysis\": {\n    \"complexity\": \"O(n) analysis\",\n    \"correctness_verification\": \"mathematical verification details\",\n    \"edge_cases\": \"identified edge cases\",\n    \"numerical_stability\": \"numerical computation stability assessment\"\n  },\n  \"functional_verification\": {\n    \"requirements_coverage\": \"percentage of requirements covered\",\n    \"missing_features\": [\"list of missing features\"],\n    \"integration_points\": [\"external dependencies and integration points\"],\n    \"api_consistency\": \"API design consistency assessment\"\n  },\n  \"test_execution_analysis\": {\n    \"test_results_summary\": \"summary of test execution outcomes\",\n    \"pass_rate\": \"percentage of tests passed\",\n    \"failed_tests\": [\"list of failed tests with reasons\"],\n    \"actual_vs_expected\": \"analysis of actual vs expected behavior\"\n  },\n  \"recommendations\": [\n    {\n      \"priority\": \"high|medium|low\",\n      \"category\": \"algorithm|functionality|performance|quality|security\",\n      \"description\": \"specific improvement description\",\n      \"action\": \"concrete action to take\",\n      \"expected_impact\": \"expected improvement impact\"\n    }\n  ]\n}\n```\n\n## ANALYSIS GUIDELINES\n- Be thorough and objective in your assessment\n- Provide specific examples from the code when possible\n- Focus on actionable feedback and concrete improvements\n- Consider both immediate fixes and long-term improvements\n- Evaluate code from both technical and business perspectives\n- Provide evidence-based scoring with clear justification\n- **When test_execution_results are available, prioritize actual behavior over theoretical analysis**",
-    "input_arguments": [
-      "tool_name",
-      "tool_description",
-      "tool_parameters",
-      "implementation_code",
-      "test_cases",
-      "test_execution_results"
-    ],
-    "parameter": {
-      "type": "object",
-      "properties": {
-        "tool_name": {
-          "type": "string",
-          "description": "Name of the tool being analyzed"
-        },
-        "tool_description": {
-          "type": "string",
-          "description": "Description of what the tool is supposed to do"
-        },
-        "tool_parameters": {
-          "type": "string",
-          "description": "JSON string of tool parameters and their types"
-        },
-        "implementation_code": {
-          "type": "string",
-          "description": "The actual implementation code to analyze"
-        },
-        "test_cases": {
-          "type": "string",
-          "description": "JSON string of test cases for the tool"
-        },
-        "test_execution_results": {
-          "type": "string",
-          "description": "JSON string of test execution results including pass/fail status and actual outputs"
-        }
-      },
-      "required": [
-        "tool_name",
-        "tool_description",
-        "tool_parameters",
-        "implementation_code",
-        "test_cases"
-      ]
-    },
-    "configs": {
-      "api_type": "CHATGPT",
-      "model_id": "o4-mini-0416",
-      "temperature": 0.3,
-      "max_new_tokens": 8192,
-      "return_json": true
-    }
-  },
   {
     "type": "AgenticTool",
     "name": "MedicalLiteratureReviewer",
@@ -563,37 +506,6 @@
       "return_json": false
     }
   },
-  {
-    "type": "AgenticTool",
-    "name": "TestCaseGenerator",
-    "description": "Generates diverse and representative ToolUniverse tool call dictionaries for a given tool based on its parameter schema. Each tool call should be a JSON object with 'name' (the tool's name) and 'arguments' (a dict of input arguments), covering different parameter combinations, edge cases, and typical usage. Can generate targeted test cases based on previous optimization feedback.",
-    "prompt": "You are an expert software tester. Generate 3-5 diverse ToolUniverse tool call dictionaries for the given tool configuration. Each tool call must be a JSON object with 'name' (tool name) and 'arguments' (input parameters).\n\nFEEDBACK-DRIVEN GENERATION:\nIf tool_config contains '_optimization_feedback' and '_iteration', generate targeted test cases addressing the specific issues mentioned in the feedback. Focus on edge cases, parameter combinations, or usage patterns that need better coverage.\n\nSTANDARD GENERATION:\nCover typical usage, edge cases, and boundary conditions when possible.\n\nTool configuration: {tool_config}\n\nReturn a JSON object with key 'test_cases' containing an array of test case objects. Example format:\n{\"test_cases\": [{\"name\":\"ToolName\",\"arguments\":{\"param\":\"value\"}},{\"name\":\"ToolName\",\"arguments\":{\"param\":123}}]}",
-    "input_arguments": [
-      "tool_config"
-    ],
-    "parameter": {
-      "type": "object",
-      "properties": {
-        "tool_config": {
-          "type": "object",
-          "description": "The full configuration of the tool to generate test cases for. May include '_optimization_feedback' and '_iteration' fields for feedback-driven test generation."
-        }
-      },
-      "required": [
-        "tool_config"
-      ]
-    },
-    "configs": {
-      "api_type": "CHATGPT",
-      "model_id": "o4-mini-0416",
-      "temperature": 1.0,
-      "max_new_tokens": 4096,
-      "return_json": true,
-      "response_format": {
-        "type": "json_object"
-      }
-    }
-  },
   {
     "type": "AgenticTool",
     "name": "DescriptionAnalyzer",
@@ -628,40 +540,6 @@
       "return_json": true
     }
   },
-  {
-    "type": "AgenticTool",
-    "name": "ArgumentDescriptionOptimizer",
-    "description": "Optimizes the descriptions of tool arguments/parameters based on test case results and actual usage patterns. Provides improved descriptions that are more accurate and user-friendly.",
-    "prompt": "You are an expert technical writer specializing in API documentation. Given a tool's parameter schema and test case results, analyze how each parameter is used and optimize their descriptions to be clear, accurate, and concise.\n\nCRITICAL CONSTRAINTS - PARAMETER DESCRIPTION SCOPE:\n1. If the parameter schema contains '_previous_feedback', use that feedback to address specific issues and improve the parameter descriptions accordingly.\n2. Parameter descriptions should be HIGHLY SPECIFIC to each individual parameter.\n3. NEVER repeat or reference the main tool functionality - assume the user already knows what the tool does.\n4. Focus EXCLUSIVELY on parameter-specific details: data types, formats, constraints, valid values, required formats, examples when helpful.\n5. Each description should answer: 'What should I put in this specific parameter?' not 'What does the tool do?'\n6. Avoid generic phrases like 'for this tool', 'used by the tool', 'enables functionality' unless they provide specific technical context.\n7. Be precise about technical requirements (e.g., 'JSON string', 'integer between 1-100', 'URL format', etc.)\n8. Every word must serve a purpose - eliminate filler words and redundant phrases.\n\nOriginal parameter schema:\n{parameter_schema}\n\nTest results showing parameter usage:\n{test_results}\n\nFor each parameter, suggest an improved description that:\n1. Is brief but informative (1-2 sentences max)\n2. Accurately reflects the parameter's specific purpose, data type, and constraints\n3. Uses clear, simple language with precise technical details\n4. Avoids redundancy with the parameter name\n5. Addresses any issues mentioned in previous feedback\n6. Contains only essential information about what value should be provided\n\nReturn a JSON object with keys: 'optimized_parameters' (object with parameter names as keys and optimized descriptions as values) and 'rationale' (explaining the key changes made).",
-    "input_arguments": [
-      "parameter_schema",
-      "test_results"
-    ],
-    "parameter": {
-      "type": "object",
-      "properties": {
-        "parameter_schema": {
-          "type": "string",
-          "description": "JSON string of the original parameter schema with properties and descriptions."
-        },
-        "test_results": {
-          "type": "string",
-          "description": "A JSON string containing test case input/output pairs showing parameter usage."
-        }
-      },
-      "required": [
-        "parameter_schema",
-        "test_results"
-      ]
-    },
-    "configs": {
-      "api_type": "CHATGPT",
-      "model_id": "o4-mini-0416",
-      "temperature": 1.0,
-      "max_new_tokens": 1536,
-      "return_json": true
-    }
-  },
   {
     "type": "AgenticTool",
     "name": "DescriptionQualityEvaluator",
@@ -702,58 +580,6 @@
       "return_json": true
     }
   },
-  {
-    "type": "AgenticTool",
-    "name": "ToolSpecificationGenerator",
-    "description": "Generates complete ToolUniverse-compliant tool specifications based on a description and analysis of similar existing tools. Creates comprehensive tool configurations including parameters, prompts, and metadata.",
-    "prompt": "You are an expert tool architect specializing in ToolUniverse tool design. Generate a complete, valid ToolUniverse tool specification based on the provided requirements and analysis of similar tools.\n\n🚨 **CRITICAL REQUIREMENT**: For all tool types except AgenticTool, generate CUSTOM tool implementations with complete standalone code. Do NOT reference existing tool classes. Only use AgenticTool for subjective analysis tasks requiring LLM capabilities.\n\n**PACKAGE USAGE REQUIREMENT**: ALWAYS prioritize using existing, well-maintained Python packages over custom implementations. Leverage established libraries like pandas, numpy, scipy, requests, beautifulsoup4, biopython, etc. Only write custom algorithms when absolutely no suitable package exists.\n\nREQUIREMENTS:\nTool Description: {tool_description}\nTarget Category: {tool_category}\nTarget Type: {tool_type}\nSimilar Tools Analysis: {similar_tools}\nExisting Tools Context: {existing_tools_summary}\n\n**TOOL TYPE SELECTION LOGIC:**\n1. **AgenticTool**: Only for subjective tasks (analysis, interpretation, creative writing)\n2. **CustomTool**: For all computational, API, data processing tasks with complete custom implementation\n\n**FOR CustomTool (Complete custom implementation - PREFERRED for most tasks):**\n```json\n{\n  \"type\": \"CustomTool\",\n  \"name\": \"ToolName\",\n  \"description\": \"Custom implementation for [specific functionality]\",\n  \"implementation\": {\n    \"language\": \"python\",\n    \"dependencies\": [\"package1\", \"package2\"],\n    \"installation_commands\": [\"pip install package1\", \"pip install package2\"],\n    \"source_code\": \"import requests\\nimport json\\n\\ndef execute_tool(params):\\n    # Complete implementation here\\n    return result\",\n    \"main_function\": \"execute_tool\",\n    \"error_handling\": \"try-except blocks for robust error management\",\n    \"validation\": \"input parameter validation logic\",\n    \"documentation\": \"Complete usage documentation\"\n  },\n  \"parameter\": {\n    \"type\": \"object\",\n    \"properties\": {\n      \"input_param\": {\n        \"type\": \"string\",\n        \"description\": \"Description of input parameter\",\n        \"required\": true\n      }\n    },\n    \"required\": [\"input_param\"]\n  },\n  \"return_schema\": {\n    \"type\": \"object\",\n    \"properties\": {\n      \"result\": {\"type\": \"string\", \"description\": \"Tool output description\"}\n    }\n  },\n  \"testing\": {\n    \"test_cases\": [\n      {\n        \"input\": {\"input_param\": \"test_value\"},\n        \"expected_output_type\": \"object\",\n        \"description\": \"Test case description\"\n      }\n    ],\n    \"validation_method\": \"automated testing with assertions\"\n  }\n}\n```\n\n**FOR AgenticTool (AI-powered tools - Only for subjective tasks):**\n```json\n{\n  \"type\": \"AgenticTool\",\n  \"name\": \"ToolName\",\n  \"description\": \"AI-powered [subjective task] for [non-computational purpose]\",\n  \"prompt\": \"Prompt template with {parameter_name} placeholders for subjective analysis\",\n  \"input_arguments\": [\"param1\", \"param2\"],\n  \"parameter\": {\n    \"type\": \"object\",\n    \"properties\": {\n      \"param1\": {\"type\": \"string\", \"description\": \"...\", \"required\": true}\n    },\n    \"required\": [\"param1\"]\n  },\n  \"configs\": {\n    \"api_type\": \"CHATGPT\",\n    \"model_id\": \"o4-mini-0416\",\n    \"temperature\": 0.7,\n    \"max_new_tokens\": 1024,\n    \"return_json\": false\n  }\n}\n```\n\n**GENERATION REQUIREMENTS:**\n1. **CUSTOM IMPLEMENTATION APPROACH**: For computational/API/data tasks, generate complete standalone Python code\n2. **NO EXISTING TOOL CLASSES**: Do not inherit from or reference PackageTool, RESTTool, XMLTool, etc.\n3. **REAL PACKAGES**: Use actual, installable Python packages (requests, pandas, numpy, etc.)\n4. **COMPLETE CODE**: Include full implementation with imports, error handling, and validation\n5. **TESTING READY**: Provide test cases and validation methods\n6. **AGENTICTOOL ONLY FOR SUBJECTIVE**: Use AgenticTool only for interpretation, analysis, creative tasks\n\n**QUALITY STANDARDS:**\n- Generate complete, executable Python code for CustomTool\n- Include real package dependencies and installation instructions\n- Provide comprehensive error handling and input validation\n- Ensure computational accuracy through established libraries\n- Only use AgenticTool for tasks requiring subjective judgment or LLM capabilities\n\nReturn ONLY a valid JSON object representing the complete tool configuration using the EXACT format for the chosen tool type. No additional text or explanations.",
-    "input_arguments": [
-      "tool_description",
-      "tool_category",
-      "tool_type",
-      "similar_tools",
-      "existing_tools_summary"
-    ],
-    "parameter": {
-      "type": "object",
-      "properties": {
-        "tool_description": {
-          "type": "string",
-          "description": "Brief description of the desired tool functionality and purpose."
-        },
-        "tool_category": {
-          "type": "string",
-          "description": "Target category for the tool (e.g., 'biomedical', 'data_analysis', 'text_processing')."
-        },
-        "tool_type": {
-          "type": "string",
-          "description": "Specific ToolUniverse tool type (e.g., 'AgenticTool', 'RESTTool', 'PythonTool')."
-        },
-        "similar_tools": {
-          "type": "string",
-          "description": "JSON string containing configurations of similar existing tools for analysis and differentiation."
-        },
-        "existing_tools_summary": {
-          "type": "string",
-          "description": "Summary of existing tools in the ecosystem to avoid duplication and identify gaps."
-        }
-      },
-      "required": [
-        "tool_description",
-        "tool_category",
-        "tool_type",
-        "similar_tools",
-        "existing_tools_summary"
-      ]
-    },
-    "configs": {
-      "api_type": "CHATGPT",
-      "model_id": "o4-mini-0416",
-      "temperature": 1.0,
-      "max_new_tokens": 40960,
-      "return_json": true
-    }
-  },
   {
     "type": "AgenticTool",
     "name": "AdvancedCodeQualityAnalyzer",
@@ -804,128 +630,6 @@
       "return_json": true
     }
   },
-  {
-    "type": "AgenticTool",
-    "name": "ToolImplementationGenerator",
-    "description": "Generates domain-specific, functional code implementations based on tool descriptions and requirements with intelligent algorithm selection",
-    "prompt": "You are an expert software engineer specializing in domain-specific implementations. Generate a complete, functional implementation based on the requirements.\n\n## IMPLEMENTATION REQUEST\nTool Description: {tool_description}\nDomain: {domain}\nComplexity Level: {complexity_level}\nPerformance Requirements: {performance_requirements}\n\nTool Parameters:\n{tool_parameters}\n\n## CRITICAL REQUIREMENT: USE EXISTING PACKAGES\n🚨 **ALWAYS PRIORITIZE EXISTING, WELL-MAINTAINED PACKAGES** over custom implementations. Your goal is to leverage the ecosystem of established, tested, and optimized libraries. **NEVER write custom algorithms unless absolutely no suitable package exists.**\n\n## PACKAGE SELECTION STRATEGY\n1. **FIRST CHOICE**: Use established, widely-adopted packages (e.g., pandas, numpy, scipy, requests, beautifulsoup4)\n2. **SECOND CHOICE**: Use domain-specific packages (e.g., biopython for bioinformatics, matplotlib for plotting)\n3. **THIRD CHOICE**: Use specialized libraries (e.g., opencv-python for computer vision, scikit-learn for ML)\n4. **LAST RESORT**: Only implement custom algorithms when no suitable package exists\n\n## REQUIREMENTS ANALYSIS\n1. Parse the tool description to understand core functionality\n2. **Research existing packages** that can solve this problem\n3. **Evaluate package suitability** (popularity, maintenance, performance)\n4. Design implementation using the best available packages\n5. Generate production-ready code with proper error handling\n\n## CODE GENERATION GUIDELINES\n- **ALWAYS check if an existing package can solve the problem**\n- Use established libraries and algorithms for the domain\n- Include comprehensive input validation\n- Implement proper error handling with meaningful messages\n- Add informative comments explaining the logic\n- Return structured results with validation status\n- Consider edge cases and handle them gracefully\n- Follow domain-specific best practices\n- **Document why you chose specific packages**\n\n## DOMAIN-SPECIFIC PACKAGE RECOMMENDATIONS\n\n### Bioinformatics Tools\n- **Biopython**: Sequence analysis, molecular calculations, file format handling\n- **scipy.stats**: Statistical analysis for biological data\n- **pandas**: Data manipulation and analysis\n- **numpy**: Numerical computations\n- **matplotlib/seaborn**: Data visualization\n\n### Mathematical Tools\n- **numpy**: Numerical methods, linear algebra, optimization\n- **scipy**: Scientific computing, optimization, signal processing\n- **sympy**: Symbolic mathematics\n- **pandas**: Data analysis and statistics\n- **matplotlib**: Mathematical plotting\n\n### Data Science Tools\n- **pandas**: Data manipulation and analysis\n- **numpy**: Numerical computations\n- **scipy**: Statistical methods and optimization\n- **scikit-learn**: Machine learning algorithms\n- **matplotlib/seaborn**: Data visualization\n\n### Web API Tools\n- **requests**: HTTP handling and API calls\n- **urllib3**: HTTP client library\n- **aiohttp**: Asynchronous HTTP client/server\n- **httpx**: Modern HTTP client\n- **beautifulsoup4**: HTML/XML parsing\n\n### Text Processing Tools\n- **nltk**: Natural language processing\n- **spaCy**: Advanced NLP\n- **textblob**: Simple text processing\n- **re**: Regular expressions (built-in)\n- **difflib**: Sequence matching (built-in)\n\n### General Purpose\n- **pathlib**: File path operations (built-in)\n- **json**: JSON handling (built-in)\n- **csv**: CSV file handling (built-in)\n- **datetime**: Date/time operations (built-in)\n- **collections**: Advanced data structures (built-in)\n\n## PACKAGE EVALUATION CRITERIA\nWhen choosing packages, consider:\n1. **Popularity**: GitHub stars, PyPI downloads, community size\n2. **Maintenance**: Recent updates, active development\n3. **Documentation**: Quality and completeness of docs\n4. **Performance**: Speed and memory efficiency\n5. **Compatibility**: Python version support, dependencies\n6. **License**: Open source, commercial-friendly\n\n## IMPLEMENTATION APPROACH\n1. **Research Phase**: Identify 2-3 candidate packages for the problem\n2. **Evaluation Phase**: Compare packages based on criteria above\n3. **Selection Phase**: Choose the best package and document why\n4. **Implementation Phase**: Use the selected package with proper error handling\n5. **Fallback Phase**: If package fails, implement minimal custom solution\n\n## RESPONSE FORMAT\nReturn a comprehensive JSON object:\n\n```json\n{\n    \"implementation\": {\n        \"source_code\": \"<complete Python function implementation>\",\n        \"dependencies\": [\"<required packages>\"],\n        \"imports\": [\"<import statements>\"],\n        \"algorithm_description\": \"<explanation of chosen algorithm/approach>\",\n        \"complexity\": \"<time/space complexity analysis>\",\n        \"test_cases\": [\n            {\n                \"input\": \"<test input>\",\n                \"expected_output\": \"<expected result>\",\n                \"description\": \"<what this test validates>\"\n            }\n        ],\n        \"package_justification\": \"<explanation of why specific packages were chosen>\",\n        \"alternative_packages\": [\"<other packages considered but not chosen>\"]\n    },\n    \"quality_metrics\": {\n        \"estimated_accuracy\": \"<accuracy assessment>\",\n        \"performance_characteristics\": \"<performance description>\",\n        \"robustness_level\": \"<error handling assessment>\"\n    },\n    \"documentation\": {\n        \"usage_examples\": [\"<code examples>\"],\n        \"parameter_explanations\": \"<detailed parameter descriptions>\",\n        \"return_format\": \"<description of return value structure>\"\n    }\n}\n```\n\n## FINAL REMINDER\n**ALWAYS prefer using existing, well-maintained packages over custom implementations.** Only write custom code when absolutely necessary. Your goal is to create robust, maintainable tools that leverage the Python ecosystem's strengths.",
-    "input_arguments": [
-      "tool_description",
-      "tool_parameters",
-      "domain",
-      "complexity_level",
-      "performance_requirements"
-    ],
-    "parameter": {
-      "type": "object",
-      "properties": {
-        "tool_description": {
-          "type": "string",
-          "description": "Detailed description of what the tool should accomplish"
-        },
-        "tool_parameters": {
-          "type": "string",
-          "description": "JSON string of parameter schema for the tool"
-        },
-        "domain": {
-          "type": "string",
-          "description": "Domain area for specialized implementation",
-          "enum": [
-            "bioinformatics",
-            "data-science",
-            "web-api",
-            "mathematical",
-            "text-processing",
-            "general"
-          ],
-          "default": "general"
-        },
-        "complexity_level": {
-          "type": "string",
-          "enum": [
-            "basic",
-            "intermediate",
-            "advanced"
-          ],
-          "description": "Desired complexity level of implementation",
-          "default": "intermediate"
-        },
-        "performance_requirements": {
-          "type": "string",
-          "description": "Performance requirements or constraints"
-        }
-      },
-      "required": [
-        "tool_description",
-        "tool_parameters"
-      ]
-    },
-    "configs": {
-      "api_type": "CHATGPT",
-      "model_id": "o4-mini-0416",
-      "temperature": 0.2,
-      "max_new_tokens": 50000,
-      "return_json": true
-    }
-  },
-  {
-    "type": "AgenticTool",
-    "name": "ToolSpecificationOptimizer",
-    "description": "Optimizes tool specifications for clarity, completeness, and usability with comprehensive benchmarking against similar tools",
-    "prompt": "You are an expert in tool design and user experience optimization. Analyze and optimize the provided tool specification for maximum effectiveness.\n\n## TOOL SPECIFICATION TO OPTIMIZE\nCurrent Configuration:\n{tool_config}\n\nOptimization Focus: {optimization_focus}\nTarget Audience: {target_audience}\n\nSimilar Tools for Benchmarking:\n{similar_tools}\n\n## OPTIMIZATION FRAMEWORK\n\n### 1. CLARITY ASSESSMENT\n- Description comprehensiveness and clarity\n- Parameter naming and documentation\n- Usage examples and guidance\n- Error message quality\n\n### 2. COMPLETENESS EVALUATION\n- Required vs optional parameters\n- Edge case handling\n- Output format specification\n- Documentation coverage\n\n### 3. USABILITY ANALYSIS\n- Ease of understanding for target audience\n- Parameter complexity and defaults\n- Error prevention design\n- Workflow integration\n\n### 4. PERFORMANCE OPTIMIZATION\n- Parameter validation efficiency\n- Resource usage considerations\n- Scalability factors\n- Response time optimization\n\n### 5. COMPARATIVE BENCHMARKING\n- Analyze similar tools for best practices\n- Identify competitive advantages\n- Address common user pain points\n- Incorporate proven design patterns\n\n## OPTIMIZATION PROCESS\n1. Evaluate current specification quality\n2. Identify improvement opportunities\n3. Benchmark against similar tools\n4. Generate optimized version\n5. Provide detailed rationale for changes\n\n## RESPONSE FORMAT\nReturn a comprehensive optimization report:\n\n```json\n{\n    \"optimized_config\": {\n        \"name\": \"<optimized name>\",\n        \"description\": \"<improved description>\",\n        \"parameter\": {\n            \"type\": \"object\",\n            \"properties\": \"<optimized parameters>\",\n            \"required\": \"<updated required fields>\"\n        },\n        \"examples\": [\"<usage examples>\"],\n        \"metadata\": {\n            \"tags\": [\"<relevant tags>\"],\n            \"difficulty_level\": \"<user difficulty>\",\n            \"estimated_execution_time\": \"<typical runtime>\"\n        }\n    },\n    \"improvements\": [\n        {\n            \"area\": \"<improvement area>\",\n            \"change\": \"<what was changed>\",\n            \"rationale\": \"<why this improves the tool>\",\n            \"impact\": \"<expected user impact>\"\n        }\n    ],\n    \"quality_score\": {\n        \"before\": \"<0-10>\",\n        \"after\": \"<0-10>\",\n        \"improvement\": \"<difference>\"\n    },\n    \"recommendations\": [\n        {\n            \"type\": \"enhancement|fix|optimization\",\n            \"description\": \"<recommendation>\",\n            \"priority\": \"high|medium|low\"\n        }\n    ]\n}\n```",
-    "input_arguments": [
-      "tool_config",
-      "optimization_focus",
-      "target_audience",
-      "similar_tools"
-    ],
-    "parameter": {
-      "type": "object",
-      "properties": {
-        "tool_config": {
-          "type": "string",
-          "description": "JSON string of current tool configuration to optimize"
-        },
-        "optimization_focus": {
-          "type": "string",
-          "enum": [
-            "clarity",
-            "completeness",
-            "usability",
-            "performance",
-            "all"
-          ],
-          "description": "Primary optimization focus",
-          "default": "all"
-        },
-        "target_audience": {
-          "type": "string",
-          "enum": [
-            "beginner",
-            "intermediate",
-            "expert",
-            "mixed"
-          ],
-          "description": "Target user expertise level",
-          "default": "mixed"
-        },
-        "similar_tools": {
-          "type": "string",
-          "description": "JSON string array of similar tools for comparison and benchmarking"
-        }
-      },
-      "required": [
-        "tool_config"
-      ]
-    },
-    "configs": {
-      "api_type": "CHATGPT",
-      "model_id": "o4-mini-0416",
-      "temperature": 0.3,
-      "max_new_tokens": 3500,
-      "return_json": true
-    }
-  },
   {
     "type": "AgenticTool",
     "name": "DomainExpertValidator",
@@ -1022,80 +726,6 @@
       "return_json": true
     }
   },
-  {
-    "type": "AgenticTool",
-    "name": "ToolOptimizer",
-    "description": "Optimizes tool configurations based on quality feedback. Improves tool specifications and implementations to address identified issues.",
-    "prompt": "You are an expert tool optimizer. Improve this tool based on the quality feedback:\n\nOriginal Tool Configuration: {tool_config}\nQuality Feedback: {quality_feedback}\nOptimization Target: {optimization_target}\n\nGenerate an optimized version in this JSON format:\n{\n  \"optimized_tool\": {\n    \"name\": \"improved_tool_name\",\n    \"type\": \"tool_type\",\n    \"description\": \"enhanced_description\",\n    \"parameter\": {\n      \"type\": \"object\",\n      \"properties\": {},\n      \"required\": []\n    },\n    \"category\": \"category\",\n    \"implementation\": {\n      \"source_code\": \"improved_code\",\n      \"dependencies\": [],\n      \"main_function\": \"execute_tool\"\n    }\n  },\n  \"improvements_made\": [\n    \"Added input validation\",\n    \"Enhanced error handling\",\n    \"Improved parameter descriptions\"\n  ],\n  \"optimization_notes\": \"Summary of key improvements\"\n}\n\nFocus on:\n1. Fixing identified weaknesses\n2. Enhancing parameter validation\n3. Improving error handling\n4. Adding missing functionality\n5. Optimizing for the specified target\n6. Maintaining backward compatibility where possible",
-    "input_arguments": [
-      "tool_config",
-      "quality_feedback",
-      "optimization_target"
-    ],
-    "parameter": {
-      "type": "object",
-      "properties": {
-        "tool_config": {
-          "type": "string",
-          "description": "JSON string of the original tool configuration"
-        },
-        "quality_feedback": {
-          "type": "string",
-          "description": "JSON string of quality evaluation feedback"
-        },
-        "optimization_target": {
-          "type": "string",
-          "description": "What to optimize for (improve_quality, enhance_performance, etc.)"
-        }
-      },
-      "required": [
-        "tool_config",
-        "quality_feedback",
-        "optimization_target"
-      ]
-    },
-    "configs": {
-      "api_type": "CHATGPT",
-      "model_id": "o4-mini-0416",
-      "temperature": 0.3,
-      "max_new_tokens": 3072,
-      "return_json": true
-    }
-  },
-  {
-    "type": "AgenticTool",
-    "name": "CodeOptimizer",
-    "description": "Optimizes code implementation for tools based on quality evaluation. Takes tool configuration and quality evaluation results to produce improved source code.",
-    "prompt": "You are an expert software engineer specializing in code optimization. Your task is to optimize the implementation code of a tool based on the provided configuration and quality evaluation.\n\n## TOOL CONFIGURATION\n{tool_config}\n\n## QUALITY EVALUATION\n{quality_evaluation}\n\n## OPTIMIZATION INSTRUCTIONS\nAnalyze the current implementation and quality evaluation feedback, then provide an optimized version that addresses the identified issues. Focus on:\n1. **Code Quality**: Improve readability, structure, and maintainability\n2. **Error Handling**: Enhance exception handling, input validation, and robustness\n3. **Performance**: Optimize algorithms, reduce complexity, improve efficiency\n4. **Best Practices**: Follow Python standards, proper documentation, and clean code principles\n\nReturn a JSON object with the following structure:\n```json\n{\n  \"implementation\": {\n    \"source_code\": \"<optimized_python_code>\",\n    \"dependencies\": [\"<required_packages>\"],\n    \"imports\": [\"<import_statements>\"],\n    \"improvements_made\": [\"list of specific improvements based on quality evaluation feedback\"],\n    \"addressed_issues\": [\"list of issues that were fixed\"],\n    \"quality_improvements\": \"summary of overall quality improvements\"\n  }\n}\n```\n\nEnsure the optimized code:\n- Maintains the same functionality as the original\n- Addresses the specific issues mentioned in quality evaluation feedback\n- Includes proper error handling and input validation\n- Follows Python best practices and PEP 8 standards\n- Is well-documented with clear docstrings and comments",
-    "input_arguments": [
-      "tool_config",
-      "quality_evaluation"
-    ],
-    "parameter": {
-      "type": "object",
-      "properties": {
-        "tool_config": {
-          "type": "string",
-          "description": "JSON string containing the complete tool configuration including current implementation"
-        },
-        "quality_evaluation": {
-          "type": "string",
-          "description": "JSON string containing quality evaluation results and feedback"
-        }
-      },
-      "required": [
-        "tool_config",
-        "quality_evaluation"
-      ]
-    },
-    "configs": {
-      "api_type": "CHATGPT",
-      "model_id": "o4-mini-0416",
-      "temperature": 0.2,
-      "max_new_tokens": 4096,
-      "return_json": true
-    }
-  },
   {
     "type": "AgenticTool",
     "name": "LabelGenerator",

tooluniverse/data/alphafold_tools.json

@@ -1,14 +1,14 @@
 [
   {
     "name": "alphafold_get_prediction",
-    "description": "Retrieve full AlphaFold 3D structure predictions for a given protein. Input must be a UniProt accession (e.g., 'P69905'), UniProt entry name (e.g., 'HBA_HUMAN'), or CRC64 checksum. Returns residue-level metadata including sequence, per-residue confidence scores (pLDDT), and structure download links (PDB, CIF, PAE). If you do not know the accession, first call `uniprot_search` to resolve it from a protein/gene name, or `UniProt_get_entry_by_accession` if you already have the accession and want UniProt details. For a quick overview, use `alphafold_get_summary`. For mutation/variant impact, see `alphafold_get_annotations.",
+    "description": "Retrieve full AlphaFold 3D structure predictions for a given protein. IMPORTANT: The qualifier must be a UniProt ACCESSION (e.g., 'P69905' for HBA_HUMAN). Do NOT use UniProt entry names like 'HBA_HUMAN' - they will cause API errors. To find UniProt accession from a gene/protein name, use `UniProt_search` (e.g., query='gene:HBA' organism='human') or `UniProt_id_mapping` for ID conversion. Returns residue-level metadata including sequence, per-residue confidence scores (pLDDT), and structure download links (PDB, CIF, PAE). If you already have the accession and want UniProt details, call `UniProt_get_entry_by_accession`. For a quick overview, use `alphafold_get_summary`. For mutation/variant impact, see `alphafold_get_annotations`.",
     "type": "AlphaFoldRESTTool",
     "parameter": {
       "type": "object",
       "properties": {
         "qualifier": {
           "type": "string",
-          "description": "Protein identifier: UniProt accession (e.g., 'P69905'), entry name (e.g., 'HBA_HUMAN'), or CRC64 checksum."
+          "description": "Protein identifier: UniProt ACCESSION (e.g., 'P69905'). Do NOT use entry names like 'HBA_HUMAN'. To find accession from gene name: use `UniProt_search` or `UniProt_id_mapping`."
         },
         "sequence_checksum": {
           "type": "string",
@@ -230,14 +230,14 @@
   },
   {
     "name": "alphafold_get_summary",
-    "description": "Retrieve summary details of AlphaFold 3D models for a given protein. Input must be a UniProt accession, entry name, or CRC64 checksum. Returns lightweight information such as sequence length, coverage, confidence scores, experimental method, resolution, oligomeric state, and structural entities. If you only know the protein/gene name, first use `uniprot_search` to find the accession. For full residue-level 3D predictions with downloadable coordinates, call `alphafold_get_prediction`. For curated variants, see `UniProt_get_disease_variants_by_accession`; for predicted mutation effects, use `alphafold_get_annotations`.",
+    "description": "Retrieve summary details of AlphaFold 3D models for a given protein. IMPORTANT: The qualifier must be a UniProt ACCESSION (e.g., 'Q5SWX9' for MEIOB_HUMAN). Do NOT use UniProt entry names like 'MEIOB_HUMAN' - they will cause API errors. To find UniProt accession from a gene/protein name, use `UniProt_search` (e.g., query='gene:MEIOB' organism='human') or `UniProt_id_mapping` for ID conversion. Returns lightweight information such as sequence length, coverage, confidence scores, experimental method, resolution, oligomeric state, and structural entities. For full residue-level 3D predictions with downloadable coordinates, call `alphafold_get_prediction`. For curated variants, see `UniProt_get_disease_variants_by_accession`; for predicted mutation effects, use `alphafold_get_annotations`.",
     "type": "AlphaFoldRESTTool",
     "parameter": {
       "type": "object",
       "properties": {
         "qualifier": {
           "type": "string",
-          "description": "Protein identifier: UniProt accession, entry name, or CRC64 checksum."
+          "description": "Protein identifier: UniProt ACCESSION (e.g., 'Q5SWX9'). Do NOT use entry names like 'MEIOB_HUMAN'. To find accession from gene name: use `UniProt_search` or `UniProt_id_mapping`."
         }
       },
       "required": [
@@ -387,14 +387,14 @@
   },
   {
     "name": "alphafold_get_annotations",
-    "description": "Retrieve AlphaFold variant annotations (e.g., missense mutations) for a given UniProt accession (e.g., 'P69905'). Input must be a UniProt accession, entry name, or CRC64 checksum, along with an annotation type (currently only 'MUTAGEN'). Use this tool to explore predicted pathogenicity or functional effects of substitutions. If you only have a protein/gene name, resolve it with `uniprot_search`. For experimentally curated variants, use `UniProt_get_disease_variants_by_accession`. To view the full 3D structure, call `alphafold_get_prediction`; for overall model metadata, use `alphafold_get_summary`.",
+    "description": "Retrieve AlphaFold variant annotations (e.g., missense mutations) for a given UniProt accession. IMPORTANT: The qualifier must be a UniProt ACCESSION (e.g., 'P69905'), along with an annotation type (currently only 'MUTAGEN'). Do NOT use UniProt entry names as they will cause API errors. To find UniProt accession from a gene/protein name, use `UniProt_search` (e.g., query='gene:TP53' organism='human') or `UniProt_id_mapping` for ID conversion. Use this tool to explore predicted pathogenicity or functional effects of substitutions. For experimentally curated variants, use `UniProt_get_disease_variants_by_accession`. To view the full 3D structure, call `alphafold_get_prediction`; for overall model metadata, use `alphafold_get_summary`.",
     "type": "AlphaFoldRESTTool",
     "parameter": {
       "type": "object",
       "properties": {
         "qualifier": {
           "type": "string",
-          "description": "Protein identifier: UniProt accession, entry name, or CRC64 checksum."
+          "description": "Protein identifier: UniProt ACCESSION (e.g., 'P69905'). Do NOT use entry names. To find accession from gene name: use `UniProt_search` or `UniProt_id_mapping`."
         },
         "type": {
           "type": "string",

tooluniverse/data/blast_tools.json

@@ -0,0 +1,112 @@
+[
+  {
+    "type": "NCBIBlastTool",
+    "name": "BLAST_nucleotide_search",
+    "description": "Search nucleotide sequences using NCBI BLAST blastn against nucleotide databases",
+    "parameter": {
+      "type": "object",
+      "properties": {
+        "sequence": {"type": "string", "description": "DNA sequence to search"},
+        "database": {"type": "string", "default": "nt", "description": "Database (nt, est, etc.)"},
+        "expect": {"type": "number", "default": 10.0, "description": "E-value threshold"},
+        "hitlist_size": {"type": "integer", "default": 50, "description": "Max hits to return"}
+      },
+      "required": ["sequence"]
+    },
+    "return_schema": {
+      "type": "object",
+      "properties": {
+        "query_id": {"type": "string"},
+        "query_length": {"type": "integer"},
+        "database": {"type": "string"},
+        "alignments": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "hit_id": {"type": "string"},
+              "hit_def": {"type": "string"},
+              "hit_length": {"type": "integer"},
+              "hsps": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "score": {"type": "number"},
+                    "bits": {"type": "number"},
+                    "expect": {"type": "number"},
+                    "identities": {"type": "integer"},
+                    "positives": {"type": "integer"},
+                    "gaps": {"type": "integer"},
+                    "query": {"type": "string"},
+                    "match": {"type": "string"},
+                    "sbjct": {"type": "string"}
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "test_examples": [
+      {"sequence": "ATGCGATCGATCGATCGATCG", "database": "nt"},
+      {"sequence": "AAAAATTTTTCCCCCGGGGG", "database": "est"}
+    ]
+  },
+  {
+    "type": "NCBIBlastTool",
+    "name": "BLAST_protein_search",
+    "description": "Search protein sequences using NCBI BLAST blastp against protein databases",
+    "parameter": {
+      "type": "object",
+      "properties": {
+        "sequence": {"type": "string", "description": "Protein sequence to search"},
+        "database": {"type": "string", "default": "nr", "description": "Database (nr, swissprot, etc.)"},
+        "expect": {"type": "number", "default": 10.0},
+        "hitlist_size": {"type": "integer", "default": 50}
+      },
+      "required": ["sequence"]
+    },
+    "return_schema": {
+      "type": "object",
+      "properties": {
+        "query_id": {"type": "string"},
+        "query_length": {"type": "integer"},
+        "database": {"type": "string"},
+        "alignments": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "hit_id": {"type": "string"},
+              "hit_def": {"type": "string"},
+              "hit_length": {"type": "integer"},
+              "hsps": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "score": {"type": "number"},
+                    "bits": {"type": "number"},
+                    "expect": {"type": "number"},
+                    "identities": {"type": "integer"},
+                    "positives": {"type": "integer"},
+                    "gaps": {"type": "integer"},
+                    "query": {"type": "string"},
+                    "match": {"type": "string"},
+                    "sbjct": {"type": "string"}
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "test_examples": [
+      {"sequence": "MKLLILTCLVAVALARPKHPIKHQGLPQEVLNENLLRFFVAPFPEVFGKEKVNEL"},
+      {"sequence": "MKWVTFISLLFLFSSAYS"}
+    ]
+  }
+]