tooluniverse 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

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_odphp_tool.py

@@ -0,0 +1,166 @@
+import json
+import os
+from tooluniverse import ToolUniverse
+import pytest
+
+schema_path = os.path.join(os.path.dirname(__file__), "..", "data", "odphp_tools.json")
+with open(schema_path) as f:
+    schemas = {tool["name"]: tool["return_schema"] for tool in json.load(f)}
+
+tooluni = ToolUniverse()
+tooluni.load_tools()
+
+
+def summarize_result(tool_name, res):
+    if isinstance(res, str):
+        return f"{tool_name}: INVALID Raw string response: {res[:200]}..."
+    if isinstance(res, dict):
+        if "error" in res:
+            return f"{tool_name}: ERROR {res['error']}"
+        data = res.get("data", {})
+        total = data.get("Total") if isinstance(data, dict) else None
+        msg = f"{tool_name}: SUCCESS"
+        if isinstance(total, int):
+            msg += f" | Total={total}"
+
+        if tool_name == "odphp_myhealthfinder":
+            heading = data.get("MyHFHeading", "")
+            resources = (data.get("Resources", {}).get("All", {}).get("Resource", [])) or []
+            first_title = resources[0].get("Title") if resources else None
+            msg += f" | Heading='{heading[:60]}...'"
+            if first_title:
+                msg += f" | FirstResource='{first_title}'"
+            callouts = (data.get("Callouts", {}).get("All", {}).get("Resource", [])) or []
+            if callouts and callouts[0].get("MyHFTitle"):
+                msg += f" | FirstCallout='{callouts[0].get('MyHFTitle')}'"
+
+        elif tool_name == "odphp_itemlist":
+            items = data.get("Items", {}).get("Item", []) or []
+            titles = [i.get("Title") for i in items[:3]]
+            if titles:
+                msg += f" | ExampleItems={titles}"
+
+        elif tool_name == "odphp_topicsearch":
+            resources = data.get("Resources", {}).get("Resource", []) or []
+            titles = [r.get("Title") for r in resources[:3]]
+            if titles:
+                msg += f" | ExampleTopics={titles}"
+
+        elif tool_name.startswith("odphp_outlink_fetch"):
+            results = res.get("results") or []
+            if results:
+                first = results[0]
+                msg += f" | url={first.get('url')} status={first.get('status')} type={first.get('content_type')}"
+                if first.get("title"):
+                    msg += f" | Title='{first['title'][:50]}...'"
+                if first.get("text"):
+                    snippet = first["text"][:80].replace("\n", " ")
+                    msg += f" | TextSnippet='{snippet}...'"
+
+        expected_keys = schemas.get(tool_name, {}).get("properties", {}).keys()
+        missing = [k for k in expected_keys if k not in data and k not in res]
+        if missing:
+            msg += f" | WARNING: Missing keys {missing}"
+        else:
+            msg += " | Schema OK"
+        return msg
+    return f"{tool_name}: INVALID Unexpected type {type(res)}"
+
+
+def test_01_myhealthfinder_valid():
+    res = tooluni.run({"name": "odphp_myhealthfinder",
+                       "arguments": {"age": 35, "sex": "female", "pregnant": "no", "lang": "en"}})
+    print(summarize_result("odphp_myhealthfinder", res))
+    assert isinstance(res, dict) and not res.get("error")
+
+
+def test_02_itemlist_valid():
+    res = tooluni.run({"name": "odphp_itemlist", "arguments": {"type": "topic", "lang": "en"}})
+    print(summarize_result("odphp_itemlist", res))
+    assert isinstance(res, dict) and not res.get("error")
+
+
+def test_03_topicsearch_keyword_valid():
+    res = tooluni.run({"name": "odphp_topicsearch", "arguments": {"keyword": "cancer", "lang": "en"}})
+    print(summarize_result("odphp_topicsearch", res))
+    assert isinstance(res, dict) and not res.get("error")
+
+
+def test_04_invalid_types_fail_fast():
+    r1 = tooluni.run({"name": "odphp_myhealthfinder", "arguments": {"age": "banana"}})
+    r2 = tooluni.run({"name": "odphp_topicsearch", "arguments": {"topicId": 123}})
+    print("Expected type errors:", r1, r2)
+    assert isinstance(r1, str) and "Type mismatches" in r1
+    assert isinstance(r2, str) and "Type mismatches" in r2
+
+
+def test_05_sections_case_and_strip_html():
+    res = tooluni.run({"name": "odphp_topicsearch",
+                       "arguments": {"keyword": "Keep Your Heart Healthy", "lang": "en", "strip_html": True}})
+    print(summarize_result("odphp_topicsearch", res))
+    assert isinstance(res, dict) and not res.get("error")
+    data = res.get("data") or {}
+    resources = (data.get("Resources") or {}).get("Resource") or []
+    if resources:
+        s_any = resources[0].get("Sections", {})
+        arr = s_any.get("Section") or s_any.get("section") or []
+        assert isinstance(arr, list)
+        assert "PlainSections" in resources[0]
+
+
+def test_06_outlink_fetch_accessible_version():
+    url = "https://odphp.health.gov/myhealthfinder/health-conditions/heart-health/keep-your-heart-healthy"
+    res = tooluni.run({"name": "odphp_outlink_fetch",
+                       "arguments": {"urls": [url], "max_chars": 4000}})
+    print(summarize_result("odphp_outlink_fetch", res))
+    assert isinstance(res, dict) and not res.get("error")
+    results = res.get("results") or []
+    assert results and results[0].get("status") in (200, 301, 302)
+    if "text/html" in (results[0].get("content_type") or ""):
+        assert len(results[0].get("text", "")) > 100
+
+
+def test_07_itemlist_spanish():
+    res = tooluni.run({"name": "odphp_itemlist", "arguments": {"type": "topic", "lang": "es"}})
+    print(summarize_result("odphp_itemlist", res))
+    assert isinstance(res, dict) and not res.get("error")
+
+
+def test_08_topicsearch_by_category():
+    cats = tooluni.run({"name": "odphp_itemlist", "arguments": {"type": "category", "lang": "en"}})
+    first_cat = (cats.get("data", {}).get("Items", {}).get("Item") or [])[0]
+    cid = first_cat.get("Id")
+    res = tooluni.run({"name": "odphp_topicsearch", "arguments": {"categoryId": cid, "lang": "en"}})
+    print(summarize_result("odphp_topicsearch", res))
+    assert isinstance(res, dict) and not res.get("error")
+
+def test_09_outlink_fetch_pdf():
+    url = "https://odphp.health.gov/sites/default/files/2021-12/DGA_Pregnancy_FactSheet-508.pdf"
+    res = tooluni.run({"name": "odphp_outlink_fetch",
+                       "arguments": {"urls": [url], "max_chars": 1000}})
+    print(summarize_result("odphp_outlink_fetch_pdf", res))
+
+    assert isinstance(res, dict) and not res.get("error")
+    results = res.get("results") or []
+    assert results, "No results returned for PDF URL"
+
+    ctype = results[0].get("content_type", "")
+    assert ctype.startswith("application/pdf"), f"Expected PDF but got {ctype}"
+
+    # Ensure text extraction worked at least partially
+    text = results[0].get("text", "")
+    assert text and len(text) > 50, "Extracted PDF text too short"
+
+
+if __name__ == "__main__":
+    print("\nRunning ODPHP tool tests...\n")
+    test_01_myhealthfinder_valid()
+    test_02_itemlist_valid()
+    test_03_topicsearch_keyword_valid()
+    test_04_invalid_types_fail_fast()
+    test_05_sections_case_and_strip_html()
+    test_06_outlink_fetch_accessible_version()
+    test_07_itemlist_spanish()
+    test_08_topicsearch_by_category()
+    test_09_outlink_fetch_pdf()
+    print("\nAll ODPHP tests executed.\n")

