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

tooluniverse/test/test_agentic_tool.py

@@ -1,129 +0,0 @@
-from tooluniverse import ToolUniverse
-from typing import Any, Dict, List
-
-# Step 1: Initialize tool universe and load available tools
-tooluni = ToolUniverse()
-tooluni.load_tools()
-
-# Sample biomedical text for testing
-sample_abstract = """
-Background: Drug-drug interactions (DDIs) are a major cause of adverse drug reactions and
-represent a significant public health concern. This study aimed to develop and validate a
-machine learning approach for predicting potential DDIs using molecular descriptors and
-pharmacokinetic properties.
-
-Methods: We collected data on 15,000 drug pairs from DrugBank and FDA databases. Molecular
-descriptors were computed using RDKit, and pharmacokinetic parameters were extracted from
-literature. A gradient boosting classifier was trained to predict DDI severity levels.
-
-Results: The model achieved an accuracy of 89.2% with a precision of 0.91 and recall of 0.87
-for high-severity DDI prediction. Feature importance analysis revealed that CYP450 enzyme
-inhibition patterns and protein binding affinity were the most predictive features.
-
-Conclusions: Our machine learning approach demonstrates high accuracy in predicting DDIs and
-could serve as a valuable tool for clinical decision support and drug safety assessment.
-"""
-
-# Define test queries based on the agentic_tools.json configuration
-test_queries: List[Dict[str, Any]] = [
-    # {
-    #     "name": "BiomedicalTextSummarizer",
-    #     "arguments": {
-    #         "text": sample_abstract,
-    #         "summary_length": "100 words",
-    #         "focus_area": "methodology and results"
-    #     }
-    # },
-    # {
-    #     "name": "BiomedicalTextSummarizer",
-    #     "arguments": {
-    #         "text": "Metformin is a first-line treatment for type 2 diabetes that works by reducing glucose production in the liver.",
-    #         "summary_length": "25 words",
-    #         "focus_area": "mechanism of action"
-    #     }
-    # },
-    # {
-    #     "name": "MedicalLiteratureReviewer",
-    #     "arguments": {
-    #         "research_topic": "Immunotherapy efficacy in triple-negative breast cancer",
-    #         "literature_content": "Study 1: Pembrolizumab showed 23% response rate (n=150). Study 2: Atezolizumab combined with chemotherapy improved progression-free survival (HR=0.62, p=0.002).",
-    #         "focus_area": "treatment efficacy",
-    #         "study_types": "randomized controlled trials",
-    #         "quality_level": "moderate and above",
-    #         "review_scope": "rapid review"
-    #     }
-    # },
-    # {
-    #     "name": "HypothesisGenerator",
-    #     "arguments": {
-    #         "context": "Recent studies have shown that patients with Alzheimer's disease have altered gut microbiome composition. Additionally, inflammation markers in the brain correlate with cognitive decline. Some research suggests that certain probiotics can cross the blood-brain barrier and influence neuroinflammation.",
-    #         "domain": "neuroscience",
-    #         "number_of_hypotheses": "3",
-    #         "hypothesis_format": "If-then statements"
-    #     }
-    # },
-    # {
-    #     "name": "HypothesisGenerator",
-    #     "arguments": {
-    #         "context": "Machine learning models trained on electronic health records show promise in predicting drug adverse events. However, most models focus on single drugs rather than drug combinations. Polypharmacy is common in elderly patients and drug-drug interactions are poorly understood.",
-    #         "domain": "pharmacology",
-    #         "number_of_hypotheses": "2"
-    #     }
-    # },
-    {
-        "name": "ExperimentalDesignScorer",
-        "arguments": {
-            "hypothesis": "Daily high-intensity interval training (HIIT) for 8 weeks will improve insulin sensitivity in overweight adults compared to moderate-intensity continuous training (MICT).",
-            "design_description": """
-Study Design: Randomized, parallel-group clinical trial
-
-Participants: 120 overweight adults (BMI 25–30) aged 30–50, sedentary lifestyle
-Inclusion: No history of diabetes, stable weight for 3 months
-Exclusion: Cardiovascular disease, musculoskeletal injuries, current exercise regimen
-
-Interventions:
-- HIIT group (n=60): 4×4-minute intervals at 90% HRmax with 3-minute active recovery, 3×/week
-- MICT group (n=60): 40 minutes at 60% HRmax, 3×/week
-
-Randomization: Computer-generated simple randomization
-Blinding: Outcome assessors blinded
-
-Primary Outcome: Change in HOMA-IR from baseline to 8 weeks
-Secondary Outcomes: VO₂max, body composition (DXA), fasting glucose and insulin
-
-Data Collection: Baseline, 4 weeks, 8 weeks
-Sample Size Justification: 90% power to detect a 15% change in HOMA-IR (SD=20%), α=0.05, 15% dropout
-
-Statistical Analysis: ANCOVA adjusting for baseline values, intention-to-treat
-""",
-        },
-    },
-]
-
-# Run individual test queries
-for idx, query in enumerate(test_queries):
-    # try:
-    print(
-        f"\n[{idx+1}] Running tool: {query['name']} with arguments: {list(query['arguments'].keys())}"
-    )
-    result = tooluni.run(query)
-    print("✅ Success. Output snippet:")
-    if isinstance(result, dict):
-        if result.get("success"):
-            result_text = result["result"]
-            print(
-                f"Result: {result_text[:2000]}..."
-                if len(result_text) > 2000
-                else f"Result: {result_text}"
-            )
-            print(
-                f"Model used: {result.get('metadata', {}).get('model_info', {}).get('model_id', 'unknown')}"
-            )
-        else:
-            print(f"Failed: {result.get('error', 'Unknown error')}")
-    else:
-        print(str(result)[:5000])
-# except Exception as e:
-#     print(f"❌ Failed running {query['name']}. Error: {e}")
-
-print("\n🏁 Agentic tool tests completed!")

