feat(stdio): add MCP tool toggle support with tools/list_changed notifications

MCPForUnity/Editor/Services/Transport/Transports/StdioBridgeHost.cs

@@ -1014,6 +1014,19 @@ private static bool IsValidJson(string text)
             return false;
         }
 
+        public static void RefreshStatusFile(string reason = "manual_refresh")
+        {
+            try
+            {
+                heartbeatSeq++;
+                WriteHeartbeat(false, reason);
+            }
+            catch (Exception ex)
+            {
+                McpLog.Warn($"Failed to refresh stdio status file: {ex.Message}");
+            }
+        }
+
 
         public static void WriteHeartbeat(bool reloading, string reason = null)
         {
@@ -1025,7 +1038,8 @@ public static void WriteHeartbeat(bool reloading, string reason = null)
                     dir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".unity-mcp");
                 }
                 Directory.CreateDirectory(dir);
-                string filePath = Path.Combine(dir, $"unity-mcp-status-{ComputeProjectHash(Application.dataPath)}.json");
+                string projectHash = ComputeProjectHash(Application.dataPath);
+                string filePath = Path.Combine(dir, $"unity-mcp-status-{projectHash}.json");
 
                 string projectName = "Unknown";
                 try
@@ -1047,14 +1061,33 @@ public static void WriteHeartbeat(bool reloading, string reason = null)
                 }
                 catch { }
 
+                string[] enabledTools = Array.Empty<string>();
+                try
+                {
+                    var toolMetadata = MCPServiceLocator.ToolDiscovery.GetEnabledTools();
+                    enabledTools = toolMetadata
+                        ?.Select(tool => tool?.Name)
+                        .Where(name => !string.IsNullOrWhiteSpace(name))
+                        .Distinct(StringComparer.Ordinal)
+                        .OrderBy(name => name, StringComparer.Ordinal)
+                        .ToArray()
+                        ?? Array.Empty<string>();
+                }
+                catch (Exception ex)
+                {
+                    McpLog.Warn($"Failed to resolve enabled tools for stdio status file: {ex.Message}");
+                }
+
                 var payload = new
                 {
                     unity_port = currentUnityPort,
                     reloading,
                     reason = reason ?? (reloading ? "reloading" : "ready"),
                     seq = heartbeatSeq,
+                    project_hash = projectHash,
                     project_path = Application.dataPath,
                     project_name = projectName,
+                    enabled_tools = enabledTools,
                     unity_version = Application.unityVersion,
                     last_heartbeat = DateTime.UtcNow.ToString("O")
                 };

MCPForUnity/Editor/Tools/ManageEditor.cs

@@ -1,5 +1,9 @@
 using System;
+using System.Threading.Tasks;
 using MCPForUnity.Editor.Helpers;
+using MCPForUnity.Editor.Services;
+using MCPForUnity.Editor.Services.Transport;
+using MCPForUnity.Editor.Services.Transport.Transports;
 using Newtonsoft.Json.Linq;
 using UnityEditor;
 using UnityEditorInternal; // Required for tag management
@@ -101,6 +105,38 @@ public static object HandleCommand(JObject @params)
                     if (!toolNameResult.IsSuccess)
                         return new ErrorResponse(toolNameResult.ErrorMessage);
                     return SetActiveTool(toolNameResult.Value);
+                case "set_mcp_tool_enabled":
+                    var setToolEnabledNameResult = p.GetRequired(
+                        "toolName",
+                        "'toolName' parameter required for set_mcp_tool_enabled.");
+                    if (!setToolEnabledNameResult.IsSuccess)
+                    {
+                        return new ErrorResponse(setToolEnabledNameResult.ErrorMessage);
+                    }
+
+                    if (!p.Has("enabled"))
+                    {
+                        return new ErrorResponse("'enabled' parameter required for set_mcp_tool_enabled.");
+                    }
+
+                    bool? enabled = ParamCoercion.CoerceBoolNullable(p.GetRaw("enabled"));
+                    if (!enabled.HasValue)
+                    {
+                        return new ErrorResponse("'enabled' parameter must be a boolean.");
+                    }
+
+                    return SetMcpToolEnabled(setToolEnabledNameResult.Value, enabled.Value);
+                case "get_mcp_tool_enabled":
+                    var getToolEnabledNameResult = p.GetRequired(
+                        "toolName",
+                        "'toolName' parameter required for get_mcp_tool_enabled.");
+                    if (!getToolEnabledNameResult.IsSuccess)
+                    {
+                        return new ErrorResponse(getToolEnabledNameResult.ErrorMessage);
+                    }
+                    return GetMcpToolEnabled(getToolEnabledNameResult.Value);
+                case "list_mcp_tools":
+                    return ListMcpTools();
 
                 // Tag Management
                 case "add_tag":
