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

tooluniverse/test/test_fda_drug_labeling.py

@@ -1,91 +0,0 @@
-# === openfda_test_all_tools.py ===
-
-from tooluniverse import ToolUniverse
-
-# Step 1: Initialize tool universe
-tooluni = ToolUniverse()
-tooluni.load_tools()
-
-# Step 2: Define all test queries for all tools
-test_queries = [
-    # # ====== Tests for FAERS_count_reactions_by_drug_event ======
-    # {"name": "FAERS_count_reactions_by_drug_event", "arguments": {"medicinalproduct": "LIPITOR"}},
-    # {"name": "FAERS_count_reactions_by_drug_event", "arguments": {"medicinalproduct": "LIPITOR", "patient.patientsex": "Male", "serious": "Serious"}},
-    # {"name": "FAERS_count_reactions_by_drug_event", "arguments": {"medicinalproduct": "ASPIRIN", "patient.patientagegroup": "Adult"}},
-    # {"name": "FAERS_count_reactions_by_drug_event", "arguments": {"medicinalproduct": "ADVIL", "patient.patientsex": "Female", "patient.patientagegroup": "Elderly", "occurcountry": "US", "serious": "Non-serious"}},
-    # {"name": "FAERS_count_reactions_by_drug_event", "arguments": {"medicinalproduct": "ADVIL", "seriousnessdeath": "Yes"}},
-    # # ====== Tests for FAERS_count_drugs_by_drug_event ======
-    # {"name": "FAERS_count_drugs_by_drug_event", "arguments": {"patient.patientsex": "Female"}},
-    # {"name": "FAERS_count_drugs_by_drug_event", "arguments": {"patient.patientagegroup": "Child"}},
-    # {"name": "FAERS_count_drugs_by_drug_event", "arguments": {"serious": "Serious"}},
-    # {"name": "FAERS_count_drugs_by_drug_event", "arguments": {"occurcountry": "CA", "serious": "Non-serious"}},
-    # # ====== Tests for FAERS_count_country_by_drug_event ======
-    # {"name": "FAERS_count_country_by_drug_event", "arguments": {"medicinalproduct": "METFORMIN"}},
-    # {"name": "FAERS_count_country_by_drug_event", "arguments": {"medicinalproduct": "INSULIN", "patient.patientsex": "Male"}},
-    # {"name": "FAERS_count_country_by_drug_event", "arguments": {"medicinalproduct": "ASPIRIN", "serious": "Serious"}},
-    # {"name": "FAERS_count_country_by_drug_event", "arguments": {"medicinalproduct": "STATIN", "patient.patientsex": "Female", "patient.patientagegroup": "Adult", "serious": "Non-serious"}},
-    # # ====== Tests for FAERS_count_reportercountry_by_drug_event ======
-    # {"name": "FAERS_count_reportercountry_by_drug_event", "arguments": {"medicinalproduct": "LANTUS"}},
-    # {"name": "FAERS_count_reportercountry_by_drug_event", "arguments": {"medicinalproduct": "AMLODIPINE", "patient.patientsex": "Unknown"}},
-    # {"name": "FAERS_count_reportercountry_by_drug_event", "arguments": {"medicinalproduct": "ATORVASTATIN", "patient.patientagegroup": "Elderly"}},
-    # {"name": "FAERS_count_reportercountry_by_drug_event", "arguments": {"medicinalproduct": "GABAPENTIN", "patient.patientsex": "Male", "patient.patientagegroup": "Adult", "serious": "Serious"}},
-    # # ====== Tests for FAERS_count_seriousness_by_drug_event ======
-    # {"name": "FAERS_count_seriousness_by_drug_event", "arguments": {"medicinalproduct": "NAPROXEN"}},
-    # {"name": "FAERS_count_seriousness_by_drug_event", "arguments": {"medicinalproduct": "ALBUTEROL", "patient.patientsex": "Female"}},
-    # {"name": "FAERS_count_seriousness_by_drug_event", "arguments": {"medicinalproduct": "PREDNISONE", "patient.patientagegroup": "Child"}},
-    # {"name": "FAERS_count_seriousness_by_drug_event", "arguments": {"medicinalproduct": "METHOTREXATE", "patient.patientsex": "Male", "patient.patientagegroup": "Adult", "occurcountry": "US"}},
-    # # ====== Tests for FAERS_count_outcomes_by_drug_event ======
-    # {"name": "FAERS_count_outcomes_by_drug_event", "arguments": {"medicinalproduct": "IBUPROFEN"}},
-    # {"name": "FAERS_count_outcomes_by_drug_event", "arguments": {"medicinalproduct": "IBUPROFEN", "patient.patientsex": "Female", "occurcountry": "GB"}},
-    # {"name": "FAERS_count_outcomes_by_drug_event", "arguments": {"medicinalproduct": "IBUPROFEN", "patient.patientsex": "Male", "patient.patientagegroup": "Adolescent"}},
-    # # ====== Tests for FAERS_count_drug_routes_by_event ======
-    # {"name": "FAERS_count_drug_routes_by_event", "arguments": {"medicinalproduct": "INSULIN", "serious": "Serious"}},
-    # {"name": "FAERS_count_drug_routes_by_event", "arguments": {"medicinalproduct": "MORPHINE", "serious": "Non-serious"}},
-    # # ====== Tests for FAERS_count_patient_age_distribution ======
-    # {"name": "FAERS_count_patient_age_distribution", "arguments": {"medicinalproduct": "PENICILLIN"}},
-    # {"name": "FAERS_count_patient_age_distribution", "arguments": {"medicinalproduct": "ACETAMINOPHEN"}},
-    # ====== Tests for FAERS_count_death_related_by_drug ======
-    # {"name": "FAERS_count_death_related_by_drug", "arguments": {"medicinalproduct": "FENTANYL"}},
-    # {"name": "FAERS_count_death_related_by_drug", "arguments": {"medicinalproduct": "WARFARIN"}},
-    # # ====== Tests for FAERS_count_additive_adverse_reactions ======
-    # {"name": "FAERS_count_additive_adverse_reactions", "arguments": {"medicinalproducts": ["LIPITOR", "ASPIRIN"]}},
-    # {"name": "FAERS_count_additive_adverse_reactions", "arguments": {"medicinalproducts": ["LIPITOR", "ASPIRIN"], "patient.patientsex": "Male"}},
-    # {"name": "FAERS_count_additive_adverse_reactions", "arguments": {"medicinalproducts": ["LIPITOR", "ASPIRIN"], "serious": "Serious"}},
-    # # ====== Tests for FAERS_count_additive_event_reports_by_country ======
-    # {"name": "FAERS_count_additive_event_reports_by_country", "arguments": {"medicinalproducts": ["LIPITOR", "ASPIRIN"]}},
-    # {"name": "FAERS_count_additive_event_reports_by_country", "arguments": {"medicinalproducts": ["LIPITOR", "ASPIRIN"], "serious": "Non-serious"}},
-    # # ====== Tests for FAERS_count_additive_reports_by_reporter_country ======
-    # {"name": "FAERS_count_additive_reports_by_reporter_country", "arguments": {"medicinalproducts": ["LIPITOR", "ASPIRIN"]}},
-    # {"name": "FAERS_count_additive_reports_by_reporter_country", "arguments": {"medicinalproducts": ["LIPITOR", "ASPIRIN"], "patient.patientagegroup": "Elderly"}},
-    # # ====== Tests for FAERS_count_additive_seriousness_classification ======
-    # {"name": "FAERS_count_additive_seriousness_classification", "arguments": {"medicinalproducts": ["LIPITOR", "ASPIRIN"]}},
-    # {"name": "FAERS_count_additive_seriousness_classification", "arguments": {"medicinalproducts": ["LIPITOR", "ASPIRIN"], "occurcountry": "CA"}},
-    # ====== Tests for FAERS_count_additive_reaction_outcomes ======
-    # {"name": "FAERS_count_additive_reaction_outcomes", "arguments": {"medicinalproducts": ["LIPITOR", "ASPIRIN"]}},
-    # {"name": "FAERS_count_additive_reaction_outcomes", "arguments": {"medicinalproducts": ["LIPITOR", "ASPIRIN"]}},
-    # ====== Tests for FAERS_count_additive_administration_routes ======
-    # {"name": "FAERS_count_additive_administration_routes", "arguments": {"medicinalproducts": ["LIPITOR", "ASPIRIN"]}},
-    # {"name": "FAERS_count_additive_administration_routes", "arguments": {"medicinalproducts": ["LIPITOR", "ASPIRIN"], "serious": "Non-serious"}},
-    #            {'name': 'FAERS_count_additive_seriousness_classification', 'arguments': {'medicinalproducts': ['Dysport'], 'occurcountry': 'US', 'patient.patientagegroup': 'Adult'}},
-    {
-        "name": "FDA_get_drug_names_by_clinical_studies",
-        "arguments": {
-            "clinical_studies": "NSCLC hepatic impairment",
-            "indication": "cardiovascular",
-        },
-    },
-]
-
-# 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)[:500]
-        )  # Print snippet if result is big
-    except Exception as e:
-        print(f"❌ Failed. Error: {str(e)}")

