fix(local-mcp): answer the relay MCP initialize handshake locally

A relayed server's real connection can be a slow-to-spawn stdio
process on the user's machine. Relaying the MCP `initialize` handshake
made connection establishment wait on a cross-machine round trip plus
that spawn, blowing the client's init timeout so the server was dropped
for the whole run ("no slack tool"). As a pass-through proxy the relay
now answers `initialize` (and the paired `initialized` notification)
locally — advertising tools capability and echoing the client's
protocol version — so the connection is instant; `tools/list` and tool
calls still relay for real with their generous per-request timeouts.

Also log received `mcp_response` commands in the sandbox so the
desktop's response behavior is diagnosable from the readable side, not
just the (often invisible) Electron main-process logs.

Generated-By: PostHog Code
Task-Id: 7c87c3a4-0be6-475e-a8ec-269140ded301

Author: richardsolomou

packages/agent/src/server/agent-server.ts

@@ -1216,6 +1216,13 @@ export class AgentServer {
         const resolved = this.mcpRelayServer?.resolveResponse(
           params as unknown as McpRelayResponse,
         );
+        // Logged so the desktop's response behavior is visible from the
+        // readable sandbox side, not just the (often invisible) desktop logs.
+        this.logger.debug("MCP relay response received", {
+          requestId: String(params.requestId),
+          server: String(params.server),
+          resolved,
+        });
         if (!resolved) {
           throw new Error(
             `No pending MCP relay request found for id: ${String(params.requestId)}`,

packages/agent/src/server/mcp-relay-server.test.ts

@@ -179,12 +179,41 @@ describe("McpRelayServer", () => {
     expect(events).toHaveLength(0);
   });
 
-  it("relays notifications fire-and-forget with a 202", async () => {
-    const { events, post } = await startRelay();
+  it("answers the initialize handshake locally without relaying", async () => {
+    // Even with no reachable client, the connection must establish so the
+    // real (slow-to-spawn) server isn't dropped during startup.
+    const { events, post } = await startRelay({
+      hasReachableClient: () => false,
+    });
     const response = await post("slack", {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: { protocolVersion: "2025-06-18" },
+    });
+    expect(response.status).toBe(200);
+    const body = (await response.json()) as {
+      result: { protocolVersion: string; capabilities: { tools: unknown } };
+    };
+    expect(body.result.protocolVersion).toBe("2025-06-18");
+    expect(body.result.capabilities.tools).toBeDefined();
+    expect(events).toHaveLength(0);
+
+    // The paired initialized notification is also answered locally.
+    const notified = await post("slack", {
       jsonrpc: "2.0",
       method: "notifications/initialized",
     });
+    expect(notified.status).toBe(202);
+    expect(events).toHaveLength(0);
+  });
+
+  it("relays non-initialize notifications fire-and-forget with a 202", async () => {
+    const { events, post } = await startRelay();
+    const response = await post("slack", {
+      jsonrpc: "2.0",
+      method: "notifications/cancelled",
+    });
     expect(response.status).toBe(202);
     await expect.poll(() => events.length).toBe(1);
   });
@@ -216,11 +245,11 @@ describe("McpRelayServer", () => {
       hasReachableClient: () => reachable,
       requestTimeoutMs: 2_000,
     });
-    // Session-start handshake fires before the event relay attaches.
+    // A relayed request (tools/list) fires before the event relay attaches.
     const responsePromise = post("slack", {
       jsonrpc: "2.0",
       id: 1,
-      method: "initialize",
+      method: "tools/list",
     });
     await expect.poll(() => events.length).toBe(1);
     const event = events[0] as { requestId: string };

packages/agent/src/server/mcp-relay-server.ts

@@ -222,6 +222,36 @@ export class McpRelayServer {
         });
       }
 
+      // Answer the MCP `initialize` handshake locally. The real server may be
+      // a slow-to-spawn stdio process on the user's machine; making connection
+      // establishment wait on a cross-machine round trip + process spawn blows
+      // the client's init timeout, and the server is dropped for the run. As a
+      // pass-through proxy we advertise tools capability and echo the client's
+      // protocol version; `tools/list` and tool calls relay for real (with
+      // generous per-request timeouts). The matching `initialized` notification
+      // is likewise answered locally.
+      if (payload.method === "initialize") {
+        const params = payload.params as
+          | { protocolVersion?: unknown }
+          | undefined;
+        const protocolVersion =
+          typeof params?.protocolVersion === "string"
+            ? params.protocolVersion
+            : "2025-06-18";
+        return c.json({
+          jsonrpc: "2.0",
+          id: payload.id,
+          result: {
+            protocolVersion,
+            capabilities: { tools: { listChanged: false } },
+            serverInfo: { name: `relay:${server}`, version: "1.0.0" },
+          },
+        });
+      }
+      if (payload.method === "notifications/initialized") {
+        return c.body(null, 202);
+      }
+
       const requestId = crypto.randomUUID();
       const timeoutMs =
         this.config.requestTimeoutMs ?? DEFAULT_RELAY_TIMEOUT_MS;