tooluniverse/test/test_agentic_tool_azure_models.py

@@ -1,91 +0,0 @@
-#!/usr/bin/env python3
-"""
-Batch test: AgenticTool with multiple Azure OpenAI deployments.
-- Validates API key during initialization
-- Performs a tiny run call per model (1 token)
-"""
-
-import os
-import sys
-from typing import List
-
-# Ensure src/ is importable
-CURRENT_DIR = os.path.dirname(__file__)
-SRC_DIR = os.path.join(CURRENT_DIR, "src")
-if SRC_DIR not in sys.path:
-    sys.path.insert(0, SRC_DIR)
-
-try:
-    from tooluniverse.agentic_tool import AgenticTool  # type: ignore
-except ImportError:
-    # Fallback for when running from different directory
-    sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
-    from tooluniverse.agentic_tool import AgenticTool  # type: ignore
-
-# Chat-capable deployment IDs to test (skip embeddings)
-MODELS: List[str] = [
-    "gpt-4.1",
-    "gpt-4.1-mini",
-    "gpt-4.1-nano",
-    "gpt-4o-1120",
-    "gpt-4o-0806",
-    "gpt-4o-mini-0718",
-    "o4-mini-0416",
-    "o3-mini-0131",
-]
-
-
-def test_model(model_id: str) -> None:
-    print(f"\n=== Testing model: {model_id} ===")
-    config = {
-        "name": f"agentic_test_{model_id}",
-        "description": "AgenticTool model validation",
-        "type": "AgenticTool",
-        "prompt": "Echo: {q}",
-        "input_arguments": ["q"],
-        "parameter": {
-            "type": "object",
-            "properties": {
-                "q": {"type": "string", "description": "input", "required": True}
-            },
-            "required": ["q"],
-        },
-        "configs": {
-            "api_type": "CHATGPT",
-            "model_id": model_id,
-            "validate_api_key": True,
-            "temperature": 0.0,
-            "max_new_tokens": 1,
-            "return_json": False,
-            "return_metadata": False,
-        },
-    }
-
-    try:
-        tool = AgenticTool(config)
-        print("- Init: OK (API key validated)")
-    except Exception as e:
-        print(f"- Init: FAIL -> {e}")
-        return
-
-    try:
-        out = tool.run({"q": "ping"})
-        ok = isinstance(out, (str, dict))
-        print(
-            f"- Run : {'OK' if ok else 'WARN'} -> {str(out)[:120].replace('\n', ' ')}"
-        )
-    except Exception as e:
-        print(f"- Run : FAIL -> {e}")
-
-
-def main() -> None:
-    print("Azure endpoint:", os.getenv("AZURE_OPENAI_ENDPOINT"))
-    print("Using per-model versions:")
-    print(os.getenv("AZURE_OPENAI_API_VERSION_BY_MODEL", "<none>"))
-
-    for m in MODELS:
-        test_model(m)
-
-
-if __name__ == "__main__":
-    main()

