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

tooluniverse/test/list_azure_openai_models.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""
+List Azure OpenAI deployments (deployed models) for the current resource.
+
+Environment variables used:
+- AZURE_OPENAI_ENDPOINT (required)  e.g., https://<your-resource>.openai.azure.com
+- AZURE_OPENAI_API_KEY (required)
+- AZURE_OPENAI_API_VERSION (optional; default: 2024-12-01-preview)
+
+This script queries the Azure OpenAI data-plane deployments endpoint:
+  GET {endpoint}/openai/deployments?api-version={api_version}
+It also tries alternative paths and versions if the first attempt fails.
+If REST fails, it falls back to listing models via the SDK (client.models.list()).
+
+CLI options:
+  --rest-only       Only use REST
+  --sdk-only        Only use SDK fallback
+  --raw             Print raw JSON result for REST (when available)
+  --versions v1 v2  Override API versions to try (space-separated)
+"""
+
+import argparse
+import json
+import os
+import sys
+from typing import Any, Dict, List, Optional, Tuple
+
+import requests
+
+
+DEFAULT_VERSIONS = [
+    # Common recent versions
+    "2024-12-01-preview",
+    "2024-10-21",
+    # Add more if needed
+]
+
+
+def try_rest_once(
+    endpoint: str, api_key: str, api_version: str, path_variant: str
+) -> Tuple[Optional[List[Dict[str, Any]]], Optional[Dict[str, Any]], Optional[str]]:
+    url = endpoint.rstrip("/") + f"{path_variant}?api-version={api_version}"
+    headers = {"api-key": api_key, "Content-Type": "application/json"}
+    try:
+        resp = requests.get(url, headers=headers, timeout=15)
+        resp.raise_for_status()
+        data = resp.json()
+        items = data.get("data") or data.get("value") or []
+        deployments: List[Dict[str, Any]] = []
+        for item in items:
+            deployments.append(
+                {
+                    "id": item.get("id") or item.get("name"),
+                    "name": item.get("name") or item.get("id"),
+                    "model": (
+                        (item.get("model") or {}).get("name")
+                        if isinstance(item.get("model"), dict)
+                        else item.get("model")
+                    ),
+                    "model_format": item.get("model_format"),
+                    "created": item.get("created"),
+                    "status": item.get("status")
+                    or item.get("provisioningState")
+                    or item.get("provisioning_state"),
+                    "properties": item.get("properties"),
+                }
+            )
+        return deployments, data, None
+    except Exception as e:
+        return None, None, f"{e} (url: {url})"
+
+
+def list_deployments_via_rest(
+    endpoint: str, api_key: str, versions: List[str]
+) -> Tuple[List[Dict[str, Any]], Optional[Dict[str, Any]], List[str]]:
+    errors: List[str] = []
+    raw: Optional[Dict[str, Any]] = None
+    # Try two common path variants
+    path_variants = ["/openai/deployments", "/deployments"]
+    for v in versions:
+        for pv in path_variants:
+            deployments, raw_json, err = try_rest_once(endpoint, api_key, v, pv)
+            if deployments is not None:
+                raw = raw_json
+                return deployments, raw, errors
+            if err:
+                errors.append(f"{v} {pv}: {err}")
+    return [], raw, errors
+
+
+def list_models_via_sdk(
+    endpoint: str, api_key: str, api_version: str
+) -> List[Dict[str, Any]]:
+    try:
+        from openai import AzureOpenAI  # type: ignore
+    except Exception as e:  # pragma: no cover
+        raise RuntimeError("Failed to import openai AzureOpenAI client: %s" % e)
+
+    client = AzureOpenAI(
+        azure_endpoint=endpoint,
+        api_key=api_key,
+        api_version=api_version,
+    )
+    resp = client.models.list()
+    data = getattr(resp, "data", None) or []
+    models: List[Dict[str, Any]] = []
+    for m in data:
+        models.append(
+            {
+                "id": getattr(m, "id", None) or getattr(m, "root", None),
+                "owned_by": getattr(m, "owned_by", None),
+                "created": getattr(m, "created", None),
+            }
+        )
+    return models
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="List Azure OpenAI deployments/models")
+    parser.add_argument("--rest-only", action="store_true", help="Use REST only")
+    parser.add_argument("--sdk-only", action="store_true", help="Use SDK only")
+    parser.add_argument(
+        "--raw", action="store_true", help="Print raw JSON from REST when available"
+    )
+    parser.add_argument(
+        "--versions", nargs="*", help="API versions to try for REST (override)"
+    )
+    args = parser.parse_args()
+
+    endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
+    api_key = os.getenv("AZURE_OPENAI_API_KEY")
+    env_version = os.getenv("AZURE_OPENAI_API_VERSION")
+
+    if not endpoint or not api_key:
+        print("ERROR: Missing required environment variables.")
+        print(" - AZURE_OPENAI_ENDPOINT (current: %s)" % (endpoint or "<unset>"))
+        print(
+            " - AZURE_OPENAI_API_KEY (current: %s)"
+            % ("<set>" if api_key else "<unset>")
+        )
+        sys.exit(1)
+
+    versions = (
+        args.versions
+        if args.versions
+        else ([env_version] if env_version else DEFAULT_VERSIONS)
+    )
+
+    print("Listing Azure OpenAI deployments for resource:")
+    print(f" - Endpoint : {endpoint}")
+    print(f" - Versions : {', '.join([v for v in versions if v])}")
+    print()
+
+    deployments: List[Dict[str, Any]] = []
+    rest_errors: List[str] = []
+    raw: Optional[Dict[str, Any]] = None
+
+    if not args.sdk_only:
+        deployments, raw, rest_errors = list_deployments_via_rest(
+            endpoint, api_key, [v for v in versions if v]
+        )
+        if deployments:
+            print(f"Found {len(deployments)} deployment(s) via REST:")
+            for d in deployments:
+                print("- Deployment:")
+                print(f"    name   : {d.get('name')}")
+                print(f"    id     : {d.get('id')}")
+                print(f"    model  : {d.get('model')}")
+                print(f"    status : {d.get('status')}")
+            if args.raw and raw is not None:
+                print("\nRaw JSON (REST):")
+                print(json.dumps(raw, indent=2, ensure_ascii=False))
+            print(
+                "\nTip: Use the 'name' (deployment name) as model_id in your requests."
+            )
+            return
+        else:
+            print("No deployments found via REST or REST not available.")
+            if rest_errors:
+                print("\nREST attempt details (for debugging):")
+                for e in rest_errors[:5]:  # limit output
+                    print(" -", e)
+            print()
+
+    if not args.rest_only:
+        api_version_for_sdk = env_version or DEFAULT_VERSIONS[0]
+        try:
+            models = list_models_via_sdk(endpoint, api_key, api_version_for_sdk)
+            if models:
+                print(f"Found {len(models)} model(s) via SDK:")
+                for m in models[:200]:
+                    print("- Model (SDK):")
+                    print(f"    id      : {m.get('id')}")
+                    if m.get("owned_by") is not None:
+                        print(f"    owned_by: {m.get('owned_by')}")
+                    if m.get("created") is not None:
+                        print(f"    created : {m.get('created')}")
+                print()
+                print(
+                    "Note: SDK list may show global IDs; real calls require the deployment name."
+                )
+            else:
+                print("No models found via SDK either.")
+        except Exception as e:
+            print("ERROR: Unable to list models via SDK: %s" % e)
+            sys.exit(2)
+
+
+if __name__ == "__main__":
+    main()

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_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")