Add setter-based handlers for MCP request/notification forwarding

- Add oncalltool, onlistresources, onlistresourcetemplates, onreadresource, onlistprompts setters for Guest UI → Host requests
- Add sendToolListChanged, sendResourceListChanged, sendPromptListChanged methods for Host → Guest UI notifications
- Refactor connect() to use new setters with inlined callbacks
- Update documentation to clarify optional client parameter behavior
- Remove unused forwardRequest/forwardNotification helper methods
- Add comprehensive tests for AppBridge without MCP client (manual handlers)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: ochafik

src/app-bridge.test.ts

@@ -2,7 +2,17 @@ import { describe, it, expect, beforeEach, afterEach } from "bun:test";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { ServerCapabilities } from "@modelcontextprotocol/sdk/types.js";
-import { EmptyResultSchema } from "@modelcontextprotocol/sdk/types.js";
+import {
+  CallToolResultSchema,
+  EmptyResultSchema,
+  ListPromptsResultSchema,
+  ListResourcesResultSchema,
+  ListResourceTemplatesResultSchema,
+  PromptListChangedNotificationSchema,
+  ReadResourceResultSchema,
+  ResourceListChangedNotificationSchema,
+  ToolListChangedNotificationSchema,
+} from "@modelcontextprotocol/sdk/types.js";
 
 import { App } from "./app";
 import { AppBridge, type McpUiHostCapabilities } from "./app-bridge";
@@ -508,4 +518,189 @@ describe("App <-> AppBridge integration", () => {
       expect(result).toEqual({});
     });
   });