tooluniverse/test/test_alphafold_tool.py

@@ -1,108 +0,0 @@
-import json
-import os
-from typing import Any, Dict, List
-from tooluniverse import ToolUniverse
-
-# Load all tool schemas from JSON
-schema_path = os.path.join(
-    os.path.dirname(__file__), "..", "data", "alphafold_tools.json"
-)
-with open(schema_path) as f:
-    tools_json = json.load(f)
-
-schemas = {tool["name"]: tool["return_schema"] for tool in tools_json}
-
-tooluni = ToolUniverse()
-tooluni.load_tools()
-
-test_queries: List[Dict[str, Any]] = [
-    # Hemoglobin subunit alpha (valid)
-    {
-        "name": "alphafold_get_prediction",
-        "arguments": {"qualifier": "P69905"},
-    },
-    # Invalid
-    {
-        "name": "alphafold_get_prediction",
-        "arguments": {"qualifier": "XXX123"},
-    },
-    # Missing param
-    {
-        "name": "alphafold_get_prediction",
-        "arguments": {},
-    },
-    # Summary: valid
-    {
-        "name": "alphafold_get_summary",
-        "arguments": {"qualifier": "P69905"},
-    },
-    # Annotations (valid + invalid type)
-    {
-        "name": "alphafold_get_annotations",
-        "arguments": {"qualifier": "P69905", "type": "MUTAGEN"},
-    },
-    {
-        "name": "alphafold_get_annotations",
-        "arguments": {"qualifier": "P69905", "type": "INVALID"},
-    },
-]
-
-for idx, query in enumerate(test_queries, 1):
-    print(f"\n[{idx}] Running {query['name']} with {query['arguments']}")
-    result = tooluni.run(query)
-
-    # Handle errors
-    if isinstance(result, dict) and "error" in result:
-        print(f"INVALID: {result['error']}")
-        if "detail" in result:
-            print(f"   Detail: {result['detail']}")
-        continue
-
-    # Handle success
-    data = result.get("data")
-    if not data:
-        print("No data returned.")
-        continue
-
-    # Schema validation (check only top-level keys)
-    schema = schemas[query["name"]]
-    expected_keys = schema.get("properties", {}).keys()
-
-    # Handle list vs dict results
-    if isinstance(data, list) and data:
-        record = data[0]
-    elif isinstance(data, dict):
-        record = data
-    else:
-        record = {}
-
-    missing = [k for k in expected_keys if k not in record]
-    if missing:
-        print(f"   INVALID Missing expected fields: {missing}")
-    else:
-        print("   SUCCESS All expected schema fields present")
-
-    # Show highlights depending on tool
-    if query["name"] == "alphafold_get_prediction":
-        if "uniprotDescription" in record:
-            print(
-                f"   {record.get('uniprotDescription')} ({record.get('uniprotAccession')})"
-            )
-            print(f"   Organism: {record.get('organismScientificName')}")
-            print(f"   Avg pLDDT: {record.get('globalMetricValue')}")
-
-    elif query["name"] == "alphafold_get_summary":
-        entry = record.get("uniprot_entry", {})
-        structures = record.get("structures", [])
-        print(f"   UniProt AC: {entry.get('ac')}, ID: {entry.get('id')}")
-        print(f"   Sequence length: {entry.get('sequence_length')}")
-        print(f"   Structures returned: {len(structures)}")
-
-    elif query["name"] == "alphafold_get_annotations":
-        annotations = record.get("annotation", [])
-        print(f"   Accession: {record.get('accession')}")
-        print(f"   Total annotations: {len(annotations)}")
-        if annotations:
-            first_ann = annotations[0]
-            print(f"   First annotation type: {first_ann.get('type')}")
-            print(f"   First annotation description: {first_ann.get('description')}")

tooluniverse/test/test_api_key_validation_min.py

