fix(mcp): push list_changed when host catalog reloads

Daemon ConnectedHostCatalog stayed stale after Reload/AddPath in Revit,
so search_dynamic could not see newly registered tools until reconnect.
Host now broadcasts tools/list_changed and resources/list_changed to
connected MCP pipe clients.

- Add McpJsonRpc.CreateNotification and McpPipeSession.SendNotificationAsync
- Refactor McpPipeSession read loop; remove unused RunAsync
- Add NamedPipe test for tool list change notifications
- Add mcp_autonomous sample for PostCommand probing

Author: trgiangv

samples/PythonDemo/mcp_autonomous/autonomous_mcp.py

@@ -0,0 +1,47 @@
+from mcp.server.mcpserver import MCPServer
+from mcp.types import CallToolResult, TextContent, ToolAnnotations
+from typing import Annotated
+from pydantic import Field
+
+from RevitDevTool.Core import RevitContext
+from Autodesk.Revit import UI
+
+mcp = MCPServer("Autonomous Revit Toolset")
+
+
+def register_autonomous_tools(mcp: MCPServer) -> None:
+
+    @mcp.tool(annotations=ToolAnnotations(title="Probe / Post Revit Command"))
+    async def autonomous_post_command(
+        command_id: Annotated[str, Field(description="Revit command id for LookupCommandId")],
+        post: Annotated[
+            bool,
+            Field(description="If true, call PostCommand when CanPostCommand is true"),
+        ] = False,
+    ) -> CallToolResult:
+        """Temporary spike: probe LookupCommandId / CanPostCommand / PostCommand."""
+
+        uiapp = RevitContext.UiApplication
+        cmd = UI.RevitCommandId.LookupCommandId(command_id)
+        found = cmd is not None
+        can_post = uiapp.CanPostCommand(cmd) if found else False
+
+        lines = [
+            f"command_id={command_id}",
+            f"found={found}",
+            f"can_post={can_post}",
+        ]
+        if found:
+            lines.append(f"name={cmd.Name}")
+            lines.append(f"id={cmd.Id}")
+
+        if post and can_post:
+            uiapp.PostCommand(cmd)
+            lines.append("posted=true")
+        elif post:
+            lines.append("posted=false (CanPostCommand was false)")
+
+        return CallToolResult(content=[TextContent(type="text", text="\n".join(lines))])
+
+
+register_autonomous_tools(mcp)

source/DevTools.Mcp.Adapter/External/HostMcpPipeServer.cs

@@ -6,6 +6,7 @@
 using DevTools.Mcp.Core.Protocol;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
+using ModelContextProtocol.Protocol;
 using ZLogger;
 namespace DevTools.Mcp.Adapter.External;
 
