address MCP server review feedback

  - McpHttpServer: cap POST body read via ReadBlockAsync so chunked requests
    can't bypass the Content-Length limit and exhaust memory
  - McpHttpServer: capture the listener into a local in the accept loop to
    avoid an NRE race with a concurrent Dispose()
  - McpHttpServer: document the deliberate stateless single-session design
    (unconditional, unvalidated Mcp-Session-Id)
  - McpToolsRegistry: hand out a DeepClone of the tools/list payload so
    concurrent dispatches don't race on the shared JObject
  - McpJsonRpcDispatcher: return -32600 (Invalid Request) for well-formed
    JSON that isn't an object, keeping -32700 for unparseable input
  - McpJsonRpcDispatcher: log a warning when the client's initialize
    protocolVersion differs from the server's
  - McpServerPlugin: store the log entry bus in a field and unsubscribe in
    Dispose()

Author: popuz

Explorer/Assets/DCL/McpServer/Core/McpHttpServer.cs

@@ -24,6 +24,13 @@ public class McpHttpServer : IDisposable
 
         private readonly McpJsonRpcDispatcher dispatcher;
         private readonly int port;
+
+        // Stateless single-session design: this localhost, single-user automation server exposes one logical MCP
+        // session for the whole process lifetime. It therefore uses one id for its entire life and echoes it on
+        // every response (including errors and before initialize) instead of minting one per handshake, and it does
+        // not validate the incoming Mcp-Session-Id — there is no per-session state to bind a request to. This
+        // deliberately departs from the Streamable HTTP session lifecycle; revisit if the server ever serves
+        // multiple concurrent clients.
         private readonly string sessionId = Guid.NewGuid().ToString("N");
 
         private HttpListener? listener;
@@ -73,11 +80,16 @@ public async UniTaskVoid RunAsync(CancellationToken ct)
         {
             await DCLTask.SwitchToThreadPool();
 
-            while (!ct.IsCancellationRequested && listener is { IsListening: true })
+            // Capture once: a concurrent Dispose() on the main thread nulls the field, and re-reading it between
+            // the guard and GetContextAsync would throw an unfiltered NRE. Dispose still stops/closes this same
+            // instance, so a parked GetContextAsync surfaces as one of the caught exceptions below.
+            HttpListener? local = listener;
+
+            while (!ct.IsCancellationRequested && local is { IsListening: true })
             {
                 HttpListenerContext context;
 
-                try { context = await listener.GetContextAsync(); }
+                try { context = await local.GetContextAsync(); }
                 catch (Exception e) when (e is HttpListenerException or ObjectDisposedException or InvalidOperationException)
                 {
                     // The listener was stopped or disposed; end the accept loop.

Explorer/Assets/DCL/McpServer/Core/McpJsonRpcDispatcher.cs

@@ -49,7 +49,7 @@ public McpJsonRpcDispatcher(McpToolsRegistry tools, string serverVersion)
 
             return routable.Value.method switch
                    {
-                       "initialize" => JsonRpcEnvelope.Result(id, InitializeResult()),
+                       "initialize" => JsonRpcEnvelope.Result(id, InitializeResult(routable.Value.callParams)),
                        "ping" => JsonRpcEnvelope.Result(id, new JObject()),
                        "tools/list" => JsonRpcEnvelope.Result(id, tools),
                        "tools/call" => await CallToolAsync(id,
@@ -69,14 +69,22 @@ private static (JToken id, string method, JObject? callParams)? ParseRoutableReq
         {
             earlyResponse = null;
 
-            JObject request;
-            try { request = JObject.Parse(requestJson); }
+            JToken parsed;
+            try { parsed = JToken.Parse(requestJson); }
             catch (JsonException)
             {
                 earlyResponse = JsonRpcEnvelope.Error(null, PARSE_ERROR, "Parse error");
                 return null;
             }
 
+            // -32700 is reserved for unparseable JSON; well-formed JSON that is not a JSON-RPC object
+            // (a bare array, number or string) is a valid document but an invalid request: -32600.
+            if (parsed is not JObject request)
+            {
+                earlyResponse = JsonRpcEnvelope.Error(null, INVALID_REQUEST, "Invalid request: expected a JSON-RPC object");
+                return null;
+            }
+
             JToken? id = request["id"];
             string? method = request["method"]?.Value<string>();
 
@@ -93,8 +101,17 @@ private static (JToken id, string method, JObject? callParams)? ParseRoutableReq
             return (id, method, request["params"] as JObject);
         }
 
-        private JObject InitializeResult() =>
-            new ()
+        private JObject InitializeResult(JObject? initializeParams)
+        {
+            // We implement a single MCP revision. Per the handshake rules we answer with our version regardless,
+            // but a client pinned to a different revision may abort on a strict mismatch — surface it so the
+            // otherwise-silent interop failure is diagnosable from the server logs.
+            string? requestedVersion = initializeParams?["protocolVersion"]?.Value<string>();
+
+            if (!string.IsNullOrEmpty(requestedVersion) && requestedVersion != PROTOCOL_VERSION)
+                ReportHub.LogWarning(ReportCategory.MCP, $"MCP client requested protocol version '{requestedVersion}', server responding with '{PROTOCOL_VERSION}'");
+
+            return new JObject
             {
                 ["protocolVersion"] = PROTOCOL_VERSION,
                 ["capabilities"] = new JObject { ["tools"] = new JObject() },
@@ -105,6 +122,7 @@ private JObject InitializeResult() =>
                     ["pid"] = processId,
                 },
             };
+        }
 
         private async UniTask<string?> CallToolAsync(JToken id, string? toolName, JObject arguments, CancellationToken ct)
         {

Explorer/Assets/DCL/McpServer/Core/McpToolsRegistry.cs

@@ -10,9 +10,14 @@ public class McpToolsRegistry
         private readonly Dictionary<string, IMcpTool> tools = new ();
         private JObject toolsList = null!;
 
-        /// <summary>Lets the built registry stand in directly for its tools/list payload.</summary>
+        /// <summary>
+        ///     Lets the built registry stand in directly for its tools/list payload. Returns a detached clone:
+        ///     dispatched requests run concurrently on the thread pool, and attaching the shared instance to a
+        ///     response envelope re-parents it in place, so handing out the same object would race on its parent/
+        ///     sibling pointers during serialization.
+        /// </summary>
         public static implicit operator JObject(McpToolsRegistry registry) =>
-            registry.toolsList;
+            (JObject)registry.toolsList.DeepClone();
 
         public McpToolsRegistry Add(IMcpTool tool)
         {