@@ -1,64 +0,0 @@
-#!/usr/bin/env python3
-"""
-Minimal test: validate API key during AgenticTool initialization.
-- Success: prints OK and model info
-- Failure: prints the error message (e.g., invalid/missing key or model not deployed)
-"""
-
-import os
-import sys
-
-# Ensure src/ is importable
-CURRENT_DIR = os.path.dirname(__file__)
-SRC_DIR = os.path.join(CURRENT_DIR, "src")
-if SRC_DIR not in sys.path:
-    sys.path.insert(0, SRC_DIR)
-
-try:
-    from tooluniverse.agentic_tool import AgenticTool  # type: ignore
-except ImportError:
-    # Fallback for when running from different directory
-    sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
-    from tooluniverse.agentic_tool import AgenticTool  # type: ignore
-
-
-def main() -> None:
-    config = {
-        "name": "api_key_validation_test",
-        "description": "Minimal API key validation test",
-        "type": "AgenticTool",
-        "prompt": "Test: {q}",
-        "input_arguments": ["q"],
-        "parameter": {
-            "type": "object",
-            "properties": {
-                "q": {
-                    "type": "string",
-                    "description": "placeholder",
-                    "required": True,
-                }
-            },
-            "required": ["q"],
-        },
-        "configs": {
-            "api_type": "CHATGPT",  # or "GEMINI" if you prefer
-            "model_id": "gpt-4o-1120",  # requested model to test
-            "validate_api_key": True,  # this triggers validation during init
-            "temperature": 0.0,
-            "max_new_tokens": 1,
-        },
-    }
-
-    print("Running minimal API key validation test...")
-    try:
-        tool = AgenticTool(config)
-        info = tool.get_model_info()
-        print("OK: initialization succeeded and API key validated.")
-        print(f"Model info: {info}")
-    except Exception as e:
-        print("ERROR: initialization failed during API key validation.")
-        print(f"Reason: {e}")
-
-
-if __name__ == "__main__":
-    main()

tooluniverse/test/test_chem_tool.py

@@ -1,37 +0,0 @@
-from tooluniverse import ToolUniverse
-
-# Step 1: Initialize tool universe
-tooluni = ToolUniverse()
-tooluni.load_tools()
-
-# Step 2: Define test queries for the ChEMBLTool
-test_queries = [
-    # {"name": "ChEMBL_search_similar_molecules", "arguments": {"query": "aspirin"}},
-    # {"name": "ChEMBL_search_similar_molecules", "arguments": {"query": "aspirin", "similarity_threshold": 90}},
-    # {"name": "ChEMBL_search_similar_molecules", "arguments": {"query": "aspirin", "max_results": 5}},
-    # {"name": "ChEMBL_search_similar_molecules", "arguments": {"query": "aspirin", "similarity_threshold": 85, "max_results": 3}},
-    # {"name": "ChEMBL_search_similar_molecules", "arguments": {"query": "CC(=O)OC1=CC=CC=C1C(=O)O", "similarity_threshold": 80, "max_results": 10}},  # SMILES for aspirin
-    # {'name': 'ChEMBL_search_similar_molecules', 'arguments': {'query': 'FENOFIBRATE', 'similarity_threshold': 70, 'max_results': 20}}
-    {
-        "name": "ChEMBL_search_similar_molecules",
-        "arguments": {
-            "query": "Gadavist",
-            "similarity_threshold": 70,
-            "max_results": 20,
-        },
-    }
-]
-
-# Step 3: Run all test queries
-for idx, query in enumerate(test_queries):
-    # try:
-    print(
-        f"\n[{idx+1}] Running tool: {query['name']} with arguments: {query['arguments']}"
-    )
-    result = tooluni.run(query)
-    print("✅ Success. Example output snippet:")
-    print(
-        result if isinstance(result, dict) else str(result)
-    )  # Print snippet if result is big
-# except Exception as e:
-#     print(f"❌ Failed. Error: {str(e)}")

tooluniverse/test/test_claude_sdk.py

