tooluniverse 1.0.9__py3-none-any.whl → 1.0.10__py3-none-any.whl

tooluniverse/mcp_tool_registry.py

@@ -1,23 +1,27 @@
 """
 MCP Tool Registration System for ToolUniverse
 
-This module provides functionality to register local tools as MCP tools and enables
-automatic loading of these tools on remote servers via ToolUniverse integration.
+This module provides functionality to register local tools as MCP tools and
+enables automatic loading of these tools on remote servers via ToolUniverse
+integration.
 
-Usage:
-======
+Usage
+-----
 
 Server Side (Tool Provider):
-```python
-from tooluniverse.mcp_tool_registry import register_mcp_tool, start_mcp_server
-
-@register_mcp_tool(
-    tool_type_name="my_analysis_tool",
-    config={
-        "description": "Performs custom data analysis"
-    },
-    mcp_config={
-        "server_name": "Custom Analysis Server",
+.. code-block:: python
+
+    from tooluniverse.mcp_tool_registry import (
+        register_mcp_tool, start_mcp_server
+    )
+
+    @register_mcp_tool(
+        tool_type_name="my_analysis_tool",
+        config={
+            "description": "Performs custom data analysis"
+        },
+        mcp_config={
+            "server_name": "Custom Analysis Server",
         "host": "0.0.0.0",
         "port": 8001
     }
@@ -43,10 +47,10 @@ result = tu.run_tool("my_analysis_tool", {"data": "input"})
 ```
 """
 
-import json
 import asyncio
 from typing import Dict, Any, List, Optional
-import threading
+
+from .tool_registry import register_tool
 
 
 # Import SMCP and ToolUniverse dynamically to avoid circular imports
@@ -68,18 +72,21 @@ def _get_tooluniverse():
 _mcp_tool_registry: Dict[str, Any] = {}
 _mcp_server_configs: Dict[int, Dict[str, Any]] = {}
 _mcp_server_instances: Dict[int, Any] = {}
+_mcp_tool_configs: List[Dict[str, Any]] = []  # Store tool configs
 
 
 def register_mcp_tool(tool_type_name=None, config=None, mcp_config=None):
     """
-    Decorator to register a tool class exactly like register_tool, but also expose it as an MCP server.
+    Decorator to register a tool class for MCP server exposure.
 
-    This decorator does everything that register_tool does, PLUS exposes the tool via SMCP protocol
-    for remote access. The parameters and behavior are identical to register_tool, with an optional
-    mcp_config parameter for server configuration.
+    This decorator registers tools both globally (via register_tool) and for
+    MCP server management. The global registration allows ToolUniverse to
+    properly instantiate tools, while MCP registration controls server
+    exposure. The parameters and behavior are identical to register_tool,
+    with an optional mcp_config parameter for server configuration.
 
-    Parameters:
-    ===========
+    Parameters
+    ----------
     tool_type_name : str, optional
         Custom name for the tool type. Same as register_tool.
 
@@ -94,17 +101,18 @@ def register_mcp_tool(tool_type_name=None, config=None, mcp_config=None):
         - transport: "http" or "stdio" (default: "http")
         - auto_start: Whether to auto-start server when tool is registered
 
-    Returns:
-    ========
+    Returns
+    -------
     function
-        Decorator function that registers the tool class both locally and as MCP server.
+        Decorator function that registers the tool class for MCP server only.
 
-    Examples:
-    =========
+    Examples
+    --------
 
-    Same as register_tool, just with MCP exposure:
+    MCP tool registration:
     ```python
-    @register_mcp_tool('CustomToolName', config={...}, mcp_config={"port": 8001})
+    @register_mcp_tool('CustomToolName', config={...},
+                       mcp_config={"port": 8001})
     class MyTool:
         pass
 
@@ -115,13 +123,13 @@ def register_mcp_tool(tool_type_name=None, config=None, mcp_config=None):
     """
 
     def decorator(cls):
-        # First, do exactly what register_tool does
-        from .tool_registry import register_tool
-
-        # Apply register_tool decorator to register locally
+        # Step 1: Register tool class to global registry
+        # This allows ToolUniverse to properly instantiate and manage the tool
+        # Note: Registration doesn't mean auto-loading. The lightweight
+        # ToolUniverse with keep_default_tools=False remains isolated.
         registered_cls = register_tool(tool_type_name, config)(cls)
 
