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

tooluniverse/test/test_claude_sdk.py

@@ -0,0 +1,93 @@
+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_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"])
+
+

tooluniverse/test/test_stdio_hooks.py

@@ -50,7 +50,7 @@ run_stdio_server()
             if not line:
                 break
             print(f"启动日志: {line.strip()}")
-            if "Starting SMCP ToolUniverse Server" in line:
+            if "Starting ToolUniverse SMCP Server" in line:
                 break
 
         # 发送初始化请求

tooluniverse/test/test_tool_finder.py

@@ -14,7 +14,7 @@ test_queries = [
             "return_call_result": False,
         },
     },
-    {"name": "Tool_Finder_Keyword", "arguments": {"query": "disease", "limit": 5}},
+    {"name": "Tool_Finder_Keyword", "arguments": {"description": "disease", "limit": 5}},
 ]
 
 for idx, query in enumerate(test_queries):

tooluniverse/unpaywall_tool.py

@@ -0,0 +1,63 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("UnpaywallTool")
+class UnpaywallTool(BaseTool):
+    """
+    Query Unpaywall by DOI to check open-access status and OA locations.
+    Requires a contact email.
+    """
+
+    def __init__(self, tool_config, base_url="https://api.unpaywall.org/v2/"):
+        super().__init__(tool_config)
+        self.base_url = base_url.rstrip("/") + "/"
+
+    def run(self, arguments):
+        doi = arguments.get("doi")
+        email = arguments.get("email")  # required by Unpaywall
+        if not doi:
+            return {"error": "`doi` parameter is required."}
+        if not email:
+            return {"error": "`email` parameter is required for Unpaywall."}
+        return self._lookup(doi, email)
+
+    def _lookup(self, doi, email):
+        url = f"{self.base_url}{doi}"
+        params = {"email": email}
+        try:
+            response = requests.get(
+                url,
+                params=params,
+                timeout=20,
+            )
+        except requests.RequestException as e:
+            return {
+                "error": "Network error calling Unpaywall API",
+                "reason": str(e),
+            }
+
+        if response.status_code != 200:
+            return {
+                "error": f"Unpaywall API error {response.status_code}",
+                "reason": response.reason,
+            }
+
+        data = response.json()
+        result = {
+            "is_oa": data.get("is_oa"),
+            "oa_status": data.get("oa_status"),
+            "best_oa_location": data.get("best_oa_location"),
+            "oa_locations": data.get("oa_locations"),
+            "journal_is_oa": data.get("journal_is_oa"),
+            "journal_issn_l": data.get("journal_issn_l"),
+            "journal_issns": data.get("journal_issns"),
+            "doi": data.get("doi"),
+            "title": data.get("title"),
+            "year": data.get("year"),
+            "publisher": data.get("publisher"),
+            "url": data.get("url"),
+        }
+        return result
+