tooluniverse/test/test_openrouter_client.py

@@ -0,0 +1,288 @@
+"""
+Tests for OpenRouter client integration.
+
+These tests verify that the OpenRouter client is properly integrated
+with the ToolUniverse system.
+"""
+
+import os
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+from tooluniverse.llm_clients import OpenRouterClient
+from tooluniverse.agentic_tool import AgenticTool
+
+
+class TestOpenRouterClient:
+    """Test suite for OpenRouterClient."""
+
+    def test_client_initialization_without_api_key(self):
+        """Test that client raises error when API key is not set."""
+        # Remove API key if present
+        old_key = os.environ.pop("OPENROUTER_API_KEY", None)
+        
+        try:
+            with pytest.raises(ValueError, match="OPENROUTER_API_KEY not set"):
+                logger = Mock()
+                OpenRouterClient("openai/gpt-4o", logger)
+        finally:
+            # Restore old key if it existed
+            if old_key:
+                os.environ["OPENROUTER_API_KEY"] = old_key
+
+    @patch.dict(os.environ, {"OPENROUTER_API_KEY": "test_key"})
+    @patch("tooluniverse.llm_clients.OpenRouterClient._OpenAI")
+    def test_client_initialization_with_api_key(self, mock_openai_class):
+        """Test that client initializes correctly with API key."""
+        logger = Mock()
+        mock_client = Mock()
+        mock_openai_class.return_value = mock_client
+        
+        client = OpenRouterClient("openai/gpt-4o", logger)
+        
+        assert client.model_name == "openai/gpt-4o"
+        assert client.logger == logger
+        mock_openai_class.assert_called_once()
+        
+        # Verify base_url and api_key
+        call_kwargs = mock_openai_class.call_args[1]
+        assert call_kwargs["base_url"] == "https://openrouter.ai/api/v1"
+        assert call_kwargs["api_key"] == "test_key"
+
+    @patch.dict(
+        os.environ,
+        {
+            "OPENROUTER_API_KEY": "test_key",
+            "OPENROUTER_SITE_URL": "https://example.com",
+            "OPENROUTER_SITE_NAME": "Test App"
+        }
+    )
+    @patch("tooluniverse.llm_clients.OpenRouterClient._OpenAI")
+    def test_client_with_optional_headers(self, mock_openai_class):
+        """Test that optional headers are set correctly."""
+        logger = Mock()
+        mock_client = Mock()
+        mock_openai_class.return_value = mock_client
+        
+        client = OpenRouterClient("openai/gpt-4o", logger)
+        
+        call_kwargs = mock_openai_class.call_args[1]
+        assert "default_headers" in call_kwargs
+        headers = call_kwargs["default_headers"]
+        assert headers["HTTP-Referer"] == "https://example.com"
+        assert headers["X-Title"] == "Test App"
+
+    @patch.dict(os.environ, {"OPENROUTER_API_KEY": "test_key"})
+    @patch("tooluniverse.llm_clients.OpenRouterClient._OpenAI")
+    def test_resolve_default_max_tokens(self, mock_openai_class):
+        """Test max tokens resolution for known models."""
+        logger = Mock()
+        mock_client = Mock()
+        mock_openai_class.return_value = mock_client
+        
+        client = OpenRouterClient("openai/gpt-4o", logger)
+        
+        # Test known model
+        max_tokens = client._resolve_default_max_tokens("openai/gpt-4o")
+        assert max_tokens == 64000
+        
+        # Test another known model
+        max_tokens = client._resolve_default_max_tokens("anthropic/claude-3.5-sonnet")
+        assert max_tokens == 8192
+        
+        # Test unknown model
+        max_tokens = client._resolve_default_max_tokens("unknown/model")
+        assert max_tokens is None
+
+    @patch.dict(os.environ, {"OPENROUTER_API_KEY": "test_key"})
+    @patch("tooluniverse.llm_clients.OpenRouterClient._OpenAI")
+    def test_infer_basic(self, mock_openai_class):
+        """Test basic inference functionality."""
+        logger = Mock()
+        mock_client = Mock()
+        mock_openai_class.return_value = mock_client
+        
+        # Mock the completion response
+        mock_response = Mock()
+        mock_response.choices = [Mock()]
+        mock_response.choices[0].message.content = "Test response"
+        mock_client.chat.completions.create.return_value = mock_response
+        
+        client = OpenRouterClient("openai/gpt-4o", logger)
+        
+        messages = [{"role": "user", "content": "Test prompt"}]
+        result = client.infer(
+            messages=messages,
+            temperature=0.7,
+            max_tokens=100,
+            return_json=False
+        )
+        
+        assert result == "Test response"
+        mock_client.chat.completions.create.assert_called_once()
+        
+        # Verify call arguments
+        call_kwargs = mock_client.chat.completions.create.call_args[1]
+        assert call_kwargs["model"] == "openai/gpt-4o"
+        assert call_kwargs["messages"] == messages
+        assert call_kwargs["temperature"] == 0.7
+        assert call_kwargs["max_tokens"] == 100
+
+
+class TestAgenticToolWithOpenRouter:
+    """Test AgenticTool integration with OpenRouter."""
+
+    @patch.dict(os.environ, {"OPENROUTER_API_KEY": "test_key"})
+    @patch("tooluniverse.agentic_tool.OpenRouterClient")
+    def test_agentic_tool_with_openrouter(self, mock_client_class):
+        """Test that AgenticTool can use OpenRouter."""
+        # Mock the client
+        mock_client = Mock()
+        mock_client_class.return_value = mock_client
+        mock_client.test_api = Mock()
+        mock_client.infer = Mock(return_value="Test result")
+        
+        # Create tool config
+        tool_config = {
+            "name": "Test_Tool",
+            "prompt": "Test prompt: {input}",
+            "input_arguments": ["input"],
+            "parameter": {
+                "type": "object",
+                "properties": {
+                    "input": {"type": "string", "required": True}
+                },
+                "required": ["input"]
+            },
+            "configs": {
+                "api_type": "OPENROUTER",
+                "model_id": "openai/gpt-4o",
+                "temperature": 0.5,
+                "validate_api_key": True,
+                "return_metadata": False
+            }
+        }
+        
+        # Create tool
+        tool = AgenticTool(tool_config)
+        
+        # Verify initialization
+        assert tool._is_available
+        assert tool._current_api_type == "OPENROUTER"
+        assert tool._current_model_id == "openai/gpt-4o"
+        mock_client.test_api.assert_called_once()
+        
+        # Test execution
+        result = tool.run({"input": "test data"})
+        assert result == "Test result"
+        mock_client.infer.assert_called_once()
+
+    def test_openrouter_in_supported_types(self):
+        """Test that OPENROUTER is in supported API types."""
+        tool_config = {
+            "name": "Test_Tool",
+            "prompt": "Test: {x}",
+            "input_arguments": ["x"],
+            "parameter": {
+                "type": "object",
+                "properties": {"x": {"type": "string"}},
+                "required": ["x"]
+            },
+            "configs": {
+                "api_type": "OPENROUTER",
+                "model_id": "openai/gpt-4o",
+                "validate_api_key": False
+            }
+        }
+        
+        # This should not raise an error
+        try:
+            tool = AgenticTool(tool_config)
+            # Validation should pass
+            validation = tool.validate_configuration()
+            assert validation["valid"]
+        except ValueError as e:
+            if "Unsupported API type" in str(e):
+                pytest.fail("OPENROUTER should be a supported API type")
+
+
+class TestOpenRouterModels:
+    """Test model configuration and limits."""
+
+    @patch.dict(os.environ, {"OPENROUTER_API_KEY": "test_key"})
+    @patch("tooluniverse.llm_clients.OpenRouterClient._OpenAI")
+    def test_model_limits_configuration(self, mock_openai_class):
+        """Test that model limits are correctly configured."""
+        logger = Mock()
+        mock_client = Mock()
+        mock_openai_class.return_value = mock_client
+        
+        client = OpenRouterClient("openai/gpt-4o", logger)
+        
+        # Check some key models
+        expected_models = {
+            "openai/gpt-4o": {"max_output": 64000, "context_window": 1_048_576},
+            "anthropic/claude-3.7-sonnet": {"max_output": 8192, "context_window": 200_000},
+            "google/gemini-2.0-flash-exp": {"max_output": 8192, "context_window": 1_048_576},
+            "qwen/qwq-32b-preview": {"max_output": 8192, "context_window": 32_768},
+        }
+        
+        for model_id, expected_limits in expected_models.items():
+            assert model_id in client.DEFAULT_MODEL_LIMITS
+            assert client.DEFAULT_MODEL_LIMITS[model_id] == expected_limits
+
+    @patch.dict(
+        os.environ,
+        {
+            "OPENROUTER_API_KEY": "test_key",
+            "OPENROUTER_MAX_TOKENS_BY_MODEL": '{"openai/gpt-4o": 32000}'
+        }
+    )
+    @patch("tooluniverse.llm_clients.OpenRouterClient._OpenAI")
+    def test_env_override_max_tokens(self, mock_openai_class):
+        """Test that environment variables can override max tokens."""
+        logger = Mock()
+        mock_client = Mock()
+        mock_openai_class.return_value = mock_client
+        
+        client = OpenRouterClient("openai/gpt-4o", logger)
+        
+        # Should return the overridden value
+        max_tokens = client._resolve_default_max_tokens("openai/gpt-4o")
+        assert max_tokens == 32000
+
+
+class TestOpenRouterFallback:
+    """Test fallback configuration with OpenRouter."""
+
+    def test_openrouter_in_default_fallback_chain(self):
+        """Test that OpenRouter is in the default fallback chain."""
+        from tooluniverse.agentic_tool import DEFAULT_FALLBACK_CHAIN
+        
+        # Check that OPENROUTER is in the default chain
+        openrouter_configs = [
+            config for config in DEFAULT_FALLBACK_CHAIN
+            if config["api_type"] == "OPENROUTER"
+        ]
+        
+        assert len(openrouter_configs) > 0, "OPENROUTER should be in default fallback chain"
+        
+        # Verify it has a model_id
+        for config in openrouter_configs:
+            assert "model_id" in config
+            assert config["model_id"].startswith("openai/") or \
+                   config["model_id"].startswith("anthropic/") or \
+                   config["model_id"].startswith("google/") or \
+                   config["model_id"].startswith("qwen/")
+
+    def test_openrouter_in_api_key_env_vars(self):
+        """Test that OPENROUTER is in API key environment variables mapping."""
+        from tooluniverse.agentic_tool import API_KEY_ENV_VARS
+        
+        assert "OPENROUTER" in API_KEY_ENV_VARS
+        assert "OPENROUTER_API_KEY" in API_KEY_ENV_VARS["OPENROUTER"]
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])
+
+