revert(local-mcp): relay the MCP initialize handshake instead of faking it

Answering initialize locally regressed the relay: desktop main.log
showed servers connecting and executing with the relayed handshake, but
stopped connecting once the synthetic-initialize build shipped (the
streamable-HTTP session the client sets up on initialize wasn't honored
by a locally-fabricated response, so tools/list never followed). Revert
to relaying initialize through to the real server, keeping the liveness
and startup-buffering fixes that made the round trip work end to end.

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

Author: richardsolomou

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

@@ -179,40 +179,11 @@ describe("McpRelayServer", () => {
     expect(events).toHaveLength(0);
   });
 
-  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 () => {
+  it("relays notifications fire-and-forget with a 202", async () => {
     const { events, post } = await startRelay();
     const response = await post("slack", {
       jsonrpc: "2.0",
-      method: "notifications/cancelled",
+      method: "notifications/initialized",
     });
     expect(response.status).toBe(202);
     await expect.poll(() => events.length).toBe(1);

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

@@ -222,36 +222,6 @@ 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;