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

tooluniverse/test/test_agentic_tool_azure_models.py

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

tooluniverse/test/test_api_key_validation_min.py

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

tooluniverse/test/test_claude_sdk.py

@@ -0,0 +1,86 @@
+import asyncio
+
+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
+    """
+    import os
+    cwd = os.getcwd()
+
+    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": "tooluniverse-smcp-stdio",
+                    "args": [],
+                    "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_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")