Skip to content

Mobile MCP: let AI agents drive your iOS and Android apps. MCP server for simulators, emulators and real devices. Works with Claude Code, Codex, Cursor and any MCP client.

fix: serve server/discover for the 2026-07-28 protocol revision (#451)

Rahulec61fe05a5de
diff --git a/src/index.ts b/src/index.ts
index f22ee13..5f8ea67 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,7 +1,8 @@
#!/usr/bin/env node
import { createMcpExpressApp } from "@modelcontextprotocol/express";
-import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
-import { NodeStreamableHTTPServerTransport } from "@modelcontextprotocol/node";
+import { toNodeHandler } from "@modelcontextprotocol/node";
+import { createMcpHandler } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
import { createMcpServer, getAgentVersion, getSdkVersion } from "./server";
import { error } from "./logger";
import { Request, Response } from "express";
@@ -41,37 +42,20 @@ const startHttpServer = async (host: string, port: number) => {
});
}
- const handleMcpRequest = async (req: Request, res: Response) => {
- // Stateless Streamable HTTP: fresh server + transport per request
- // (Smithery / horizontal-host friendly; no session affinity).
- const server = createMcpServer();
- try {
- const transport = new NodeStreamableHTTPServerTransport({
- sessionIdGenerator: undefined,
- });
- // Register cleanup first: the response can close before handleRequest resolves.
- res.on("close", () => {
- transport.close();
- server.close();
- });
- await server.connect(transport);
- await transport.handleRequest(req, res, req.body);
- } catch (err: unknown) {
- error("Error handling MCP request: " + (err instanceof Error ? err.stack : String(err)));
- if (!res.headersSent) {
- res.status(500).json({
- jsonrpc: "2.0",
- error: {
- code: -32603,
- message: "Internal server error",
- },
- id: null,
- });
- }
- }
- };
-
- app.post("/mcp", handleMcpRequest);
+ // createMcpHandler serves both protocol eras from one factory: requests
+ // carrying the per-request `_meta` envelope (revision 2026-07-28, answered
+ // with `server/discover` and the modern result vocabulary) get a fresh
+ // era-marked instance, and legacy `initialize` traffic is served stateless
+ // from the same factory — the same per-request model as before.
+ // onerror keeps request-handling and transport failures in the application
+ // log (the SDK otherwise answers HTTP 500 silently).
+ const onerror = (err: Error) => error("Error handling MCP request: " + (err.stack ?? String(err)));
+ const handler = createMcpHandler(() => createMcpServer(), { onerror });
+ const node = toNodeHandler(handler, { onerror });
+
+ app.all("/mcp", (req: Request, res: Response) => {
+ void node(req, res, req.body);
+ });
// Stateless mode has no long-lived sessions; GET (SSE stream) and DELETE
// (session teardown) are not applicable. Return 405 per SDK guidance.
@@ -96,10 +80,11 @@ const startHttpServer = async (host: string, port: number) => {
const startStdioServer = async () => {
try {
- const transport = new StdioServerTransport();
-
- const server = createMcpServer();
- await server.connect(transport);
+ // serveStdio owns the transport and the era decision for the
+ // connection: a `server/discover` probe (revision 2026-07-28) pins
+ // the connection modern, while an `initialize` handshake keeps
+ // serving the 2025-era protocol exactly as before.
+ serveStdio(() => createMcpServer());
// Exit cleanly on termination signals so node flushes pending work
// (including NODE_V8_COVERAGE output). Node's default SIGINT/SIGTERM
diff --git a/test/server-discover.test.ts b/test/server-discover.test.ts
new file mode 100644
index 0000000..71da5a9
--- /dev/null
+++ b/test/server-discover.test.ts
@@ -0,0 +1,90 @@
+import { expect, test } from "@playwright/test";
+import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
+import { createMcpHandler } from "@modelcontextprotocol/server";
+import { createMcpServer } from "../src/server";
+
+const discoverRequestBody = (id: string | number) =>
+ JSON.stringify({
+ jsonrpc: "2.0",
+ id,
+ method: "server/discover",
+ params: {
+ _meta: {
+ "io.modelcontextprotocol/protocolVersion": "2026-07-28",
+ "io.modelcontextprotocol/clientInfo": { name: "discover-test", version: "1.0.0" },
+ "io.modelcontextprotocol/clientCapabilities": {},
+ },
+ },
+ });
+
+test("serves server/discover for the 2026-07-28 protocol revision", async () => {
+ const previousTelemetrySetting = process.env.MOBILEMCP_DISABLE_TELEMETRY;
+ process.env.MOBILEMCP_DISABLE_TELEMETRY = "1";
+
+ try {
+ // createMcpHandler is the serving entry production uses; it marks
+ // each request's instance as serving the 2026-07-28 era, which is
+ // what installs the server/discover handler. A hand-constructed
+ // McpServer connected straight to a transport never serves
+ // server/discover (the era gate answers -32601 instead).
+ const handler = createMcpHandler(() => createMcpServer());
+
+ const response = await handler.fetch(
+ new Request("http://localhost/mcp", {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ "Accept": "application/json, text/event-stream",
+ "MCP-Protocol-Version": "2026-07-28",
+ "Mcp-Method": "server/discover",
+ },
+ body: discoverRequestBody("discover-1"),
+ }),
+ );
+
+ expect(response.status).toBe(200);
+ const body = await response.json();
+ expect(body.error).toBeUndefined();
+ expect(body.result.supportedVersions).toContain("2026-07-28");
+ expect(body.result.capabilities.tools).toBeDefined();
+ expect(body.result.resultType).toBe("complete");
+ expect(body.result._meta?.["io.modelcontextprotocol/serverInfo"]?.name).toBe("mobile-mcp");
+ } finally {
+ if (previousTelemetrySetting === undefined) {
+ delete process.env.MOBILEMCP_DISABLE_TELEMETRY;
+ } else {
+ process.env.MOBILEMCP_DISABLE_TELEMETRY = previousTelemetrySetting;
+ }
+ }
+});
+
+test("still serves the legacy initialize handshake", async () => {
+ const previousTelemetrySetting = process.env.MOBILEMCP_DISABLE_TELEMETRY;
+ process.env.MOBILEMCP_DISABLE_TELEMETRY = "1";
+
+ try {
+ const server = createMcpServer();
+ const client = new Client({ name: "legacy-test", version: "1.0.0" });
+ const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+ try {
+ await server.connect(serverTransport);
+ await client.connect(clientTransport);
+
+ expect(client.getProtocolEra()).toBe("legacy");
+ expect(client.getServerVersion()?.name).toBe("mobile-mcp");
+
+ const tools = await client.listTools();
+ expect(tools.tools.length).toBeGreaterThan(0);
+ } finally {
+ await client.close();
+ await server.close();
+ }
+ } finally {
+ if (previousTelemetrySetting === undefined) {
+ delete process.env.MOBILEMCP_DISABLE_TELEMETRY;
+ } else {
+ process.env.MOBILEMCP_DISABLE_TELEMETRY = previousTelemetrySetting;
+ }
+ }
+});