@@ -27,7 +28,7 @@ public sealed class HostMcpPipeServer(
 
     private CancellationTokenSource? _cts;
     private Task? _acceptLoopTask;
-    private readonly ConcurrentDictionary<int, IAsyncDisposable> _sessions = new();
+    private readonly ConcurrentDictionary<int, McpPipeSession> _sessions = new();
     private int _nextSessionId;
     private string? _pipeName;
     private bool _disposed;
@@ -111,12 +112,11 @@ private async Task AcceptLoopAsync(CancellationToken ct)
     private async Task HandleConnectionAsync(NamedPipeServerStream pipe, CancellationToken ct)
     {
         var sessionId = Interlocked.Increment(ref _nextSessionId);
-        IAsyncDisposable? session = null;
+        McpPipeSession? pipeSession = null;
         try
         {
-            var pipeSession = McpPipeSession.Start(pipe, mcpHandler, ct);
-            session = pipeSession;
-            _sessions[sessionId] = session;
+            pipeSession = McpPipeSession.Start(pipe, mcpHandler, ct);
+            _sessions[sessionId] = pipeSession;
             connectionTracker.SetMcpClientCount(_sessions.Count);
 
             logger.ZLogInformation($"MCP client connected. Active sessions: {_sessions.Count}");
@@ -129,10 +129,10 @@ private async Task HandleConnectionAsync(NamedPipeServerStream pipe, Cancellatio
         }
         finally
         {
-            if (session is not null)
+            if (pipeSession is not null)
             {
                 _sessions.TryRemove(sessionId, out _);
-                await session.DisposeAsync().ConfigureAwait(false);
+                await pipeSession.DisposeAsync().ConfigureAwait(false);
             }
             else
             {
@@ -150,6 +150,7 @@ private void OnCatalogChanged(object? sender, EventArgs e)
         {
             primitiveDispatcher.ClearCaches();
             toolsetContextManager.Clear();
+            _ = BroadcastCatalogListChangedNotificationsAsync();
             logger.ZLogInformation(
                 $"MCP host catalog reloaded ({catalogStore.ToolDescriptors.Count} tools, {catalogStore.ResourceDescriptors.Count} resources).");
         }
@@ -159,6 +160,22 @@ private void OnCatalogChanged(object? sender, EventArgs e)
         }
     }
 
+    private async Task BroadcastCatalogListChangedNotificationsAsync()
+    {
+        foreach (var session in _sessions.Values)
+        {
+            try
+            {
+                await session.SendNotificationAsync(NotificationMethods.ToolListChangedNotification).ConfigureAwait(false);
+                await session.SendNotificationAsync(NotificationMethods.ResourceListChangedNotification).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.ZLogWarning($"Failed to notify MCP client of catalog change: {ex.Message}");
+            }
+        }
+    }
+
     private static NamedPipeServerStream CreateServerPipe(string pipeName)
     {
         var security = new PipeSecurity();

source/DevTools.Mcp.Adapter/Host/McpJsonRpc.cs

@@ -1,51 +1,40 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
-
-using DevTools.Mcp.Core.Protocol;
-
 using JsonRpcKeys = DevTools.Mcp.Core.Protocol.McpSpecKeys.JsonRpc;
 
-
-
 namespace DevTools.Mcp.Adapter.Host;
 
-
-
 /// <summary>JSON-RPC 2.0 envelope helpers for the host MCP handler.</summary>
-
 internal static class McpJsonRpc
-
 {
-
     public const string Version = JsonRpcKeys.Version;
-
     public const int InvalidRequest = JsonRpcKeys.InvalidRequest;
-
     public const int MethodNotFound = JsonRpcKeys.MethodNotFound;
-
     public const int InvalidParams = JsonRpcKeys.InvalidParams;
-
     public const int InternalError = JsonRpcKeys.InternalError;
-
     public const int UnsupportedProtocolVersion = JsonRpcKeys.UnsupportedProtocolVersion;
 
-
-
     public static JsonObject CreateSuccess(JsonNode? id, JsonNode result) =>
-
         new()
-
         {
-
             [JsonRpcKeys.Envelope] = Version,
-
             [JsonRpcKeys.Id] = id?.DeepClone(),
-
             [JsonRpcKeys.Result] = result.DeepClone(),
+        };
 
+    public static JsonObject CreateNotification(string method, JsonObject? parameters = null)
+    {
+        var notification = new JsonObject
+        {
+            [JsonRpcKeys.Envelope] = Version,
+            [JsonRpcKeys.Method] = method,
         };
 
+        if (parameters is not null)
+            notification[JsonRpcKeys.Params] = parameters.DeepClone();
 
+        return notification;
+    }
 
     public static JsonObject CreateError(JsonNode? id, int code, string message) =>
         CreateError(id, code, message, data: null);
@@ -69,67 +58,33 @@ public static JsonObject CreateError(JsonNode? id, int code, string message, Jso
                 },
         };
 
-
-
     public static bool TryGetMethod(JsonObject request, out string? method)
-
     {
-
         if (request[JsonRpcKeys.Method] is JsonValue value && value.TryGetValue(out string? parsed))
-
         {
-
             method = parsed;
-
             return true;
-
         }
 
-
-
         method = null;
-
         return false;
-
     }
 
-
-
     public static JsonNode? GetId(JsonObject request) => request[JsonRpcKeys.Id];
 
-
-
     public static bool HasId(JsonObject request) => request.ContainsKey(JsonRpcKeys.Id);
 
-
-
     public static JsonObject? GetParams(JsonObject request) =>
-
         request[JsonRpcKeys.Params] switch
-
         {
-
             JsonObject obj => obj,
-
-            null => null,
-
             _ => null,
-
         };
 
-
-
     public static JsonObject ParseRequest(string json) =>
-
         JsonNode.Parse(json)?.AsObject()
-
         ?? throw new JsonException("Expected a JSON-RPC request object.");
 
-
-
     public static string Serialize(JsonObject message) =>
-
         message.ToJsonString(new JsonSerializerOptions { WriteIndented = false });
-
 }
-