tooluniverse/test/test_gene_ontology_tools.py

@@ -1,66 +0,0 @@
-# test_go.py
-
-from tooluniverse import (
-    ToolUniverse,
-)  # Assuming your ToolUniverse class is in this module
-from typing import Any, Dict, List
-
-# Step 1: Initialize ToolUniverse and load the GO tools
-tooluni = ToolUniverse()
-# This assumes your ToolUniverse is configured to find 'go_tools.json'
-# when the 'go' category is requested.
-tooluni.load_tools(["go"])
-
-# Test GO ID for cell cycle process
-TEST_GO_ID = "GO:0007049"  # cell cycle
-TEST_GENE_NAME = "TP53"  # TP53 gene
-
-test_queries: List[Dict[str, Any]] = [
-    {"name": "GO_search_terms", "arguments": {"query": "cell cycle"}},
-    {"name": "GO_get_term_by_id", "arguments": {"id": TEST_GO_ID}},
-    {"name": "GO_get_term_details", "arguments": {"id": TEST_GO_ID}},
-    {"name": "GO_get_genes_for_term", "arguments": {"id": TEST_GO_ID, "rows": 5}},
-    {"name": "GO_get_annotations_for_gene", "arguments": {"gene_id": TEST_GENE_NAME}},
-]
-
-
-def format_value(value, max_items=5, max_length=200):
-    """Helper function to format output values with more detail"""
-    if isinstance(value, dict):
-        dict_str = str(value)
-        return f"Dict ({len(dict_str)} chars): {dict_str[:500]}{'...' if len(dict_str) > 500 else ''}"
-    elif isinstance(value, list):
-        if not value:
-            return "Empty list"
-        items_to_show = value[:max_items]
-        items_str = "\n  - ".join(
-            [
-                str(item)[:max_length] + ("..." if len(str(item)) > max_length else "")
-                for item in items_to_show
-            ]
-        )
-        remaining = len(value) - max_items
-        return f"List with {len(value)} items:\n  - {items_str}" + (
-            f"\n  ... and {remaining} more items" if remaining > 0 else ""
-        )
-    elif isinstance(value, str):
-        return f"String ({len(value)} chars): {value[:max_length]}{'...' if len(value) > max_length else ''}"
-    else:
-        return f"Type: {type(value)}, Value: {value}"
-
-
-print("--- Starting Gene Ontology (GO) Tool Test ---")
-
-for idx, q in enumerate(test_queries, 1):
-    print(
-        f"\n{'='*80}\n[{idx}] {q['name']}({', '.join([f'{k}={v}' for k, v in q['arguments'].items()])})"
-    )
-    res = tooluni.run(q)
-
-    if isinstance(res, dict) and "error" in res:
-        print(f"ERROR: {res['error']}")
-    else:
-        print(format_value(res))
-    print()
-
-print("\n--- GO Tool Test Completed ---")

