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

tooluniverse/smcp_server.py

@@ -146,8 +146,8 @@ Examples:
   # Start with specific categories
   tooluniverse-stdio --categories uniprot ChEMBL opentarget
 
-  # Disable hooks
-  tooluniverse-stdio --no-hooks
+  # Enable hooks
+  tooluniverse-stdio --hooks
 
   # Use FileSaveHook instead of SummarizationHook
   tooluniverse-stdio --hook-type FileSaveHook
@@ -272,18 +272,17 @@ Examples:
         "--verbose", "-v", action="store_true", help="Enable verbose logging"
     )
 
-    # Hook configuration options (default enabled for stdio)
+    # Hook configuration options (default disabled for stdio)
     hook_group = parser.add_argument_group("Hook Configuration")
     hook_group.add_argument(
-        "--no-hooks",
+        "--hooks",
         action="store_true",
-        help="Disable output processing hooks (default: enabled for stdio)",
+        help="Enable output processing hooks (default: disabled for stdio)",
     )
     hook_group.add_argument(
         "--hook-type",
         choices=["SummarizationHook", "FileSaveHook"],
-        default="SummarizationHook",
-        help="Hook type to use (default: SummarizationHook)",
+        help="Hook type to use (default: SummarizationHook when hooks are enabled)",
     )
     hook_group.add_argument(
         "--hook-config-file",
@@ -493,16 +492,23 @@ Examples:
                 hook_config = json.load(f)
             print(f"🔗 Hook config loaded from: {args.hook_config_file}")
 
-        # Determine hook settings (default enabled for stdio)
-        hooks_enabled = not args.no_hooks
+        # Determine hook settings (default disabled for stdio)
+        hooks_enabled = (
+            args.hooks or args.hook_type is not None or hook_config is not None
+        )
+
+        # Set default hook type if hooks are enabled but no type specified
+        hook_type = args.hook_type
+        if hooks_enabled and hook_type is None:
+            hook_type = "SummarizationHook"
         if hooks_enabled:
-            if args.hook_type:
-                print(f"🔗 Hooks enabled: {args.hook_type}")
+            if hook_type:
+                print(f"🔗 Hooks enabled: {hook_type}")
             elif hook_config:
                 hook_count = len(hook_config.get("hooks", []))
                 print(f"🔗 Hooks enabled: {hook_count} custom hooks")
             else:
-                print(f"🔗 Hooks enabled: {args.hook_type} (default)")
+                print("🔗 Hooks enabled: default configuration")
         else:
             print("🔗 Hooks disabled")
 
@@ -525,7 +531,7 @@ Examples:
             stateless_http=True,  # Enable stateless mode for MCPAutoLoaderTool compatibility
             hooks_enabled=hooks_enabled,
             hook_config=hook_config,
-            hook_type=args.hook_type,
+            hook_type=hook_type,
         )
 
         # Run server with stdio transport (forced)

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()