@@ -136,7 +172,7 @@ public static object HandleCommand(JObject @params)
 
                 default:
                     return new ErrorResponse(
-                        $"Unknown action: '{action}'. Supported actions: play, pause, stop, set_active_tool, add_tag, remove_tag, add_layer, remove_layer. Use MCP resources for reading editor state, project info, tags, layers, selection, windows, prefab stage, and active tool."
+                        $"Unknown action: '{action}'. Supported actions: play, pause, stop, set_active_tool, set_mcp_tool_enabled, get_mcp_tool_enabled, list_mcp_tools, add_tag, remove_tag, add_layer, remove_layer. Use MCP resources for reading editor state, project info, tags, layers, selection, windows, prefab stage, and active tool."
                     );
             }
         }
@@ -178,6 +214,129 @@ private static object SetActiveTool(string toolName)
             }
         }
 
+        private static object SetMcpToolEnabled(string toolName, bool enabled)
+        {
+            if (string.IsNullOrWhiteSpace(toolName))
+            {
+                return new ErrorResponse("Tool name cannot be empty.");
+            }
+
+            var metadata = MCPServiceLocator.ToolDiscovery.GetToolMetadata(toolName);
+            if (metadata == null)
+            {
+                return new ErrorResponse($"Unknown tool '{toolName}'.");
+            }
+
+            if (!enabled && string.Equals(metadata.Name, "manage_editor", StringComparison.OrdinalIgnoreCase))
+            {
+                return new ErrorResponse($"Tool '{metadata.Name}' cannot be disabled.");
+            }
+
+            MCPServiceLocator.ToolDiscovery.SetToolEnabled(metadata.Name, enabled);
+            RefreshStdioStatusFile();
+            RefreshHttpToolRegistration();
+
+            return new SuccessResponse(
+                $"Tool '{metadata.Name}' {(enabled ? "enabled" : "disabled")} successfully.",
+                new
+                {
+                    toolName = metadata.Name,
+                    enabled
+                });
+        }
+
+        private static object GetMcpToolEnabled(string toolName)
+        {
+            if (string.IsNullOrWhiteSpace(toolName))
+            {
+                return new ErrorResponse("Tool name cannot be empty.");
+            }
+
+            var metadata = MCPServiceLocator.ToolDiscovery.GetToolMetadata(toolName);
+            if (metadata == null)
+            {
+                return new ErrorResponse($"Unknown tool '{toolName}'.");
+            }
+
+            bool enabled = MCPServiceLocator.ToolDiscovery.IsToolEnabled(metadata.Name);
+            return new SuccessResponse(
+                $"Tool '{metadata.Name}' is {(enabled ? "enabled" : "disabled")}.",
+                new
+                {
+                    toolName = metadata.Name,
+                    enabled
+                });
+        }
+
+        private static object ListMcpTools()
+        {
+            try
+            {
+                var discoveredTools = MCPServiceLocator.ToolDiscovery.DiscoverAllTools();
+                var toolStates = new JArray();
+
+                foreach (var tool in discoveredTools)
+                {
+                    toolStates.Add(new JObject
+                    {
+                        ["name"] = tool.Name,
+                        ["enabled"] = MCPServiceLocator.ToolDiscovery.IsToolEnabled(tool.Name),
+                        ["autoRegister"] = tool.AutoRegister,
+                        ["isBuiltIn"] = tool.IsBuiltIn
+                    });
+                }
+
+                return new SuccessResponse(
+                    $"Listed {toolStates.Count} MCP tools.",
+                    new JObject
+                    {
+                        ["toolCount"] = toolStates.Count,
+                        ["tools"] = toolStates
+                    });
+            }
+            catch (Exception e)
+            {
+                return new ErrorResponse($"Failed to list MCP tools: {e.Message}");
+            }
+        }
+
+        private static void RefreshStdioStatusFile()
+        {
+            if (!StdioBridgeHost.IsRunning)
+                return;
+
+            StdioBridgeHost.RefreshStatusFile("tool_toggle");
+        }
+
+        private static void RefreshHttpToolRegistration()
+        {
+            try
+            {
+                var transportManager = MCPServiceLocator.TransportManager;
+                var client = transportManager.GetClient(TransportMode.Http);
+                if (client == null || !client.IsConnected)
+                {
+                    return;
+                }
+
+                _ = Task.Run(async () =>
+                {
+                    try
+                    {
+                        await client.ReregisterToolsAsync().ConfigureAwait(false);
+                    }
+                    catch (Exception e)
+                    {
+                        McpLog.Warn($"Failed to reregister HTTP tools after tool toggle: {e.Message}");
+                    }
+                });
+            }
+            catch (Exception e)
+            {
+                McpLog.Warn($"Failed to schedule HTTP tool reregistration after tool toggle: {e.Message}");
+            }
+        }
+
         // --- Tag Management Methods ---
 
         private static object AddTag(string tagName)

