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

tooluniverse/smcp.py

@@ -1389,7 +1389,7 @@ class SMCP(FastMCP):
                 self.tool_finder_available = True
                 self.tool_finder_type = "Tool_Finder_LLM"
                 self.logger.info(
-                    "✅ Tool_Finder_LLM (cost-optimized) available for advanced search"
+                    "✅ Tool_Finder_LLM available for advanced search"
                 )
                 return
 
@@ -1879,6 +1879,91 @@ class SMCP(FastMCP):
         except Exception:
             pass
 
+    def _print_tooluniverse_banner(self):
+        """Print ToolUniverse branding banner after FastMCP banner with dynamic information."""
+        # Get transport info if available
+        transport_display = getattr(self, '_transport_type', 'Unknown')
+        server_url = getattr(self, '_server_url', 'N/A')
+        tools_count = len(self._exposed_tools)
+        
+        # Map transport types to display names
+        transport_map = {
+            'stdio': 'STDIO',
+            'streamable-http': 'Streamable-HTTP',
+            'http': 'HTTP',
+            'sse': 'SSE'
+        }
+        transport_name = transport_map.get(transport_display, transport_display)
+        
+        # Format lines with proper alignment (matching FastMCP style)
+        # Each line should be exactly 75 characters (emoji takes 2 display widths but counts as 1 in len())
+        transport_line = f"                 📦 Transport:       {transport_name}"
+        server_line = f"                 🔗 Server URL:      {server_url}"
+        tools_line = f"                 🧰 Loaded Tools:    {tools_count}"
+        
+        # Pad to exactly 75 characters (emoji counts as 1 in len() but displays as 2)
+        transport_line = transport_line + " " * (75 - len(transport_line))
+        server_line = server_line + " " * (75 - len(server_line))
+        tools_line = tools_line + " " * (75 - len(tools_line))
+        
+        banner = f"""
+╭────────────────────────────────────────────────────────────────────────────╮
+│                                                                            │
+│                         🧬 ToolUniverse SMCP Server 🧬                     │
+│                                                                            │
+│            Bridging AI Agents with Scientific Computing Tools              │
+│                                                                            │
+│{transport_line}│
+│{server_line}│
+│{tools_line}│
+│                                                                            │
+│                 🌐 Website:  https://aiscientist.tools/                    │
+│                 💻 GitHub:   https://github.com/mims-harvard/ToolUniverse  │
+│                                                                            │
+╰────────────────────────────────────────────────────────────────────────────╯
+"""
+        print(banner)
+
+    def run(self, *args, **kwargs):
+        """
+        Override run method to display ToolUniverse banner after FastMCP banner.
+        
+        This method intercepts the parent's run() call to inject our custom banner
+        immediately after FastMCP displays its startup banner.
+        """
+        # Save transport information for banner display
+        transport = kwargs.get('transport', args[0] if args else 'unknown')
+        host = kwargs.get('host', '0.0.0.0')
+        port = kwargs.get('port', 7000)
+        
+        self._transport_type = transport
+        
+        # Build server URL based on transport
+        if transport == 'streamable-http' or transport == 'http':
+            self._server_url = f"http://{host}:{port}/mcp"
+        elif transport == 'sse':
+            self._server_url = f"http://{host}:{port}"
+        else:
+            self._server_url = "N/A (stdio mode)"
+        
+        # Use threading to print our banner shortly after FastMCP's banner
+        import threading
+        import time
+        
+        def delayed_banner():
+            """Print ToolUniverse banner with a small delay to appear after FastMCP banner."""
+            time.sleep(1.0)  # Delay to ensure FastMCP banner displays first
+            self._print_tooluniverse_banner()
+        
+        # Start banner thread only on first run
+        if not hasattr(self, '_tooluniverse_banner_shown'):
+            self._tooluniverse_banner_shown = True
+            banner_thread = threading.Thread(target=delayed_banner, daemon=True)
+            banner_thread.start()
+        
+        # Call parent's run method (blocking call)
+        return super().run(*args, **kwargs)
+
     def run_simple(
         self,
         transport: Literal["stdio", "http", "sse"] = "http",
@@ -2085,120 +2170,127 @@ class SMCP(FastMCP):
             func_params = []
             param_annotations = {}
 
-            for param_name, param_info in properties.items():
-                param_type = param_info.get("type", "string")
-                param_description = param_info.get(
-                    "description", f"{param_name} parameter"
-                )
-                is_required = param_name in required_params
-
-                # Map JSON schema types to Python types and create appropriate Field
-                field_kwargs = {"description": param_description}
-
-                if param_type == "string":
-                    python_type = str
-                    # For string type, don't add json_schema_extra - let Pydantic handle it
-                elif param_type == "integer":
-                    python_type = int
-                    # For integer type, don't add json_schema_extra - let Pydantic handle it
-                elif param_type == "number":
-                    python_type = float
-                    # For number type, don't add json_schema_extra - let Pydantic handle it
-                elif param_type == "boolean":
-                    python_type = bool
-                    # For boolean type, don't add json_schema_extra - let Pydantic handle it
-                elif param_type == "array":
-                    python_type = list
-                    # Add array-specific schema information only for complex cases
-                    items_info = param_info.get("items", {})
-                    if items_info:
-                        # Clean up items definition - remove invalid fields
-                        cleaned_items = items_info.copy()
-
-                        # Remove 'required' field from items (not valid in JSON Schema for array items)
-                        if "required" in cleaned_items:
-                            cleaned_items.pop("required")
-
-                        field_kwargs["json_schema_extra"] = {
-                            "type": "array",
-                            "items": cleaned_items,
-                        }
+            # Process parameters in two phases: required first, then optional
+            # This ensures Python function signature validity (no default args before non-default)
+            for is_required_phase in [True, False]:
+                for param_name, param_info in properties.items():
+                    param_type = param_info.get("type", "string")
+                    param_description = param_info.get(
+                        "description", f"{param_name} parameter"
+                    )
+                    is_required = param_name in required_params
+
+                    # Skip if not in current phase
+                    if is_required != is_required_phase:
+                        continue
+
+                    # Map JSON schema types to Python types and create appropriate Field
+                    field_kwargs = {"description": param_description}
+
+                    if param_type == "string":
+                        python_type = str
+                        # For string type, don't add json_schema_extra - let Pydantic handle it
+                    elif param_type == "integer":
+                        python_type = int
+                        # For integer type, don't add json_schema_extra - let Pydantic handle it
+                    elif param_type == "number":
+                        python_type = float
+                        # For number type, don't add json_schema_extra - let Pydantic handle it
+                    elif param_type == "boolean":
+                        python_type = bool
+                        # For boolean type, don't add json_schema_extra - let Pydantic handle it
+                    elif param_type == "array":
+                        python_type = list
+                        # Add array-specific schema information only for complex cases
+                        items_info = param_info.get("items", {})
+                        if items_info:
+                            # Clean up items definition - remove invalid fields
+                            cleaned_items = items_info.copy()
+
+                            # Remove 'required' field from items (not valid in JSON Schema for array items)
+                            if "required" in cleaned_items:
+                                cleaned_items.pop("required")
+
+                            field_kwargs["json_schema_extra"] = {
+                                "type": "array",
+                                "items": cleaned_items,
+                            }
+                        else:
+                            # If no items specified, default to string items
+                            field_kwargs["json_schema_extra"] = {
+                                "type": "array",
+                                "items": {"type": "string"},
+                            }
+                    elif param_type == "object":
+                        python_type = dict
+                        # Add object-specific schema information
+                        object_props = param_info.get("properties", {})
+                        if object_props:
+                            # Clean up the nested object properties - fix common schema issues
+                            cleaned_props = {}
+                            nested_required = []
+
+                            for prop_name, prop_info in object_props.items():
+                                cleaned_prop = prop_info.copy()
+
+                                # Fix string "True"/"False" in required field (common ToolUniverse issue)
+                                if "required" in cleaned_prop:
+                                    req_value = cleaned_prop.pop("required")
+                                    if req_value in ["True", "true", True]:
+                                        nested_required.append(prop_name)
+                                    # Remove the individual required field as it should be at object level
+
+                                cleaned_props[prop_name] = cleaned_prop
+
+                            # Create proper JSON schema for nested object
+                            object_schema = {"type": "object", "properties": cleaned_props}
+
+                            # Add required array at object level if there are required fields
+                            if nested_required:
+                                object_schema["required"] = nested_required
+
+                            field_kwargs["json_schema_extra"] = object_schema
                     else:
-                        # If no items specified, default to string items
-                        field_kwargs["json_schema_extra"] = {
-                            "type": "array",
-                            "items": {"type": "string"},
-                        }
-                elif param_type == "object":
-                    python_type = dict
-                    # Add object-specific schema information
-                    object_props = param_info.get("properties", {})
-                    if object_props:
-                        # Clean up the nested object properties - fix common schema issues
-                        cleaned_props = {}
-                        nested_required = []
-
-                        for prop_name, prop_info in object_props.items():
-                            cleaned_prop = prop_info.copy()
-
-                            # Fix string "True"/"False" in required field (common ToolUniverse issue)
-                            if "required" in cleaned_prop:
-                                req_value = cleaned_prop.pop("required")
-                                if req_value in ["True", "true", True]:
-                                    nested_required.append(prop_name)
-                                # Remove the individual required field as it should be at object level
-
-                            cleaned_props[prop_name] = cleaned_prop
-
-                        # Create proper JSON schema for nested object
-                        object_schema = {"type": "object", "properties": cleaned_props}
-
-                        # Add required array at object level if there are required fields
-                        if nested_required:
-                            object_schema["required"] = nested_required
-
-                        field_kwargs["json_schema_extra"] = object_schema
-                else:
-                    # For unknown types, default to string and only add type info if it's truly unknown
-                    python_type = str
-                    if param_type not in [
-                        "string",
-                        "integer",
-                        "number",
-                        "boolean",
-                        "array",
-                        "object",
-                    ]:
-                        field_kwargs["json_schema_extra"] = {"type": param_type}
-
-                # Create Pydantic Field with enhanced schema information
-                pydantic_field = Field(**field_kwargs)
-
-                if is_required:
-                    # Required parameter with description and schema info
-                    annotated_type = Annotated[python_type, pydantic_field]
-                    param_annotations[param_name] = annotated_type
-                    func_params.append(
-                        inspect.Parameter(
-                            param_name,
-                            inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                            annotation=annotated_type,
+                        # For unknown types, default to string and only add type info if it's truly unknown
+                        python_type = str
+                        if param_type not in [
+                            "string",
+                            "integer",
+                            "number",
+                            "boolean",
+                            "array",
+                            "object",
+                        ]:
+                            field_kwargs["json_schema_extra"] = {"type": param_type}
+
+                    # Create Pydantic Field with enhanced schema information
+                    pydantic_field = Field(**field_kwargs)
+
+                    if is_required:
+                        # Required parameter with description and schema info
+                        annotated_type = Annotated[python_type, pydantic_field]
+                        param_annotations[param_name] = annotated_type
+                        func_params.append(
+                            inspect.Parameter(
+                                param_name,
+                                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                                annotation=annotated_type,
+                            )
                         )
-                    )
-                else:
-                    # Optional parameter with description, schema info and default value
-                    annotated_type = Annotated[
-                        Union[python_type, type(None)], pydantic_field
-                    ]
-                    param_annotations[param_name] = annotated_type
-                    func_params.append(
-                        inspect.Parameter(
-                            param_name,
-                            inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                            default=None,
-                            annotation=annotated_type,
+                    else:
+                        # Optional parameter with description, schema info and default value
+                        annotated_type = Annotated[
+                            Union[python_type, type(None)], pydantic_field
+                        ]
+                        param_annotations[param_name] = annotated_type
+                        func_params.append(
+                            inspect.Parameter(
+                                param_name,
+                                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                                default=None,
+                                annotation=annotated_type,
+                            )
                         )
-                    )
 
             # Create the async function with dynamic signature
             if not properties:

tooluniverse/smcp_server.py

@@ -111,7 +111,6 @@ Examples:
             auto_expose_tools=True,
             search_enabled=True,
             max_workers=5,
-            stateless_http=True,  # Enable stateless mode for MCPAutoLoaderTool compatibility
             hooks_enabled=hooks_enabled,
             hook_config=hook_config,
             hook_type=args.hook_type,
@@ -146,8 +145,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
@@ -254,8 +253,8 @@ Examples:
     # Server configuration (stdio-specific)
     parser.add_argument(
         "--name",
-        default="SMCP ToolUniverse Server",
-        help="Server name (default: SMCP ToolUniverse Server)",
+        default="ToolUniverse SMCP Server",
+        help="Server name (default: ToolUniverse SMCP Server)",
     )
     parser.add_argument(
         "--no-search",
@@ -272,18 +271,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 +491,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")
 
@@ -522,10 +527,9 @@ Examples:
             exclude_tool_types=exclude_tool_types,
             search_enabled=not args.no_search,
             max_workers=args.max_workers,
-            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)
@@ -679,8 +683,8 @@ Examples:
     )
     parser.add_argument(
         "--name",
-        default="SMCP ToolUniverse Server",
-        help="Server name (default: SMCP ToolUniverse Server)",
+        default="ToolUniverse SMCP Server",
+        help="Server name (default: ToolUniverse SMCP Server)",
     )
     parser.add_argument(
         "--no-search",
@@ -950,7 +954,6 @@ Examples:
             exclude_tool_types=exclude_tool_types,
             search_enabled=not args.no_search,
             max_workers=args.max_workers,
-            stateless_http=True,  # Enable stateless mode for MCPAutoLoaderTool compatibility
             hooks_enabled=hooks_enabled,
             hook_config=hook_config,
             hook_type=args.hook_type,

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