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

tooluniverse/tools/ToolDescriptionOptimizer.py

@@ -0,0 +1,67 @@
+"""
+ToolDescriptionOptimizer
+
+Optimizes a tool's description and parameter descriptions by generating test cases, executing the...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ToolDescriptionOptimizer(
+    tool_config: dict[str, Any],
+    save_to_file: bool,
+    output_file: str,
+    max_iterations: int,
+    satisfaction_threshold: float,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Optimizes a tool's description and parameter descriptions by generating test cases, executing the...
+
+    Parameters
+    ----------
+    tool_config : dict[str, Any]
+        The full configuration of the tool to optimize.
+    save_to_file : bool
+        If true, save the optimized description to a file (do not overwrite the origi...
+    output_file : str
+        Optional file path to save the optimized description. If not provided, use '<...
+    max_iterations : int
+        Maximum number of optimization rounds to perform.
+    satisfaction_threshold : float
+        Quality score threshold (1-10) to consider optimization satisfactory.
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ToolDescriptionOptimizer",
+            "arguments": {
+                "tool_config": tool_config,
+                "save_to_file": save_to_file,
+                "output_file": output_file,
+                "max_iterations": max_iterations,
+                "satisfaction_threshold": satisfaction_threshold,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ToolDescriptionOptimizer"]

tooluniverse/tools/ToolDiscover.py

@@ -0,0 +1,63 @@
+"""
+ToolDiscover
+
+Generates new ToolUniverse-compliant tools based on short descriptions through an intelligent dis...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ToolDiscover(
+    tool_description: str,
+    max_iterations: int,
+    save_to_file: bool,
+    output_file: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Generates new ToolUniverse-compliant tools based on short descriptions through an intelligent dis...
+
+    Parameters
+    ----------
+    tool_description : str
+        Short description of the desired tool functionality and purpose. Tool Discove...
+    max_iterations : int
+        Maximum number of refinement iterations to perform.
+    save_to_file : bool
+        Whether to save the generated tool configuration and report to a file.
+    output_file : str
+        Optional file path to save the generated tool. If not provided, uses auto-gen...
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ToolDiscover",
+            "arguments": {
+                "tool_description": tool_description,
+                "max_iterations": max_iterations,
+                "save_to_file": save_to_file,
+                "output_file": output_file,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ToolDiscover"]

tooluniverse/tools/ToolGraphComposer.py

@@ -0,0 +1,71 @@
+"""
+ToolGraphComposer
+
+Builds a comprehensive graph of tool compatibility relationships in ToolUniverse. Analyzes all av...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ToolGraphComposer(
+    output_path: str,
+    analysis_depth: str,
+    min_compatibility_score: int,
+    exclude_categories: list[Any],
+    max_tools_per_category: int,
+    force_rebuild: bool,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Builds a comprehensive graph of tool compatibility relationships in ToolUniverse. Analyzes all av...
+
+    Parameters
+    ----------
+    output_path : str
+        Path to save the generated graph files (JSON and pickle formats)
+    analysis_depth : str
+        Level of compatibility analysis to perform
+    min_compatibility_score : int
+        Minimum compatibility score to create an edge in the graph
+    exclude_categories : list[Any]
+        Tool categories to exclude from analysis (e.g., ['tool_finder', 'special_tool...
+    max_tools_per_category : int
+        Maximum number of tools to analyze per category (for performance)
+    force_rebuild : bool
+        Whether to force rebuild even if cached graph exists
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ToolGraphComposer",
+            "arguments": {
+                "output_path": output_path,
+                "analysis_depth": analysis_depth,
+                "min_compatibility_score": min_compatibility_score,
+                "exclude_categories": exclude_categories,
+                "max_tools_per_category": max_tools_per_category,
+                "force_rebuild": force_rebuild,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ToolGraphComposer"]

tooluniverse/tools/ToolGraphGenerationPipeline.py

@@ -0,0 +1,63 @@
+"""
+ToolGraphGenerationPipeline
+
+Generates a directed tool relationship graph among provided tool configs using ToolRelationshipDe...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ToolGraphGenerationPipeline(
+    tool_configs: list[Any],
+    max_tools: int,
+    output_path: str,
+    save_intermediate_every: int,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Generates a directed tool relationship graph among provided tool configs using ToolRelationshipDe...
+
+    Parameters
+    ----------
+    tool_configs : list[Any]
+        List of tool configuration objects
+    max_tools : int
+        Optional max number of tools to process (debug)
+    output_path : str
+        Path for output graph JSON
+    save_intermediate_every : int
+        Checkpoint every N processed pairs
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ToolGraphGenerationPipeline",
+            "arguments": {
+                "tool_configs": tool_configs,
+                "max_tools": max_tools,
+                "output_path": output_path,
+                "save_intermediate_every": save_intermediate_every,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ToolGraphGenerationPipeline"]

tooluniverse/tools/ToolImplementationGenerator.py

@@ -0,0 +1,67 @@
+"""
+ToolImplementationGenerator
+
+Generates domain-specific, functional code implementations based on tool descriptions and require...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ToolImplementationGenerator(
+    tool_description: str,
+    tool_parameters: str,
+    domain: Optional[str] = "general",
+    complexity_level: Optional[str] = "intermediate",
+    performance_requirements: Optional[str] = None,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Generates domain-specific, functional code implementations based on tool descriptions and require...
+
+    Parameters
+    ----------
+    tool_description : str
+        Detailed description of what the tool should accomplish
+    tool_parameters : str
+        JSON string of parameter schema for the tool
+    domain : str
+        Domain area for specialized implementation
+    complexity_level : str
+        Desired complexity level of implementation
+    performance_requirements : str
+        Performance requirements or constraints
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ToolImplementationGenerator",
+            "arguments": {
+                "tool_description": tool_description,
+                "tool_parameters": tool_parameters,
+                "domain": domain,
+                "complexity_level": complexity_level,
+                "performance_requirements": performance_requirements,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ToolImplementationGenerator"]

tooluniverse/tools/ToolMetadataGenerationPipeline.py

@@ -0,0 +1,63 @@
+"""
+ToolMetadataGenerationPipeline
+
+Generates standardized metadata for a batch of ToolUniverse tool configurations by calling ToolMe...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ToolMetadataGenerationPipeline(
+    tool_configs: list[Any],
+    tool_type_mappings: dict[str, Any],
+    add_existing_tooluniverse_labels: bool,
+    max_new_tooluniverse_labels: int,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Generates standardized metadata for a batch of ToolUniverse tool configurations by calling ToolMe...
+
+    Parameters
+    ----------
+    tool_configs : list[Any]
+        List of raw tool configuration JSON objects to extract and standardize metada...
+    tool_type_mappings : dict[str, Any]
+        Mapping of simplified toolType (keys) to lists of tool 'type' values belongin...
+    add_existing_tooluniverse_labels : bool
+        Whether to include labels from existing ToolUniverse tools when labeling the ...
+    max_new_tooluniverse_labels : int
+        The maximum number of new ToolUniverse labels to use in the metadata configs ...
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ToolMetadataGenerationPipeline",
+            "arguments": {
+                "tool_configs": tool_configs,
+                "tool_type_mappings": tool_type_mappings,
+                "add_existing_tooluniverse_labels": add_existing_tooluniverse_labels,
+                "max_new_tooluniverse_labels": max_new_tooluniverse_labels,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ToolMetadataGenerationPipeline"]

tooluniverse/tools/ToolMetadataGenerator.py

@@ -0,0 +1,55 @@
+"""
+ToolMetadataGenerator
+
+Generates a JSON structure with the metadata of a tool in ToolUniverse, given the JSON configurat...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ToolMetadataGenerator(
+    tool_config: str,
+    tool_type_mappings: Optional[dict[str, Any]] = None,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Generates a JSON structure with the metadata of a tool in ToolUniverse, given the JSON configurat...
+
+    Parameters
+    ----------
+    tool_config : str
+        JSON string of the tool configuration to extract metadata from
+    tool_type_mappings : dict[str, Any]
+        A mapping from a simplified toolType to a list of tool_config.type that fall ...
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ToolMetadataGenerator",
+            "arguments": {
+                "tool_config": tool_config,
+                "tool_type_mappings": tool_type_mappings,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ToolMetadataGenerator"]

tooluniverse/tools/ToolMetadataStandardizer.py

@@ -0,0 +1,52 @@
+"""
+ToolMetadataStandardizer
+
+Standardizes and groups semantically equivalent metadata strings (e.g., sources, tags) into canon...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ToolMetadataStandardizer(
+    metadata_list: list[Any],
+    limit: Optional[int] = None,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Standardizes and groups semantically equivalent metadata strings (e.g., sources, tags) into canon...
+
+    Parameters
+    ----------
+    metadata_list : list[Any]
+        List of raw metadata strings (e.g., sources, tags) to standardize and group.
+    limit : int
+        If provided, the maximum number of canonical strings to return. The LLM will ...
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ToolMetadataStandardizer",
+            "arguments": {"metadata_list": metadata_list, "limit": limit},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ToolMetadataStandardizer"]

tooluniverse/tools/ToolOptimizer.py

@@ -0,0 +1,59 @@
+"""
+ToolOptimizer
+
+Optimizes tool configurations based on quality feedback. Improves tool specifications and impleme...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ToolOptimizer(
+    tool_config: str,
+    quality_feedback: str,
+    optimization_target: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Optimizes tool configurations based on quality feedback. Improves tool specifications and impleme...
+
+    Parameters
+    ----------
+    tool_config : str
+        JSON string of the original tool configuration
+    quality_feedback : str
+        JSON string of quality evaluation feedback
+    optimization_target : str
+        What to optimize for (improve_quality, enhance_performance, etc.)
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ToolOptimizer",
+            "arguments": {
+                "tool_config": tool_config,
+                "quality_feedback": quality_feedback,
+                "optimization_target": optimization_target,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ToolOptimizer"]

tooluniverse/tools/ToolOutputSummarizer.py

@@ -0,0 +1,67 @@
+"""
+ToolOutputSummarizer
+
+AI-powered tool for summarizing long tool outputs, focusing on key information relevant to the or...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ToolOutputSummarizer(
+    tool_output: str,
+    query_context: str,
+    tool_name: str,
+    focus_areas: Optional[str] = "key_findings_and_results",
+    max_length: Optional[int] = 32000,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    AI-powered tool for summarizing long tool outputs, focusing on key information relevant to the or...
+
+    Parameters
+    ----------
+    tool_output : str
+        The original tool output to be summarized
+    query_context : str
+        Context about the original query that triggered the tool
+    tool_name : str
+        Name of the tool that generated the output
+    focus_areas : str
+        Specific areas to focus on in the summary
+    max_length : int
+        Maximum length of the summary in characters
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ToolOutputSummarizer",
+            "arguments": {
+                "tool_output": tool_output,
+                "query_context": query_context,
+                "tool_name": tool_name,
+                "focus_areas": focus_areas,
+                "max_length": max_length,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ToolOutputSummarizer"]

tooluniverse/tools/ToolQualityEvaluator.py

@@ -0,0 +1,59 @@
+"""
+ToolQualityEvaluator
+
+Evaluates the quality of tool configurations and implementations. Provides detailed scoring and f...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ToolQualityEvaluator(
+    tool_config: str,
+    test_cases: str,
+    evaluation_aspects: list[Any],
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Evaluates the quality of tool configurations and implementations. Provides detailed scoring and f...
+
+    Parameters
+    ----------
+    tool_config : str
+        JSON string of the tool configuration
+    test_cases : str
+        JSON string of test cases
+    evaluation_aspects : list[Any]
+        Aspects to evaluate (functionality, usability, completeness, best_practices)
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ToolQualityEvaluator",
+            "arguments": {
+                "tool_config": tool_config,
+                "test_cases": test_cases,
+                "evaluation_aspects": evaluation_aspects,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ToolQualityEvaluator"]