feat: port to v2 concrete-Protocol (#1891) — events shim + sdk-schemas

- events.ts: ProtocolWithEvents extends Protocol (concrete); v1-compat
  envelope-schema overload extracts method+params from .shape and forwards
  to v2's 3-arg form. Typed via EnvelopeRequestHandler/ParamsOf<T>.
  Event dispatcher writes _notificationHandlers directly to preserve the
  v1 sync-dispatch contract (v2's await parseSchema introduces a microtask).
- sdk-schemas.ts (new): envelope/result stubs for SDK *Schema constants
  via specTypeSchema(); typed Env<M,P> so ParamsOf infers concretely.
- app.ts/app-bridge.ts: redirect *Schema imports to ./sdk-schemas;
  delete no-op assert*Capability overrides; convert this.request({method,
  params}, Schema) → this.request('method', params, Schema); autowire
  block uses client.callTool/listResources/etc + 2-arg setNotificationHandler.
- generate-schemas.ts: emit z.custom<T>(isSpecType('T', v)) for SDK
  external types instead of importing dropped *Schema constants.
- message-transport.ts: JSONRPCMessageSchema → parseJSONRPCMessage.
- server/index.test.ts: Pick<McpServer> → as McpServer.

tsc 0, build 0, npm test 276/2/0. app-bridge.test.ts: 88/88 pass.

Author: felixweinberger

package-lock.json

@@ -187,20 +187,24 @@ function postProcess(content: string): string {
   // 1. Rewrite to zod/v4 and add MCP SDK schema imports.
   // zod/v4 aligns with the SDK's own zod import — composing v3 and v4
   // schema instances throws at parse time. See header comment for details.
-  const mcpImports = EXTERNAL_TYPE_SCHEMAS.join(",\n  ");
+  const typeImports = EXTERNAL_TYPE_SCHEMAS.map((s) =>
+    s.replace(/Schema$/, ""),
+  ).join(",\n  ");
   content = content.replace(
     'import { z } from "zod";',
     `import { z } from "zod/v4";
-import {
-  ${mcpImports},
-} from "@modelcontextprotocol/sdk/types.js";`,
+import { isSpecType } from "@modelcontextprotocol/client";
+import type {
+  ${typeImports},
+} from "@modelcontextprotocol/client";`,
   );
 
-  // 2. Remove z.any() placeholders for external types (now imported from MCP SDK)
+  // 2. Replace z.any() placeholders for external types with isSpecType-backed z.custom()
   for (const schema of EXTERNAL_TYPE_SCHEMAS) {
+    const typeName = schema.replace(/Schema$/, "");
     content = content.replace(
-      new RegExp(`(?:export )?const ${schema} = z\\.any\\(\\);\\n?`, "g"),
-      "",
+      new RegExp(`((?:export )?const ${schema}) = z\\.any\\(\\);`, "g"),
+      `$1 = z.custom<${typeName}>((v) => isSpecType("${typeName}", v));`,
     );
   }
 

scripts/generate-schemas.ts

@@ -11,7 +11,7 @@ import {
   ReadResourceResultSchema,
   ResourceListChangedNotificationSchema,
   ToolListChangedNotificationSchema,
-} from "@modelcontextprotocol/client";
+} from "./sdk-schemas";
 
 import { App } from "./app";
 import {
@@ -681,7 +681,8 @@ describe("App <-> AppBridge integration", () => {
 
       // Bridge can send ping via the protocol's request method
       const result = await bridge.request(
-        { method: "ping", params: {} },
+        "ping",
+        {},
         EmptyResultSchema,
       );
 
@@ -795,7 +796,8 @@ describe("App <-> AppBridge integration", () => {
 
       // App sends resources/list request via the protocol's request method
       const result = await app.request(
-        { method: "resources/list", params: requestParams },
+        "resources/list",
+        requestParams,
         ListResourcesResultSchema,
       );
 
@@ -839,7 +841,8 @@ describe("App <-> AppBridge integration", () => {
       await app.connect(appTransport);
 
       const result = await app.request(
-        { method: "resources/read", params: requestParams },
+        "resources/read",
+        requestParams,
         ReadResourceResultSchema,
       );
 
@@ -890,7 +893,8 @@ describe("App <-> AppBridge integration", () => {
       await app.connect(appTransport);
 
       const result = await app.request(
-        { method: "resources/templates/list", params: requestParams },
+        "resources/templates/list",
+        requestParams,
         ListResourceTemplatesResultSchema,
       );
 
@@ -913,7 +917,8 @@ describe("App <-> AppBridge integration", () => {
       await app.connect(appTransport);
 
       const result = await app.request(
-        { method: "prompts/list", params: requestParams },
+        "prompts/list",
+        requestParams,
         ListPromptsResultSchema,
       );
 
@@ -1370,13 +1375,11 @@ describe("isToolVisibilityAppOnly", () => {
         testHostCapabilities,
       );
       bridge2.setRequestHandler(
-        // @ts-expect-error — exercising throw path with raw schema
         { shape: { method: { value: "test/method" } } },
         () => ({}),
       );
       expect(() => {
         bridge2.setRequestHandler(
-          // @ts-expect-error — exercising throw path with raw schema
           { shape: { method: { value: "test/method" } } },
           () => ({}),
         );
@@ -1388,7 +1391,6 @@ describe("isToolVisibilityAppOnly", () => {
       app2.addEventListener("toolinput", () => {});
       expect(() => {
         app2.setNotificationHandler(
-          // @ts-expect-error — exercising throw path with raw schema
           {
             shape: { method: { value: "ui/notifications/tool-input" } },
           },

src/app-bridge.test.ts

@@ -2,42 +2,44 @@ import { Client } from "@modelcontextprotocol/client";
 import { Transport } from "@modelcontextprotocol/client";
 import {
   CallToolRequest,
-  CallToolRequestSchema,
   CallToolResult,
-  CallToolResultSchema,
   EmptyResult,
   Implementation,
   ListPromptsRequest,
-  ListPromptsRequestSchema,
   ListPromptsResult,
-  ListPromptsResultSchema,
   ListResourcesRequest,
-  ListResourcesRequestSchema,
   ListResourcesResult,
-  ListResourcesResultSchema,
   ListResourceTemplatesRequest,
-  ListResourceTemplatesRequestSchema,
   ListResourceTemplatesResult,
-  ListResourceTemplatesResultSchema,
   ListToolsRequest,
-  ListToolsRequestSchema,
-  ListToolsResultSchema,
   LoggingMessageNotification,
-  LoggingMessageNotificationSchema,
   PingRequest,
-  PingRequestSchema,
   PromptListChangedNotification,
-  PromptListChangedNotificationSchema,
   ReadResourceRequest,
-  ReadResourceRequestSchema,
   ReadResourceResult,
-  ReadResourceResultSchema,
   ResourceListChangedNotification,
-  ResourceListChangedNotificationSchema,
   Tool,
   ToolListChangedNotification,
-  ToolListChangedNotificationSchema,
 } from "@modelcontextprotocol/client";
+import {
+  CallToolRequestSchema,
+  CallToolResultSchema,
+  ListPromptsRequestSchema,
+  ListPromptsResultSchema,
+  ListResourcesRequestSchema,
+  ListResourcesResultSchema,
+  ListResourceTemplatesRequestSchema,
+  ListResourceTemplatesResultSchema,
+  ListToolsRequestSchema,
+  ListToolsResultSchema,
+  LoggingMessageNotificationSchema,
+  PingRequestSchema,
+  PromptListChangedNotificationSchema,
+  ReadResourceRequestSchema,
+  ReadResourceResultSchema,
+  ResourceListChangedNotificationSchema,
+  ToolListChangedNotificationSchema,
+} from "./sdk-schemas";
 import {
   ProtocolOptions,
   RequestOptions,
@@ -360,7 +362,7 @@ export class AppBridge extends ProtocolWithEvents<
     this._hostContext = options?.hostContext || {};
 
     this.setRequestHandler(McpUiInitializeRequestSchema, (request) =>
-      this._oninitialize(request),
+      this._oninitialize(request as McpUiInitializeRequest),
     );
 
     this.setRequestHandler(PingRequestSchema, (request, extra) => {
@@ -1312,46 +1314,6 @@ export class AppBridge extends ProtocolWithEvents<
     return this.notification("notifications/prompts/list_changed", params);
   }
 
-  /**
-   * Verify that the guest supports the capability required for the given request method.
-   * @internal
-   */
-  assertCapabilityForMethod(method: AppRequest["method"]): void {
-    // TODO
-  }
-
-  /**
-   * Verify that a request handler is registered and supported for the given method.
-   * @internal
-   */
-  assertRequestHandlerCapability(method: AppRequest["method"]): void {
-    // TODO
-  }
-
-  /**
-   * Verify that the host supports the capability required for the given notification method.
-   * @internal
-   */
-  assertNotificationCapability(method: AppNotification["method"]): void {
-    // TODO
-  }
-
-  /**
-   * Verify that task creation is supported for the given request method.
-   * @internal
-   */
-  protected assertTaskCapability(_method: string): void {
-    throw new Error("Tasks are not supported in MCP Apps");
-  }
-
-  /**
-   * Verify that task handler is supported for the given method.
-   * @internal
-   */
-  protected assertTaskHandlerCapability(_method: string): void {
-    throw new Error("Task handlers are not supported in MCP Apps");
-  }
-
   /**
    * Get the host capabilities passed to the constructor.
    *
@@ -1731,60 +1693,37 @@ export class AppBridge extends ProtocolWithEvents<
       }
 
       if (serverCapabilities.tools) {
-        this.oncalltool = async (params, extra) => {
-          return this._client!.request(
-            { method: "tools/call", params },
-            CallToolResultSchema,
-            { signal: extra.signal },
-          );
-        };
+        this.oncalltool = async (params, extra) =>
+          this._client!.callTool(params, { signal: extra.signal });
         if (serverCapabilities.tools.listChanged) {
           this._client.setNotificationHandler(
-            ToolListChangedNotificationSchema,
+            "notifications/tools/list_changed",
             (n) => this.sendToolListChanged(n.params),
           );
         }
       }
       if (serverCapabilities.resources) {
-        this.onlistresources = async (params, extra) => {
-          return this._client!.request(
-            { method: "resources/list", params },
-            ListResourcesResultSchema,
-            { signal: extra.signal },
-          );
-        };
-        this.onlistresourcetemplates = async (params, extra) => {
-          return this._client!.request(
-            { method: "resources/templates/list", params },
-            ListResourceTemplatesResultSchema,
-            { signal: extra.signal },
-          );
-        };
-        this.onreadresource = async (params, extra) => {
-          return this._client!.request(
-            { method: "resources/read", params },
-            ReadResourceResultSchema,
-            { signal: extra.signal },
-          );
-        };
+        this.onlistresources = async (params, extra) =>
+          this._client!.listResources(params, { signal: extra.signal });
+        this.onlistresourcetemplates = async (params, extra) =>
+          this._client!.listResourceTemplates(params, {
+            signal: extra.signal,
+          });
+        this.onreadresource = async (params, extra) =>
+          this._client!.readResource(params, { signal: extra.signal });
         if (serverCapabilities.resources.listChanged) {
           this._client.setNotificationHandler(
-            ResourceListChangedNotificationSchema,
+            "notifications/resources/list_changed",
             (n) => this.sendResourceListChanged(n.params),
           );
         }
       }
       if (serverCapabilities.prompts) {
-        this.onlistprompts = async (params, extra) => {
-          return this._client!.request(
-            { method: "prompts/list", params },
-            ListPromptsResultSchema,
-            { signal: extra.signal },
-          );
-        };
+        this.onlistprompts = async (params, extra) =>
+          this._client!.listPrompts(params, { signal: extra.signal });
         if (serverCapabilities.prompts.listChanged) {
           this._client.setNotificationHandler(
-            PromptListChangedNotificationSchema,
+            "notifications/prompts/list_changed",
             (n) => this.sendPromptListChanged(n.params),
           );
         }