+
+  describe("AppBridge without MCP client (manual handlers)", () => {
+    let app: App;
+    let bridge: AppBridge;
+    let appTransport: InMemoryTransport;
+    let bridgeTransport: InMemoryTransport;
+
+    beforeEach(() => {
+      [appTransport, bridgeTransport] = InMemoryTransport.createLinkedPair();
+      app = new App(testAppInfo, {}, { autoResize: false });
+      // Pass null instead of a client - manual handler registration
+      bridge = new AppBridge(null, testHostInfo, testHostCapabilities);
+    });
+
+    afterEach(async () => {
+      await appTransport.close();
+      await bridgeTransport.close();
+    });
+
+    it("connect() works without client", async () => {
+      await bridge.connect(bridgeTransport);
+      await app.connect(appTransport);
+
+      // Initialization should still work
+      const hostInfo = app.getHostVersion();
+      expect(hostInfo).toEqual(testHostInfo);
+    });
+
+    it("oncalltool setter registers handler for tools/call requests", async () => {
+      const receivedCalls: unknown[] = [];
+      bridge.oncalltool = async (params) => {
+        receivedCalls.push(params);
+        return { content: [{ type: "text", text: "result" }] };
+      };
+
+      await bridge.connect(bridgeTransport);
+      await app.connect(appTransport);
+
+      // App calls a tool via callServerTool
+      const result = await app.callServerTool({
+        name: "test-tool",
+        arguments: { arg: "value" },
+      });
+
+      expect(receivedCalls).toHaveLength(1);
+      expect(receivedCalls[0]).toMatchObject({
+        name: "test-tool",
+        arguments: { arg: "value" },
+      });
+      expect(result.content).toEqual([{ type: "text", text: "result" }]);
+    });
+
+    it("onlistresources setter registers handler for resources/list requests", async () => {
+      const receivedRequests: unknown[] = [];
+      bridge.onlistresources = async (params) => {
+        receivedRequests.push(params);
+        return { resources: [{ uri: "test://resource", name: "Test" }] };
+      };
+
+      await bridge.connect(bridgeTransport);
+      await app.connect(appTransport);
+
+      // App sends resources/list request via the protocol's request method
+      const result = await app.request(
+        { method: "resources/list", params: {} },
+        ListResourcesResultSchema,
+      );
+
+      expect(receivedRequests).toHaveLength(1);
+      expect(result.resources).toEqual([
+        { uri: "test://resource", name: "Test" },
+      ]);
+    });
+
+    it("onreadresource setter registers handler for resources/read requests", async () => {
+      const receivedRequests: unknown[] = [];
+      bridge.onreadresource = async (params) => {
+        receivedRequests.push(params);
+        return { contents: [{ uri: params.uri, text: "content" }] };
+      };
+
+      await bridge.connect(bridgeTransport);
+      await app.connect(appTransport);
+
+      const result = await app.request(
+        { method: "resources/read", params: { uri: "test://resource" } },
+        ReadResourceResultSchema,
+      );
+
+      expect(receivedRequests).toHaveLength(1);
+      expect(receivedRequests[0]).toMatchObject({ uri: "test://resource" });
+      expect(result.contents).toEqual([
+        { uri: "test://resource", text: "content" },
+      ]);
+    });
+
+    it("onlistresourcetemplates setter registers handler for resources/templates/list requests", async () => {
+      const receivedRequests: unknown[] = [];
+      bridge.onlistresourcetemplates = async (params) => {
+        receivedRequests.push(params);
+        return {
+          resourceTemplates: [
+            { uriTemplate: "test://{id}", name: "Test Template" },
+          ],
+        };
+      };
+
+      await bridge.connect(bridgeTransport);
+      await app.connect(appTransport);
+
+      const result = await app.request(
+        { method: "resources/templates/list", params: {} },
+        ListResourceTemplatesResultSchema,
+      );
+
+      expect(receivedRequests).toHaveLength(1);
+      expect(result.resourceTemplates).toEqual([
+        { uriTemplate: "test://{id}", name: "Test Template" },
+      ]);
+    });
+
+    it("onlistprompts setter registers handler for prompts/list requests", async () => {
+      const receivedRequests: unknown[] = [];
+      bridge.onlistprompts = async (params) => {
+        receivedRequests.push(params);
+        return { prompts: [{ name: "test-prompt" }] };
+      };
+
+      await bridge.connect(bridgeTransport);
+      await app.connect(appTransport);
+
+      const result = await app.request(
+        { method: "prompts/list", params: {} },
+        ListPromptsResultSchema,
+      );
+
+      expect(receivedRequests).toHaveLength(1);
+      expect(result.prompts).toEqual([{ name: "test-prompt" }]);
+    });
+
+    it("sendToolListChanged sends notification to app", async () => {
+      const receivedNotifications: unknown[] = [];
+      app.setNotificationHandler(ToolListChangedNotificationSchema, (n) => {
+        receivedNotifications.push(n.params);
+      });
+
+      await bridge.connect(bridgeTransport);
+      await app.connect(appTransport);
+
+      bridge.sendToolListChanged();
+      await flush();
+
+      expect(receivedNotifications).toHaveLength(1);
+    });
+
+    it("sendResourceListChanged sends notification to app", async () => {
+      const receivedNotifications: unknown[] = [];
+      app.setNotificationHandler(ResourceListChangedNotificationSchema, (n) => {
+        receivedNotifications.push(n.params);
+      });
+
+      await bridge.connect(bridgeTransport);
+      await app.connect(appTransport);
+
+      bridge.sendResourceListChanged();
+      await flush();
+
+      expect(receivedNotifications).toHaveLength(1);
+    });
+
+    it("sendPromptListChanged sends notification to app", async () => {
+      const receivedNotifications: unknown[] = [];
+      app.setNotificationHandler(PromptListChangedNotificationSchema, (n) => {
+        receivedNotifications.push(n.params);
+      });
+
+      await bridge.connect(bridgeTransport);
+      await app.connect(appTransport);
+
+      bridge.sendPromptListChanged();
+      await flush();
+
+      expect(receivedNotifications).toHaveLength(1);
+    });
+  });
 });