Server/README.md

@@ -147,6 +147,8 @@ These options apply to the `mcp-for-unity` command (whether run via `uvx`, Docke
 - `UNITY_MCP_HTTP_REMOTE_HOSTED` - Enable remote-hosted mode (`true`, `1`, or `yes`)
 - `UNITY_MCP_DEFAULT_INSTANCE` - Default Unity instance to target (project name, hash, or `Name@hash`)
 - `UNITY_MCP_SKIP_STARTUP_CONNECT=1` - Skip initial Unity connection attempt on startup
+- `UNITY_MCP_STDIO_STATUS_TTL_SECONDS` - Freshness window for stdio status files used by tools/list filtering (default: `15`)
+- `UNITY_MCP_STDIO_TOOLS_WATCH_INTERVAL_SECONDS` - Poll interval for stdio tool-list change watcher in seconds (default: `1.0`, minimum: `0.2`)
 
 API key authentication (remote-hosted mode):
 
@@ -164,6 +166,45 @@ Telemetry:
 - `UNITY_MCP_TELEMETRY_ENDPOINT` - Override telemetry endpoint URL
 - `UNITY_MCP_TELEMETRY_TIMEOUT` - Override telemetry request timeout (seconds)
 
+### MCP tool toggles in stdio
+
+The `manage_editor` tool exposes MCP tool enable/disable controls:
+
+- `set_mcp_tool_enabled` (`tool_name`, `enabled`)
+- `get_mcp_tool_enabled` (`tool_name`)
+- `list_mcp_tools`
+
+Example:
+
+```json
+{
+  "action": "set_mcp_tool_enabled",
+  "tool_name": "manage_scene",
+  "enabled": false
+}
+```
+
+When running in `stdio`, `tools/list` is filtered by Unity's enabled tool state.
+If all Unity-managed tools are disabled, `tools/list` will only show server-only tools.
+The Unity status file (`~/.unity-mcp/unity-mcp-status-<hash>.json`) now includes:
+
+- `project_hash`
+- `enabled_tools`
+
+Tool toggle changes trigger an immediate status-file refresh, so `tools/list`
+updates do not depend on waiting for the next heartbeat.
+When a client session initializes in `stdio`, the server sends
+`notifications/tools/list_changed` to trigger an immediate tool-list refresh.
+During runtime, a stdio watcher monitors status-file changes and emits the same
+notification when enabled-tool state changes.
+To avoid stale instance data, stdio filtering only uses recent status files
+(default freshness window: 15s, configurable via `UNITY_MCP_STDIO_STATUS_TTL_SECONDS`).
+Watcher interval defaults to 1.0s (minimum 0.2s), configurable via
+`UNITY_MCP_STDIO_TOOLS_WATCH_INTERVAL_SECONDS`.
+Compatibility note: if a client ignores `notifications/tools/list_changed`,
+tool calls still enforce enabled/disabled state, but visible list updates may
+still require reconnecting that client.
+
 ### Examples
 
 **Stdio (default):**

Server/src/main.py

@@ -144,6 +144,7 @@ async def server_lifespan(server: FastMCP) -> AsyncIterator[dict[str, Any]]:
     global _unity_connection_pool, _server_version
     _server_version = get_package_version()
     logger.info(f"MCP for Unity Server v{_server_version} starting up")
+    unity_middleware = get_unity_instance_middleware()
 
     # Register custom tool management endpoints with FastMCP
     # Routes are declared globally below after FastMCP initialization
@@ -164,6 +165,11 @@ async def server_lifespan(server: FastMCP) -> AsyncIterator[dict[str, Any]]:
         loop = asyncio.get_running_loop()
         PluginHub.configure(_plugin_registry, loop)
 
+    try:
+        await unity_middleware.start_stdio_tools_watcher()
+    except Exception:
+        logger.debug("Failed to start stdio tools watcher.", exc_info=True)
+
     # Record server startup telemetry
     start_time = time.time()
     start_clk = time.perf_counter()
@@ -248,6 +254,10 @@ def _emit_startup():
             "plugin_registry": _plugin_registry,
         }
     finally:
+        try:
+            await unity_middleware.stop_stdio_tools_watcher()
+        except Exception:
+            logger.debug("Failed to stop stdio tools watcher.", exc_info=True)
         if _unity_connection_pool:
             _unity_connection_pool.disconnect_all()
         logger.info("MCP for Unity Server shut down")