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

tooluniverse/test/test_global_fallback.py

@@ -0,0 +1,288 @@
+#!/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_hooks_direct.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+简化的 MCP stdio 模式 hooks 测试
+直接测试工具调用功能
+"""
+import subprocess
+import sys
+
+
+def test_tool_call_directly(hooks_enabled=False):
+    """直接测试工具调用"""
+    print(f"\n{'='*60}")
+    print(f"测试模式: {'开启 hooks' if hooks_enabled else '关闭 hooks'}")
+    print(f"{'='*60}")
+
+    # 构建命令
+    cmd = [
+        sys.executable,
+        "-c",
+        f"""
+import sys
+import time
+sys.path.insert(0, 'src')
+from tooluniverse.execute_function import ToolUniverse
+
+# 创建 ToolUniverse 实例
+tooluniverse = ToolUniverse()
+
+# 配置 hooks
+if {hooks_enabled}:
+    print("启用 hooks...")
+    tooluniverse.toggle_hooks(True)
+else:
+    print("禁用 hooks...")
+    tooluniverse.toggle_hooks(False)
+
+# 加载工具
+print("加载工具...")
+tooluniverse.load_tools()
+
+# 测试工具调用
+function_call = {{
+    "name": "OpenTargets_get_target_gene_ontology_by_ensemblID",
+    "arguments": {{"ensemblId": "ENSG00000012048"}}
+}}
+
+print("开始工具调用...")
+start_time = time.time()
+result = tooluniverse.run_one_function(function_call)
+end_time = time.time()
+
+response_time = end_time - start_time
+result_str = str(result)
+result_length = len(result_str)
+
+print(f"工具调用完成")
+print(f"响应时间: {{response_time:.2f}} 秒")
+print(f"响应长度: {{result_length}} 字符")
+print(f"响应类型: {{type(result)}}")
+
+# 检查是否是摘要
+if "summary" in result_str.lower() or "摘要" in result_str:
+    print("✅ 检测到摘要内容")
+else:
+    print("📄 原始内容（未摘要）")
+
+# 输出结果的前200个字符
+print(f"结果预览: {{result_str[:200]}}...")
+""",
+    ]
+
+    print(f"启动命令: {' '.join(cmd[:3])} ...")
+
+    # 启动进程
+    process = subprocess.Popen(
+        cmd,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        bufsize=0,
+    )
+
+    try:
+        # 等待执行完成
+        stdout, stderr = process.communicate(timeout=60)
+
+        print("标准输出:")
+        print(stdout)
+
+        if stderr:
+            print("标准错误:")
+            print(stderr)
+
+        # 解析结果
+        lines = stdout.split("\n")
+        response_time = None
+        result_length = None
+        is_summary = False
+
+        for line in lines:
+            if "响应时间:" in line:
+                try:
+                    response_time = float(line.split(":")[1].strip().split()[0])
+                except (ValueError, IndexError):
+                    pass
+            elif "响应长度:" in line:
+                try:
+                    result_length = int(line.split(":")[1].strip().split()[0])
+                except (ValueError, IndexError):
+                    pass
+            elif "检测到摘要内容" in line:
+                is_summary = True
+
+        return {
+            "hooks_enabled": hooks_enabled,
+            "response_time": response_time,
+            "result_length": result_length,
+            "is_summary": is_summary,
+            "success": process.returncode == 0,
+            "stdout": stdout,
+            "stderr": stderr,
+        }
+
+    except subprocess.TimeoutExpired:
+        print("❌ 测试超时")
+        process.kill()
+        return {
+            "hooks_enabled": hooks_enabled,
+            "response_time": None,
+            "result_length": None,
+            "is_summary": False,
+            "success": False,
+            "error": "超时",
+        }
+    except Exception as e:
+        print(f"❌ 测试失败: {e}")
+        return {
+            "hooks_enabled": hooks_enabled,
+            "response_time": None,
+            "result_length": None,
+            "is_summary": False,
+            "success": False,
+            "error": str(e),
+        }
+
+
+def main():
+    """主函数"""
+    print("MCP stdio 模式 hooks 直接测试")
+    print("测试工具: OpenTargets_get_target_gene_ontology_by_ensemblID")
+    print("测试参数: ensemblId=ENSG00000012048")
+
+    # 测试关闭 hooks
+    result_no_hooks = test_tool_call_directly(hooks_enabled=False)
+
+    # 测试开启 hooks
+    result_with_hooks = test_tool_call_directly(hooks_enabled=True)
+
+    # 对比结果
+    print(f"\n{'='*60}")
+    print("测试结果对比")
+    print(f"{'='*60}")
+
+    print("关闭 hooks:")
+    if result_no_hooks["success"]:
+        print(
+            f"  ✅ 成功 - 响应时间: {result_no_hooks['response_time']:.2f}s, 长度: {result_no_hooks['result_length']} 字符"
+        )
+        if result_no_hooks["is_summary"]:
+            print("  📄 检测到摘要内容")
+        else:
+            print("  📄 原始内容（未摘要）")
+    else:
+        print(f"  ❌ 失败 - {result_no_hooks.get('error', '未知错误')}")
+
+    print("开启 hooks:")
+    if result_with_hooks["success"]:
+        print(
+            f"  ✅ 成功 - 响应时间: {result_with_hooks['response_time']:.2f}s, 长度: {result_with_hooks['result_length']} 字符"
+        )
+        if result_with_hooks["is_summary"]:
+            print("  ✅ 检测到摘要内容")
+        else:
+            print("  📄 原始内容（未摘要）")
+    else:
+        print(f"  ❌ 失败 - {result_with_hooks.get('error', '未知错误')}")
+
+    # 性能对比
+    if result_no_hooks["success"] and result_with_hooks["success"]:
+        time_diff = (
+            result_with_hooks["response_time"] - result_no_hooks["response_time"]
+        )
+        length_diff = (
+            result_with_hooks["result_length"] - result_no_hooks["result_length"]
+        )
+
+        print("\n性能对比:")
+        print(
+            f"  时间差异: {time_diff:+.2f}s ({'hooks 更慢' if time_diff > 0 else 'hooks 更快'})"
+        )
+        print(
+            f"  长度差异: {length_diff:+d} 字符 ({'hooks 更长' if length_diff > 0 else 'hooks 更短'})"
+        )
+
+        if abs(time_diff) < 5.0:
+            print("  ✅ 时间差异在可接受范围内")
+        else:
+            print("  ⚠️ 时间差异较大，需要进一步优化")
+
+        # 检查 hooks 是否生效
+        if result_with_hooks["is_summary"] and not result_no_hooks["is_summary"]:
+            print("  ✅ Hooks 功能正常工作")
+        elif result_with_hooks["is_summary"] == result_no_hooks["is_summary"]:
+            print("  ⚠️ Hooks 功能可能未生效")
+
+
+if __name__ == "__main__":
+    main()

tooluniverse/test/test_list_built_in_tools.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""
+Basic test for list_built_in_tools including scan_all option.
+Run directly: python tests/test_list_built_in_tools.py
+"""
+
+from tooluniverse import ToolUniverse  # noqa: E402
+
+
+def main():
+    tu = ToolUniverse()
+
+    # Use predefined files (original behavior)
+    tool_names = tu.list_built_in_tools(mode="list_name", scan_all=False)
+    print(f"predefined tool names: {len(tool_names)}")
+
+    # Scan all JSON files
+    all_tool_names = tu.list_built_in_tools(mode="list_name", scan_all=True)
+    print(f"all tool names (scan_all): {len(all_tool_names)}")
+
+    # Get all tool specifications
+    all_tool_specs = tu.list_built_in_tools(mode="list_spec", scan_all=True)
+    print(f"all tool specs (scan_all): {len(all_tool_specs)}")
+
+    # Organize all tools by type
+    type_stats = tu.list_built_in_tools(mode="type", scan_all=True)
+    print(
+        f"type stats -> total_categories: {type_stats['total_categories']}, total_tools: {type_stats['total_tools']}"
+    )
+
+
+if __name__ == "__main__":
+    main()