-        # Now, additionally register for MCP exposure
+        # Step 2: Additionally register for MCP server management
         tool_name = tool_type_name or cls.__name__
         tool_config = config or {}
         tool_description = (
@@ -153,7 +161,8 @@ def register_mcp_tool(tool_type_name=None, config=None, mcp_config=None):
         # Register for MCP exposure
         tool_info = {
             "name": tool_name,
-            "class": cls,
+            "type": tool_type_name or cls.__name__,  # 新增：保存工具类型
+            "class": registered_cls,  # Use registered class
             "description": tool_description,
             "parameter_schema": tool_schema,
             "server_config": server_config,
@@ -168,6 +177,9 @@ def register_mcp_tool(tool_type_name=None, config=None, mcp_config=None):
             _mcp_server_configs[port] = {"config": server_config, "tools": []}
         _mcp_server_configs[port]["tools"].append(tool_info)
 
+        # Note: Removed _mcp_tool_configs append since we're not using global
+        # registry
+
         print(f"✅ Registered MCP tool: {tool_name} (server port: {port})")
 
         # Auto-start server if requested
@@ -175,7 +187,7 @@ def register_mcp_tool(tool_type_name=None, config=None, mcp_config=None):
         if auto_start:
             start_mcp_server_for_tool(tool_name)
 
-        return registered_cls
+        return registered_cls  # Return registered class
 
     return decorator
 
@@ -186,11 +198,11 @@ def register_mcp_tool_from_config(tool_class: type, config: Dict[str, Any]):
 
     This function provides a programmatic way to register tools as MCP tools
     without using decorators, useful for dynamic tool registration.
-    Just like register_mcp_tool decorator, this does everything register_tool would do
-    PLUS exposes the tool via MCP.
+    Just like register_mcp_tool decorator, this registers tools for MCP
+    exposure only.
 
-    Parameters:
-    ===========
+    Parameters
+    ----------
     tool_class : type
         The tool class to register
     config : dict
@@ -200,8 +212,8 @@ def register_mcp_tool_from_config(tool_class: type, config: Dict[str, Any]):
         - parameter_schema: JSON schema for parameters
         - mcp_config: MCP server configuration
 
-    Examples:
-    =========
+    Examples
+    --------
     ```python
     class ExistingTool:
         def run(self, arguments):
@@ -218,12 +230,17 @@ def register_mcp_tool_from_config(tool_class: type, config: Dict[str, Any]):
     tool_config = {k: v for k, v in config.items() if k != "mcp_config"}
     mcp_config = config.get("mcp_config", {})
 
-    # Use the decorator to register both locally and for MCP
+    # Use the decorator to register for MCP only
     register_mcp_tool(tool_type_name=name, config=tool_config, mcp_config=mcp_config)(
         tool_class
     )
 
 
+def get_mcp_tool_configs() -> List[Dict[str, Any]]:
+    """Get the MCP tool configurations for ToolUniverse."""
+    return _mcp_tool_configs.copy()
+
+
 def get_mcp_tool_registry() -> Dict[str, Any]:
     """Get the current MCP tool registry."""
     return _mcp_tool_registry.copy()
@@ -233,8 +250,9 @@ def get_registered_tools() -> List[Dict[str, Any]]:
     """
     Get a list of all registered MCP tools with their information.
 
-    Returns:
-        List of dictionaries containing tool information including name, description, and port.
+    Returns
+        List of dictionaries containing tool information including name,
+        description, and port.
     """
     tools = []
     for tool_name, tool_info in _mcp_tool_registry.items():
@@ -258,15 +276,16 @@ def start_mcp_server(port: Optional[int] = None, **kwargs):
     """
     Start MCP server(s) for registered tools.
 
-    Parameters:
-    ===========
+    Parameters
+    ----------
     port : int, optional
-        Specific port to start server for. If None, starts servers for all registered tools.
+        Specific port to start server for. If None, starts servers for all
+        registered tools.
     **kwargs
         Additional arguments passed to SMCP server
 
-    Examples:
-    =========
+    Examples
+    --------
     ```python
     # Start server for specific port
     start_mcp_server(port=8001)
@@ -278,10 +297,10 @@ def start_mcp_server(port: Optional[int] = None, **kwargs):
     start_mcp_server(max_workers=20, debug=True)
     ```
     """
-    import time
 
     try:
-        pass
+        # Test if SMCP is available
+        _get_smcp()
     except ImportError:
         print("❌ SMCP not available. Cannot start MCP server.")
         return
@@ -289,30 +308,27 @@ def start_mcp_server(port: Optional[int] = None, **kwargs):
     if port is not None:
         # Start server for specific port
         if port in _mcp_server_configs:
+            print("🎯 MCP server(s) starting. Press Ctrl+C to stop.")
             _start_server_for_port(port, **kwargs)
         else:
             print(f"❌ No tools registered for port {port}")
     else:
         # Start servers for all registered ports
-        for port in _mcp_server_configs:
-            _start_server_for_port(port, **kwargs)
+        ports = list(_mcp_server_configs.keys())
+        if len(ports) > 1:
+            print(
+                f"⚠️  Multiple ports registered ({len(ports)}), starting server for port {ports[0]} only"
+            )
+            print(f"   Other ports: {ports[1:]}")
+            port_to_start = ports[0]
+        else:
+            port_to_start = ports[0]
 
-    # Keep main thread alive
-    print("🎯 MCP server(s) started. Press Ctrl+C to stop.")
-    try:
-        while True:
-            time.sleep(1)
-    except KeyboardInterrupt:
-        print("\n🛑 Shutting down MCP server(s)...")
-        # Cleanup server instances
-        for port, _server in _mcp_server_instances.items():
-            try:
-                print(f"🧹 Stopping server on port {port}...")
-                # Note: FastMCP cleanup is handled automatically
-            except Exception as e:
-                print(f"⚠️  Error stopping server on port {port}: {e}")
-        _mcp_server_instances.clear()
-        print("✅ All servers stopped.")
+        print("🎯 MCP server(s) starting. Press Ctrl+C to stop.")
+        _start_server_for_port(port_to_start, **kwargs)
+
+    # Note: No need for while True loop - run_simple() is blocking
+    # Server will run until interrupted
 
 
 def _start_server_for_port(port: int, **kwargs):
@@ -327,475 +343,76 @@ def _start_server_for_port(port: int, **kwargs):
 
     print(f"🚀 Starting MCP server on port {port} with {len(tools)} tools...")
 
-    # Create SMCP server for compatibility
-    server = _get_smcp()(
-        name=config["server_name"],
-        auto_expose_tools=False,  # We'll add tools manually
-        search_enabled=True,
-        max_workers=config.get("max_workers", 5),
-        **kwargs,
+    # Create a lightweight ToolUniverse instance WITHOUT default tools
+    # This ensures only registered MCP tools are loaded
+    ToolUniverse = _get_tooluniverse()
+    tu = ToolUniverse(
+        tool_files={},  # Empty tool files - no default categories
+        keep_default_tools=False,  # Don't load any default tools
     )
 
-    # Add registered tools to the server
+    # Register MCP tools using the public API
     for tool_info in tools:
-        _add_tool_to_smcp_server(server, tool_info)
-
-    # Store server instance
-    _mcp_server_instances[port] = server
+        tool_config = {
+            "name": tool_info["name"],
+            "type": tool_info["type"],  # 使用正确的type字段
+            "description": tool_info["description"],
+            "parameter": tool_info["parameter_schema"],
+            "category": "mcp_tools",
+        }
 
-    # Start server in background thread
-    def run_server():
         try:
-            # Enable stateless mode for MCPAutoLoaderTool compatibility
-            server.run_simple(
-                transport=config["transport"],
-                host=config["host"],
-                port=port,
-                stateless_http=True,
+            tu.register_custom_tool(
+                tool_class=tool_info["class"],
+                tool_name=tool_info["type"],
+                tool_config=tool_config,
+                instantiate=True,  # 立即实例化并缓存
             )
         except Exception as e:
-            print(f"❌ Error running MCP server on port {port}: {e}")
-
-    server_thread = threading.Thread(target=run_server, daemon=True)
-    server_thread.start()
+            print(f"❌ Failed to register tool {tool_info['name']}: {e}")
+            continue
 
-    print(f"✅ MCP server started on {config['host']}:{port}")
+    print(f"✅ Registered {len(tools)} MCP tool(s) using ToolUniverse API")
+    tool_names = ", ".join([t["name"] for t in tools])
+    print(f"   Tools: {tool_names}")
 
-
-def _add_tool_to_smcp_server(server, tool_info: Dict[str, Any]):
-    """Add a registered tool to an SMCP server instance by reusing SMCP's proven method."""
-    name = tool_info["name"]
-    tool_class = tool_info["class"]
-    description = tool_info["description"]
-    schema = tool_info["parameter_schema"]
-
-    print(
-        f"🔧 Adding tool '{name}' using SMCP's _create_mcp_tool_from_tooluniverse approach..."
+    # Create SMCP server with pre-configured lightweight ToolUniverse
+    server = _get_smcp()(
+        name=config["server_name"],
+        tooluniverse_config=tu,  # Pass pre-configured ToolUniverse
+        auto_expose_tools=True,  # Auto-expose since tools are in ToolUniverse
+        search_enabled=False,  # Disable search for remote tool servers
+        max_workers=config.get("max_workers", 5),
+        **kwargs,
     )
 
-    # Create tool instance for execution
-    tool_instance = tool_class()
-
-    # Convert our tool_info to the format expected by SMCP's method
-    # SMCP expects tool_config with 'name', 'description', and 'parameter' fields
-    tool_config = {
-        "name": name,
-        "description": description,
-        "parameter": schema,  # SMCP expects 'parameter' not 'parameter_schema'
-    }
-
-    # Check if the server has the SMCP method available
-    if hasattr(server, "_create_mcp_tool_from_tooluniverse"):
-        print("✅ Using server's _create_mcp_tool_from_tooluniverse method")
-        # Temporarily store our tool instance so SMCP's method can access it
-        # We need to modify SMCP's approach to use our tool_instance instead of tooluniverse
-        server._temp_tool_instance = tool_instance
-
-        # Create a modified version of SMCP's approach
-        _create_mcp_tool_from_tooluniverse_with_instance(
-            server, tool_config, tool_instance
-        )
-    else:
-        print(
-            "⚠️ Server doesn't have _create_mcp_tool_from_tooluniverse, using fallback"
-        )
-        # Fallback to standard method
-        server.add_custom_tool(
-            name=name,
-            function=lambda arguments="{}": tool_instance.run(json.loads(arguments)),
-            description=description,
-        )
-
+    # Store server instance
+    _mcp_server_instances[port] = server
 
-def _create_mcp_tool_from_tooluniverse_with_instance(
-    server, tool_config: Dict[str, Any], tool_instance
-):
-    """
-    Create an MCP tool from a ToolUniverse tool configuration using a tool instance.
+    # Start server (blocking call)
+    host = config["host"]
+    print(f"✅ MCP server starting on {host}:{port}")
+    print(f"   Server URL: http://{host}:{port}/mcp")
 
-    This method reuses the proven approach from SMCP's _create_mcp_tool_from_tooluniverse
-    method, but adapts it to work with tool instances instead of ToolUniverse.
-    It creates functions with proper parameter signatures that match the ToolUniverse
-    tool schema, enabling FastMCP's automatic parameter validation.
-    """
     try:
-        # Debug: Ensure tool_config is a dictionary
-        if not isinstance(tool_config, dict):
-            raise ValueError(
-                f"tool_config must be a dictionary, got {type(tool_config)}: {tool_config}"
-            )
-
-        tool_name = tool_config["name"]
-        description = tool_config.get("description", f"Tool: {tool_name}")
-        parameters = tool_config.get("parameter", {})
-
-        # Extract parameter information from the schema
-        # Handle case where properties might be None (like in Finish tool)
-        properties = parameters.get("properties")
-        if properties is None:
-            properties = {}
-        required_params = parameters.get("required", [])
-
-        # Handle non-standard schema format where 'required' is set on individual properties
-        # instead of at the object level (common in ToolUniverse schemas)
-        if not required_params and properties:
-            required_params = [
-                param_name
-                for param_name, param_info in properties.items()
-                if param_info.get("required", False)
-            ]
-
-        # Build function signature dynamically with Pydantic Field support
-        import inspect
-        from typing import Union
-
-        try:
-            from typing import Annotated
-            from pydantic import Field
-
-            PYDANTIC_AVAILABLE = True
-        except ImportError:
-            PYDANTIC_AVAILABLE = False
-
-        # Create parameter signature for the function
-        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
-            python_type: type
-            if param_type == "string":
-                python_type = str
-            elif param_type == "integer":
-                python_type = int
-            elif param_type == "number":
-                python_type = float
-            elif param_type == "boolean":
-                python_type = bool
-            elif param_type == "array":
-                python_type = list
-            elif param_type == "object":
-                python_type = dict
-            else:
-                python_type = str  # Default to string for unknown types
-
-            # Create proper type annotation
-            if PYDANTIC_AVAILABLE:
-                # Use Pydantic Field for enhanced schema information
-                field_kwargs = {"description": param_description}
-                pydantic_field = Field(**field_kwargs)
-
-                if is_required:
-                    annotated_type: Any = 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_annotated_type: Any = Annotated[
-                        Union[python_type, type(None)], pydantic_field
-                    ]
-                    param_annotations[param_name] = optional_annotated_type
-                    func_params.append(
-                        inspect.Parameter(
-                            param_name,
-                            inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                            default=None,
-                            annotation=optional_annotated_type,
-                        )
-                    )
-            else:
-                # Fallback without Pydantic
-                if is_required:
-                    param_annotations[param_name] = python_type
-                    func_params.append(
-                        inspect.Parameter(
-                            param_name,
-                            inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                            annotation=python_type,
-                        )
-                    )
-                else:
-                    param_annotations[param_name] = Union[python_type, type(None)]
-                    func_params.append(
-                        inspect.Parameter(
-                            param_name,
-                            inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                            default=None,
-                            annotation=Union[python_type, type(None)],
-                        )
-                    )
-
-        # Create the async function with dynamic signature
-        if not properties:
-            # Tool has no parameters - create simple function
-            async def dynamic_tool_function() -> str:
-                """Execute tool with no arguments."""
-                try:
-                    # Execute our custom tool instance
-                    result = tool_instance.run({})
-
-                    # Format the result
-                    if isinstance(result, str):
-                        return result
-                    else:
-                        return json.dumps(result, indent=2, default=str)
-
-                except Exception as e:
-                    error_msg = f"Error executing {tool_name}: {str(e)}"
-                    print(f"❌ {error_msg}")
-                    return json.dumps({"error": error_msg}, indent=2)
-
-            # Set function metadata
-            dynamic_tool_function.__name__ = tool_name
-            dynamic_tool_function.__signature__ = inspect.Signature([])
-            dynamic_tool_function.__annotations__ = {"return": str}
-
-        else:
-            # Tool has parameters - create function with dynamic signature
-            async def dynamic_tool_function(**kwargs) -> str:
-                """Execute tool with provided arguments."""
-                try:
-                    # Filter out None values for optional parameters
-                    args_dict = {k: v for k, v in kwargs.items() if v is not None}
-
-                    # Validate required parameters
-                    missing_required = [
-                        param for param in required_params if param not in args_dict
-                    ]
-                    if missing_required:
-                        return json.dumps(
-                            {
-                                "error": f"Missing required parameters: {missing_required}",
-                                "required": required_params,
-                                "provided": list(args_dict.keys()),
-                            },
-                            indent=2,
-                        )
-
-                    # Execute our custom tool instance instead of tooluniverse
-                    result = tool_instance.run(args_dict)
-
-                    # Format the result
-                    if isinstance(result, str):
-                        return result
-                    else:
-                        return json.dumps(result, indent=2, default=str)
-
-                except Exception as e:
-                    error_msg = f"Error executing {tool_name}: {str(e)}"
-                    print(f"❌ {error_msg}")
-                    return json.dumps({"error": error_msg}, indent=2)
-
-            # Set function metadata
-            dynamic_tool_function.__name__ = tool_name
-
-            # Set function signature dynamically for tools with parameters
-            if func_params:
-                dynamic_tool_function.__signature__ = inspect.Signature(func_params)
-
-            # Set annotations for type hints
-            dynamic_tool_function.__annotations__ = param_annotations.copy()
-            dynamic_tool_function.__annotations__["return"] = str
-
-        # Create detailed docstring
-        param_docs = []
-        for param_name, param_info in properties.items():
-            param_desc = param_info.get("description", f"{param_name} parameter")
-            param_type = param_info.get("type", "string")
-            is_required = param_name in required_params
-            required_text = "required" if is_required else "optional"
-            param_docs.append(
-                f"    {param_name} ({param_type}, {required_text}): {param_desc}"
-            )
-
-        # Set function docstring
-        dynamic_tool_function.__doc__ = f"""{description}
-
-Parameters:
-{chr(10).join(param_docs) if param_docs else '    No parameters required'}
-
-Returns:
-    str: Tool execution result
-"""
-
-        print(f"✅ Created function with {len(func_params)} parameters")
-        print("📋 Docstring includes parameter descriptions:")
-        for i, doc in enumerate(param_docs[:3], 1):  # Show first 3 for brevity
-            print(f"   {i}. {doc.strip()}")
-        if len(param_docs) > 3:
-            print(f"   ... and {len(param_docs) - 3} more")
-
-        # Register with FastMCP using the tool decorator approach (following SMCP pattern)
-        server.tool(description=description)(dynamic_tool_function)
-
-        print(
-            f"📦 Tool '{tool_name}' registered successfully with parameter descriptions"
+        # Enable stateless mode for MCPAutoLoaderTool compatibility
+        server.run_simple(
+            transport=config["transport"],
+            host=config["host"],
+            port=port,
+            stateless_http=True,
         )
-
-    except Exception as e:
-        print(f"❌ Error creating tool from config: {e}")
-        import traceback
-
-        traceback.print_exc()
-        # Don't raise - continue with other tools
-        return
-
-
-def _build_fastmcp_tool_function(
-    name: str, description: str, schema: Dict[str, Any], tool_instance
-):
-    """
-    Build a FastMCP-compatible function with proper docstring and type annotations.
-
-    FastMCP generates parameter schema from the function signature and docstring,
-    so we need to create a function that matches the expected format exactly.
-    """
-    properties = schema.get("properties", {})
-    required = schema.get("required", [])
-
-    # Build parameter definitions and documentation
-    param_definitions = []
-    param_names = []
-    docstring_params = []
-
-    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")
-        has_default = param_name not in required
-        default_value = param_info.get("default", None)
-        enum_values = param_info.get("enum", None)
-
-        # Map JSON schema types to Python types
-        if param_type == "string":
-            py_type = "str"
-            if has_default and default_value is None:
-                default_value = '""'
-            elif has_default:
-                default_value = f'"{default_value}"'
-        elif param_type == "integer":
-            py_type = "int"
-            if has_default and default_value is None:
-                default_value = "0"
-            elif has_default:
-                default_value = str(default_value)
-        elif param_type == "number":
-            py_type = "float"
-            if has_default and default_value is None:
-                default_value = "0.0"
-            elif has_default:
-                default_value = str(default_value)
-        elif param_type == "boolean":
-            py_type = "bool"
-            if has_default and default_value is None:
-                default_value = "False"
-            elif has_default:
-                default_value = str(default_value)
-        else:
-            py_type = "str"  # Default to string
-            if has_default and default_value is None:
-                default_value = '""'
-            elif has_default:
-                default_value = f'"{default_value}"'
-
-        # Build parameter definition for function signature
-        if has_default:
-            param_def = f"{param_name}: {py_type} = {default_value}"
-        else:
-            param_def = f"{param_name}: {py_type}"
-
-        param_definitions.append(param_def)
-        param_names.append(param_name)
-
-        # Build docstring parameter documentation
-        param_doc = f"        {param_name} ({py_type}): {param_description}"
-        if enum_values:
-            param_doc += f". Options: {enum_values}"
-        if has_default and default_value is not None:
-            param_doc += f". Default: {default_value}"
-
-        docstring_params.append(param_doc)
-
-    # Create function signature
-    params_str = ", ".join(param_definitions)
-
-    # Create comprehensive docstring following Google style
-    # This is critical for FastMCP to extract parameter information
-    docstring_parts = [
-        f'    """{description}',
-        "",
-        "    This tool provides expert consultation functionality.",
-        "",
-    ]
-
-    if docstring_params:
-        docstring_parts.extend(["    Args:", *docstring_params, ""])
-
-    docstring_parts.extend(
-        [
-            "    Returns:",
-            "        dict: Tool execution result with status and response data",
-            '    """',
-        ]
-    )
-
-    docstring = "\n".join(docstring_parts)
-
-    # Create the function code with comprehensive docstring
-    func_code = f"""
-def fastmcp_tool_function({params_str}) -> dict:
-{docstring}
-    # Collect all parameters into arguments dict for tool execution
-    arguments = {{}}
-{chr(10).join(f'    arguments["{pname}"] = {pname}' for pname in param_names)}
-
-    # Execute the original tool
-    try:
-        result = tool_instance.run(arguments)
-        return result
     except Exception as e:
-        return {{
-            "error": f"Tool execution failed: {{str(e)}}",
-            "status": "error"
-        }}
-"""
-
-    # Execute the function definition in a clean namespace
-    namespace = {
-        "tool_instance": tool_instance,
-        "str": str,  # Ensure str is available for error handling
-    }
-
-    try:
-        exec(func_code, namespace)
-        fastmcp_function = namespace["fastmcp_tool_function"]
-
-        # Verify the function was created correctly
-        if not callable(fastmcp_function):
-            raise ValueError("Generated function is not callable")
-
-        # Verify docstring exists
-        if not fastmcp_function.__doc__:
-            raise ValueError("Generated function has no docstring")
-
-        print(f"✅ FastMCP function created successfully for '{name}'")
-        print(f"   Parameters: {len(param_names)} ({', '.join(param_names)})")
-        print(f"   Docstring length: {len(fastmcp_function.__doc__)} chars")
+        print(f"❌ Error running MCP server on port {port}: {e}")
+        raise
 
-        return fastmcp_function
 
-    except Exception as e:
-        print(f"❌ Error creating FastMCP function for '{name}': {e}")
-        print(f"Generated code:\n{func_code}")
-        raise
+# Note: Removed 438 lines of dead code:
+# - _add_tool_to_smcp_server (lines 410-457)
+# - _create_mcp_tool_from_tooluniverse_with_instance (lines 459-700)
+# - _build_fastmcp_tool_function (lines 702-848)
+# These functions were never called and have been replaced by SMCP's
+# built-in tool exposure mechanism.
 
 
 def start_mcp_server_for_tool(tool_name: str):
@@ -813,8 +430,8 @@ def stop_mcp_server(port: Optional[int] = None):
     """
     Stop MCP server(s).
 
-    Parameters:
-    ===========
+    Parameters
+    ----------
     port : int, optional
         Specific port to stop server for. If None, stops all servers.
     """
@@ -867,15 +484,15 @@ def load_mcp_tools_to_tooluniverse(tu, server_urls: Optional[List[str]] = None):
     """
     Load MCP tools from servers into a ToolUniverse instance.
 
-    Parameters:
-    ===========
+    Parameters
+    ----------
     tu : ToolUniverse
         ToolUniverse instance to load tools into
     server_urls : list of str, optional
         List of MCP server URLs. If None, uses all registered local servers.
 
-    Examples:
-    =========
+    Examples
+    --------
     ```python
     from tooluniverse import ToolUniverse
     from tooluniverse.mcp_tool_registry import load_mcp_tools_to_tooluniverse
@@ -904,8 +521,10 @@ def load_mcp_tools_to_tooluniverse(tu, server_urls: Optional[List[str]] = None):
     for url in server_urls:
         try:
             # Create auto-loader for this server
+            url_clean = url.replace(":", "_").replace("/", "_")
+            loader_name = f"mcp_auto_loader_{url_clean}"
             loader_config = {
-                "name": f"mcp_auto_loader_{url.replace(':', '_').replace('/', '_')}",
+                "name": loader_name,
                 "type": "MCPAutoLoaderTool",
                 "server_url": url,
                 "auto_register": True,