tooluniverse/test/test_global_fallback.py

@@ -1,288 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify global fallback functionality in AgenticTool.
-Tests the system-wide default fallback chain.
-"""
-
-import os
-import json
-from src.tooluniverse.agentic_tool import AgenticTool
-
-
-def test_default_global_fallback():
-    """Test: Tool uses default global fallback chain when no explicit fallback is configured."""
-
-    print("=== Test 1: Default Global Fallback Chain ===\n")
-
-    # Remove Gemini API key to force fallback
-    original_gemini_key = os.environ.get("GEMINI_API_KEY")
-    if "GEMINI_API_KEY" in os.environ:
-        del os.environ["GEMINI_API_KEY"]
-
-    try:
-        # Create tool with only primary API (no explicit fallback)
-        tool = AgenticTool(
-            {
-                "name": "gemini_with_global_fallback",
-                "api_type": "GEMINI",
-                "model_id": "gemini-2.0-flash",
-                # No fallback_api_type configured - should use global fallback
-                "prompt": "You are a helpful assistant. Answer: {question}",
-                "input_arguments": ["question"],
-            }
-        )
-
-        print(f"Tool available: {tool.is_available()}")
-        print(f"Current API: {tool._current_api_type}")
-        print(f"Current model: {tool._current_model_id}")
-        print(f"Original config: {tool._api_type} with {tool._model_id}")
-        print(f"Global fallback enabled: {tool._use_global_fallback}")
-        print(f"Global fallback chain: {tool._global_fallback_chain}")
-
-        if tool.is_available():
-            result = tool.run({"question": "What is 2+2?"})
-            if result.get("success"):
-                print(f"✅ Tool worked with global fallback: {result['result']}")
-            else:
-                print(f"❌ Tool failed: {result['error']}")
-        else:
-            print(f"❌ Tool not available: {tool._initialization_error}")
-
-    finally:
-        # Restore Gemini key
-        if original_gemini_key:
-            os.environ["GEMINI_API_KEY"] = original_gemini_key
-
-
-def test_custom_global_fallback():
-    """Test: Tool uses custom global fallback chain from environment variable."""
-
-    print("\n=== Test 2: Custom Global Fallback Chain ===\n")
-
-    # Set custom global fallback chain
-    custom_chain = [
-        {"api_type": "GEMINI", "model_id": "gemini-2.0-flash"},
-        {"api_type": "CHATGPT", "model_id": "gpt-4o-mini-0718"},
-    ]
-    os.environ["AGENTIC_TOOL_FALLBACK_CHAIN"] = json.dumps(custom_chain)
-
-    # Remove Azure OpenAI API key to force fallback
-    original_azure_key = os.environ.get("AZURE_OPENAI_API_KEY")
-    if "AZURE_OPENAI_API_KEY" in os.environ:
-        del os.environ["AZURE_OPENAI_API_KEY"]
-
-    try:
-        # Create tool with ChatGPT as primary
-        tool = AgenticTool(
-            {
-                "name": "chatgpt_with_custom_global_fallback",
-                "api_type": "CHATGPT",
-                "model_id": "gpt-4o-1120",
-                "prompt": "You are a helpful assistant. Answer: {question}",
-                "input_arguments": ["question"],
-            }
-        )
-
-        print(f"Tool available: {tool.is_available()}")
-        print(f"Current API: {tool._current_api_type}")
-        print(f"Current model: {tool._current_model_id}")
-        print(f"Original config: {tool._api_type} with {tool._model_id}")
-        print(f"Custom global fallback chain: {tool._global_fallback_chain}")
-
-        if tool.is_available():
-            result = tool.run({"question": "What is 2+2?"})
-            if result.get("success"):
-                print(f"✅ Tool worked with custom global fallback: {result['result']}")
-            else:
-                print(f"❌ Tool failed: {result['error']}")
-        else:
-            print(f"❌ Tool not available: {tool._initialization_error}")
-
-    finally:
-        # Restore Azure key and remove custom chain
-        if original_azure_key:
-            os.environ["AZURE_OPENAI_API_KEY"] = original_azure_key
-        if "AGENTIC_TOOL_FALLBACK_CHAIN" in os.environ:
-            del os.environ["AGENTIC_TOOL_FALLBACK_CHAIN"]
-
-
-def test_disable_global_fallback():
-    """Test: Tool can disable global fallback."""
-
-    print("\n=== Test 3: Disable Global Fallback ===\n")
-
-    # Remove Azure OpenAI API key
-    original_azure_key = os.environ.get("AZURE_OPENAI_API_KEY")
-    if "AZURE_OPENAI_API_KEY" in os.environ:
-        del os.environ["AZURE_OPENAI_API_KEY"]
-
-    try:
-        # Create tool with global fallback disabled
-        tool = AgenticTool(
-            {
-                "name": "no_global_fallback",
-                "api_type": "CHATGPT",
-                "model_id": "gpt-4o-1120",
-                "use_global_fallback": False,  # Disable global fallback
-                "prompt": "You are a helpful assistant. Answer: {question}",
-                "input_arguments": ["question"],
-            }
-        )
-
-        print(f"Tool available: {tool.is_available()}")
-        print(f"Current API: {tool._current_api_type}")
-        print(f"Current model: {tool._current_model_id}")
-        print(f"Global fallback enabled: {tool._use_global_fallback}")
-
-        if tool.is_available():
-            result = tool.run({"question": "What is 2+2?"})
-            print(f"Unexpected success: {result}")
-        else:
-            print(
-                f"✅ Tool correctly failed without global fallback: {tool._initialization_error}"
-            )
-
-    finally:
-        # Restore Azure key
-        if original_azure_key:
-            os.environ["AZURE_OPENAI_API_KEY"] = original_azure_key
-
-
-def test_explicit_fallback_priority():
-    """Test: Explicit fallback takes priority over global fallback."""
-
-    print("\n=== Test 4: Explicit Fallback Priority ===\n")
-
-    # Remove Gemini API key
-    original_gemini_key = os.environ.get("GEMINI_API_KEY")
-    if "GEMINI_API_KEY" in os.environ:
-        del os.environ["GEMINI_API_KEY"]
-
-    try:
-        # Create tool with both explicit and global fallback
-        tool = AgenticTool(
-            {
-                "name": "explicit_vs_global_fallback",
-                "api_type": "GEMINI",
-                "model_id": "gemini-2.0-flash",
-                "fallback_api_type": "CHATGPT",  # Explicit fallback
-                "fallback_model_id": "gpt-4o-mini-0718",  # Different from global default
-                "prompt": "You are a helpful assistant. Answer: {question}",
-                "input_arguments": ["question"],
-            }
-        )
-
-        print(f"Tool available: {tool.is_available()}")
-        print(f"Current API: {tool._current_api_type}")
-        print(f"Current model: {tool._current_model_id}")
-        print(
-            f"Explicit fallback: {tool._fallback_api_type} ({tool._fallback_model_id})"
-        )
-        print(f"Global fallback chain: {tool._global_fallback_chain}")
-
-        if tool.is_available():
-            result = tool.run({"question": "What is 2+2?"})
-            if result.get("success"):
-                print(f"✅ Tool worked with explicit fallback: {result['result']}")
-                # Check if it used explicit fallback (gpt-4o-mini-0718) instead of global default (gpt-4o-1120)
-                if tool._current_model_id == "gpt-4o-mini-0718":
-                    print("✅ Used explicit fallback as expected")
-                else:
-                    print(
-                        f"⚠️  Used {tool._current_model_id} instead of explicit fallback"
-                    )
-            else:
-                print(f"❌ Tool failed: {result['error']}")
-        else:
-            print(f"❌ Tool not available: {tool._initialization_error}")
-
-    finally:
-        # Restore Gemini key
-        if original_gemini_key:
-            os.environ["GEMINI_API_KEY"] = original_gemini_key
-
-
-def test_multiple_tools_global_fallback():
-    """Test: Multiple tools using global fallback."""
-
-    print("\n=== Test 5: Multiple Tools with Global Fallback ===\n")
-
-    # Remove Gemini API key to force fallback for Gemini tools
-    original_gemini_key = os.environ.get("GEMINI_API_KEY")
-    if "GEMINI_API_KEY" in os.environ:
-        del os.environ["GEMINI_API_KEY"]
-
-    try:
-        tools_config = [
-            {
-                "name": "gemini_tool_1",
-                "api_type": "GEMINI",
-                "model_id": "gemini-2.0-flash",
-                "prompt": "Gemini tool 1: {question}",
-                "input_arguments": ["question"],
-            },
-            {
-                "name": "gemini_tool_2",
-                "api_type": "GEMINI",
-                "model_id": "gemini-2.0-flash",
-                "prompt": "Gemini tool 2: {question}",
-                "input_arguments": ["question"],
-            },
-            {
-                "name": "chatgpt_tool",
-                "api_type": "CHATGPT",
-                "model_id": "gpt-4o-1120",
-                "prompt": "ChatGPT tool: {question}",
-                "input_arguments": ["question"],
-            },
-        ]
-
-        tools = []
-        for config in tools_config:
-            tool = AgenticTool(config)
-            tools.append(tool)
-
-            status = "✅ Available" if tool.is_available() else "❌ Unavailable"
-            current_api = (
-                f"{tool._current_api_type} ({tool._current_model_id})"
-                if tool._current_api_type
-                else "None"
-            )
-            print(f"{config['name']}: {status} - Using: {current_api}")
-
-        print()
-
-        # Test all available tools
-        available_tools = [tool for tool in tools if tool.is_available()]
-        if available_tools:
-            print("=== Testing Available Tools ===")
-            for tool in available_tools:
-                result = tool.run({"question": "Hello!"})
-                if result.get("success"):
-                    print(f"✅ {tool.name}: {result['result'][:50]}...")
-                else:
-                    print(f"❌ {tool.name}: {result['error']}")
-
-    finally:
-        # Restore Gemini key
-        if original_gemini_key:
-            os.environ["GEMINI_API_KEY"] = original_gemini_key
-
-
-if __name__ == "__main__":
-    test_default_global_fallback()
-    test_custom_global_fallback()
-    test_disable_global_fallback()
-    test_explicit_fallback_priority()
-    test_multiple_tools_global_fallback()
-
-    print("\n=== Summary ===")
-    print("✅ Global fallback chain works as default")
-    print("✅ Custom global fallback chain from environment variable")
-    print("✅ Global fallback can be disabled per tool")
-    print("✅ Explicit fallback takes priority over global fallback")
-    print("✅ Multiple tools can use global fallback independently")
-    print("\n=== Configuration Options ===")
-    print("• use_global_fallback: true/false (default: true)")
-    print("• AGENTIC_TOOL_FALLBACK_CHAIN: JSON array of {api_type, model_id}")
-    print("• Explicit fallback_api_type/fallback_model_id takes priority")

tooluniverse/test/test_gwas_tool.py

@@ -1,139 +0,0 @@
-# test_gwas_tool.py
-
-from tooluniverse import ToolUniverse
-
-# Step 1: Initialize ToolUniverse and load all tools (including GWAS tools)
-tooluni = ToolUniverse()
-tooluni.load_tools()
-
-# Step 2: Define test queries for GWAS tools based on the examples
-test_queries = [
-    # Test basic association search (Question 1 from examples)
-    {
-        "name": "gwas_search_associations",
-        "arguments": {"efo_trait": "type 2 diabetes mellitus", "size": 10},
-    },
-    # Test study search (Question 2 from examples)
-    {
-        "name": "gwas_search_studies",
-        "arguments": {"disease_trait": "type 2 diabetes", "cohort": "UKB", "size": 20},
-    },
-    # Test SNP search (Question 3 from examples)
-    {
-        "name": "gwas_search_associations",
-        "arguments": {
-            "rs_id": "rs1050316",
-            "sort": "p_value",
-            "direction": "asc",
-            "size": 10,
-        },
-    },
-    # Test gene-based SNP search (Question 10 from examples)
-    {"name": "gwas_search_snps", "arguments": {"mapped_gene": "HBS1L", "size": 10}},
-    # Test specialized tools
-    {
-        "name": "gwas_get_variants_for_trait",
-        "arguments": {"efo_trait": "type 2 diabetes mellitus", "size": 5},
-    },
-    {
-        "name": "gwas_get_associations_for_trait",
-        "arguments": {"efo_trait": "type 2 diabetes mellitus", "size": 5},
-    },
-    {
-        "name": "gwas_get_associations_for_snp",
-        "arguments": {"rs_id": "rs1050316", "size": 5},
-    },
-    {
-        "name": "gwas_get_studies_for_trait",
-        "arguments": {"efo_trait": "type 2 diabetes mellitus", "size": 5},
-    },
-    {
-        "name": "gwas_get_snps_for_gene",
-        "arguments": {"mapped_gene": "HBS1L", "size": 5},
-    },
-    # Test get by ID tools
-    {"name": "gwas_get_study_by_id", "arguments": {"study_id": "GCST000001"}},
-    {"name": "gwas_get_snp_by_id", "arguments": {"rs_id": "rs429358"}},
-    # Test studies with summary statistics (Question 9 from examples)
-    {
-        "name": "gwas_get_studies_for_trait",
-        "arguments": {
-            "efo_trait": "type 2 diabetes mellitus",
-            "full_pvalue_set": True,
-            "size": 5,
-        },
-    },
-    # Test GxE studies (Question 11 from examples)
-    {
-        "name": "gwas_get_studies_for_trait",
-        "arguments": {
-            "efo_trait": "total blood protein measurement",
-            "gxe": True,
-            "size": 5,
-        },
-    },
-]
-
-
-def format_value(value, max_items=10, max_length=5000):
-    """Helper function to format output values"""
-    if isinstance(value, dict):
-        if "error" in value:
-            return f"ERROR: {value['error']}"
-
-        # Show the structure of the response
-        if "data" in value and "metadata" in value:
-            result = "Response Structure:\n"
-            result += f"  Data: {len(value['data'])} items\n"
-            if value["metadata"]:
-                result += f"  Metadata: {value['metadata']}\n"
-
-            # Show first few data items
-            if value["data"]:
-                result += f"\nFirst {min(max_items, len(value['data']))} data items:\n"
-                for i, item in enumerate(value["data"][:max_items]):
-                    item_str = str(item)
-                    if len(item_str) > max_length:
-                        item_str = item_str[:max_length] + "..."
-                    result += f"  [{i+1}] {item_str}\n"
-
-                if len(value["data"]) > max_items:
-                    result += f"  ... and {len(value['data']) - max_items} more items\n"
-
-            return result
-        else:
-            # Fallback for non-structured responses
-            dict_str = str(value)
-            return f"Dict ({len(dict_str)} chars): {dict_str[:max_length]}{'...' if len(dict_str) > max_length else ''}"
-    elif isinstance(value, list):
-        if not value:
-            return "Empty list"
-        items_to_show = value[:max_items]
-        items_str = "\n  - ".join(
-            [
-                str(item)[:max_length] + ("..." if len(str(item)) > max_length else "")
-                for item in items_to_show
-            ]
-        )
-        remaining = len(value) - max_items
-        return f"List with {len(value)} items:\n  - {items_str}" + (
-            f"\n  ... and {remaining} more items" if remaining > 0 else ""
-        )
-    elif isinstance(value, str):
-        return f"String ({len(value)} chars): {value[:max_length]}{'...' if len(value) > max_length else ''}"
-    else:
-        return f"Type: {type(value)}, Value: {value}"
-
-
-# Step 3: Run all test queries
-for idx, query in enumerate(test_queries, 1):
-    print(
-        f"\n{'='*80}\n[{idx}] Running tool: {query['name']} with arguments: {query['arguments']}"
-    )
-    try:
-        result = tooluni.run(query)
-        print("✅ Success. Output:")
-        print(format_value(result))
-    except (ImportError, AttributeError, KeyError, ValueError) as e:
-        print(f"❌ Failed. Error: {str(e)}")
-    print()