tooluniverse 1.0.4__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,
@@ -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",
@@ -528,7 +527,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=hook_type,
@@ -685,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",
@@ -956,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/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_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")