@@ -1,93 +0,0 @@
-import asyncio
-import os
-from pathlib import Path
-
-from claude_agent_sdk import ClaudeAgentOptions, query
-from dotenv import load_dotenv
-
-load_dotenv()
-
-
-async def delegate_task(
-    prompt: str,
-    append_system_prompt: str,
-):
-    """Delegate a task to an expert
-
-    Args:
-        prompt: The prompt describing the task to delegate
-        append_system_prompt: The system prompt describing the expert
-    Returns:
-        The result of the delegation
-    """
-    # Create sandbox directory if it doesn't exist
-    sandbox_dir = Path(__file__).parent / "sandbox"
-    sandbox_dir.mkdir(exist_ok=True)
-    cwd = str(sandbox_dir)
-
-    async for message in query(
-        prompt=prompt,
-        options=ClaudeAgentOptions(
-            system_prompt={
-                "type": "preset",
-                "preset": "claude_code",
-                "append": append_system_prompt,
-            },  # Use the preset
-            cwd=cwd,
-            permission_mode="bypassPermissions",
-            mcp_servers={
-                "tooluniverse": {
-                    "type": "stdio",
-                    "command": "uv",
-                    "args": [
-                        "run",
-                        "tooluniverse-smcp-stdio",
-                    ],
-                    "env": {},
-                },
-            },
-        ),
-    ):
-        # Print all message types to see tool usage
-        message_type = type(message).__name__
-        print(f"\n--- Message Type: {message_type} ---")
-
-        # Check for tool use messages
-        if message_type == "ToolUseMessage":
-            print(f"Tool Name: {message.name}")
-            print(f"Tool Input: {message.input}")
-        elif message_type == "ToolResultMessage":
-            print(f"Tool: {message.tool_use_id}")
-            result_preview = (
-                str(message.content)[:200]
-                if hasattr(message, "content")
-                else str(message)[:200]
-            )
-            print(f"Result: {result_preview}...")
-        elif message_type == "TextMessage":
-            text_preview = (
-                str(message.text)[:200]
-                if hasattr(message, "text")
-                else str(message)[:200]
-            )
-            print(f"Text: {text_preview}...")
-        elif message_type == "ResultMessage":
-            return {
-                "status": "success",
-                "result": message.result,
-            }
-        else:
-            # Print any other message types for debugging
-            print(f"Message: {message}")
-
-
-if __name__ == "__main__":
-    # result = asyncio.run(conduct_research("What is the capital of France?"))
-    # print(result)
-    result = asyncio.run(
-        delegate_task(
-            "What tools do you have available? Return a list of all available tool names",
-            "You are a helpful assistant",
-        )
-    )
-    print(result)

tooluniverse/test/test_compose_lieraturereview.py

@@ -1,63 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple demo for SimpleLiteratureTool - Perfect for paper screenshots
-Shows clean, minimal compose tool functionality
-"""
-
-from tooluniverse import ToolUniverse
-
-
-def main():
-    print("🔬 LiteratureReviewAgent Tool Demo")
-    print("=" * 40)
-
-    # Initialize ToolUniverse and load all tools
-    engine = ToolUniverse()
-    engine.load_tools()  # Load all available tools
-
-    # Check available tools
-    all_tools = engine.return_all_loaded_tools()
-    print(f"Total tools loaded: {len(all_tools)}")
-
-    # Get tool names (for dictionary-based tools, extract the 'name' field)
-    tool_names = []
-    for tool in all_tools:
-        if isinstance(tool, dict) and "name" in tool:
-            tool_names.append(tool["name"])
-        elif isinstance(tool, str):
-            tool_names.append(tool)
-
-    # Look for compose tools
-    compose_tools = [
-        t for t in tool_names if "Safety" in t or "Literature" in t or "Simple" in t
-    ]
-    print(f"Compose tools available: {compose_tools}")
-
-    if "LiteratureReviewAgent" in tool_names:
-        # Run the simple compose tool
-        result = engine.run_one_function(
-            {
-                "name": "LiteratureReviewAgent",
-                "arguments": {"research_topic": "CRISPR gene editing"},
-            }
-        )
-        print(result)
-
-        # Display clean results if it's a dict
-        if isinstance(result, dict):
-            print(f"📚 Topic: {result.get('topic', 'N/A')}")
-            print(f"📄 Papers Found: {result.get('papers_found', 0)}")
-            print("🗂️ Sources: Europe PMC, OpenAlex, PubTator")
-            print(
-                f"🤖 AI Summary: {'✅ Generated' if result.get('ai_summary') else '❌ Failed'}"
-            )
-        else:
-            print(f"Result: {result}")
-    else:
-        print("LiteratureReviewAgent not found in loaded tools")
-
-    print("\n✅ Demo Complete!")
-
-
-if __name__ == "__main__":
-    main()