@tambo-ai/react 0.64.1 → 0.65.2

package/esm/mcp/__tests__/tambo-mcp-provider.test.js

@@ -1,8 +1,8 @@
 import { render, waitFor } from "@testing-library/react";
 import React, { useEffect } from "react";
-import { useTamboClient } from "../../providers/tambo-client-provider";
+import { TamboClientContext, useTamboClient, } from "../../providers/tambo-client-provider";
 import { TamboMcpTokenProvider } from "../../providers/tambo-mcp-token-provider";
-import { useTamboRegistry } from "../../providers/tambo-registry-provider";
+import { TamboRegistryProvider, useTamboRegistry, } from "../../providers/tambo-registry-provider";
 import { MCPClient, MCPTransport } from "../mcp-client";
 import { extractErrorMessage, TamboMcpProvider, useTamboMcpServers, } from "../tambo-mcp-provider";
 // Import the private function for testing by re-exporting it for tests only
@@ -25,13 +25,34 @@ jest.mock("../mcp-client", () => ({
     },
 }));
 // Mock the registry provider to avoid dependency issues
-jest.mock("../../providers/tambo-registry-provider", () => ({
-    useTamboRegistry: jest.fn(),
-}));
+jest.mock("../../providers/tambo-registry-provider", () => {
+    const actual = jest.requireActual("../../providers/tambo-registry-provider");
+    return {
+        ...actual,
+        useTamboRegistry: jest.fn(),
+    };
+});
 // Mock the client provider to avoid dependency issues
-jest.mock("../../providers/tambo-client-provider", () => ({
-    useTamboClient: jest.fn(),
-}));
+jest.mock("../../providers/tambo-client-provider", () => {
+    return {
+        useTamboClient: jest.fn(),
+        TamboClientContext: React.createContext(undefined),
+    };
+});
+// Helper to wrap tests with all required providers (used across multiple describe blocks)
+const TestWrapper = ({ mcpServers, handlers, children }) => {
+    const client = useTamboClient();
+    return (React.createElement(TamboClientContext.Provider, { value: {
+            client,
+            queryClient: {},
+            isUpdatingToken: false,
+            mcpAccessToken: null,
+            setMcpAccessToken: () => { },
+        } },
+        React.createElement(TamboRegistryProvider, { mcpServers: mcpServers },
+            React.createElement(TamboMcpTokenProvider, null,
+                React.createElement(TamboMcpProvider, { handlers: handlers }, children)))));
+};
 describe("extractErrorMessage", () => {
     describe("Array content handling", () => {
         it("should extract text from array content with multiple text items", () => {
@@ -156,17 +177,33 @@ describe("TamboMcpProvider server list changes", () => {
     };
     it("adds a new server when the list grows", async () => {
         let latest = [];
-        const { rerender, getByTestId } = render(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: ["https://a.example"] },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        const { rerender, getByTestId } = render(React.createElement(TamboClientContext.Provider, { value: {
+                client: useTamboClient(),
+                queryClient: {},
+                isUpdatingToken: false,
+                mcpAccessToken: null,
+                setMcpAccessToken: () => { },
+            } },
+            React.createElement(TamboRegistryProvider, { mcpServers: ["https://a.example"] },
+                React.createElement(TamboMcpTokenProvider, null,
+                    React.createElement(TamboMcpProvider, null,
+                        React.createElement(Capture, { onUpdate: (s) => (latest = s) }))))));
         // Wait for initial connection
         await waitFor(() => {
             expect(latest.length).toBe(1);
         });
         // Add new server
-        rerender(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: ["https://a.example", "https://b.example"] },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        rerender(React.createElement(TamboClientContext.Provider, { value: {
+                client: useTamboClient(),
+                queryClient: {},
+                isUpdatingToken: false,
+                mcpAccessToken: null,
+                setMcpAccessToken: () => { },
+            } },
+            React.createElement(TamboRegistryProvider, { mcpServers: ["https://a.example", "https://b.example"] },
+                React.createElement(TamboMcpTokenProvider, null,
+                    React.createElement(TamboMcpProvider, null,
+                        React.createElement(Capture, { onUpdate: (s) => (latest = s) }))))));
         await waitFor(() => {
             expect(latest.length).toBe(2);
             const urls = getByTestId("urls").textContent || "";
@@ -176,16 +213,32 @@ describe("TamboMcpProvider server list changes", () => {
     });
     it("removes a server when the list shrinks", async () => {
         let latest = [];
-        const { rerender, getByTestId } = render(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: ["https://a.example", "https://b.example"] },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        const { rerender, getByTestId } = render(React.createElement(TamboClientContext.Provider, { value: {
+                client: useTamboClient(),
+                queryClient: {},
+                isUpdatingToken: false,
+                mcpAccessToken: null,
+                setMcpAccessToken: () => { },
+            } },
+            React.createElement(TamboRegistryProvider, { mcpServers: ["https://a.example", "https://b.example"] },
+                React.createElement(TamboMcpTokenProvider, null,
+                    React.createElement(TamboMcpProvider, null,
+                        React.createElement(Capture, { onUpdate: (s) => (latest = s) }))))));
         await waitFor(() => {
             expect(latest.length).toBe(2);
         });
         // Remove one server
-        rerender(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: ["https://a.example"] },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        rerender(React.createElement(TamboClientContext.Provider, { value: {
+                client: useTamboClient(),
+                queryClient: {},
+                isUpdatingToken: false,
+                mcpAccessToken: null,
+                setMcpAccessToken: () => { },
+            } },
+            React.createElement(TamboRegistryProvider, { mcpServers: ["https://a.example"] },
+                React.createElement(TamboMcpTokenProvider, null,
+                    React.createElement(TamboMcpProvider, null,
+                        React.createElement(Capture, { onUpdate: (s) => (latest = s) }))))));
         await waitFor(() => {
             expect(latest.length).toBe(1);
             const urls = getByTestId("urls").textContent || "";
@@ -199,9 +252,8 @@ describe("TamboMcpProvider server list changes", () => {
             { url: "https://a.example", transport: MCPTransport.SSE },
             { url: "https://b.example", transport: MCPTransport.SSE },
         ];
-        const { rerender } = render(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: initial },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        const { rerender } = render(React.createElement(TestWrapper, { mcpServers: initial },
+            React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
         await waitFor(() => {
             expect(latest.length).toBe(2);
         });
@@ -210,9 +262,8 @@ describe("TamboMcpProvider server list changes", () => {
             { url: "https://a.example", transport: MCPTransport.SSE },
             { url: "https://b.example", transport: MCPTransport.SSE },
         ];
-        rerender(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: same },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        rerender(React.createElement(TestWrapper, { mcpServers: same },
+            React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
         await waitFor(() => {
             expect(latest.length).toBe(2);
             const urls = latest.map((s) => s.url).sort();
@@ -227,9 +278,8 @@ describe("TamboMcpProvider server list changes", () => {
         MCPClient.create = createSpy;
         let latest = [];
         const initial = [{ url: "https://a.example", transport: MCPTransport.SSE }];
-        const { rerender } = render(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: initial },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        const { rerender } = render(React.createElement(TestWrapper, { mcpServers: initial },
+            React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
         await waitFor(() => {
             expect(latest.length).toBe(1);
         });
@@ -238,9 +288,8 @@ describe("TamboMcpProvider server list changes", () => {
         const firstClient = latest[0].client;
         // Pass a new array with same server
         const same = [{ url: "https://a.example", transport: MCPTransport.SSE }];
-        rerender(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: same },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        rerender(React.createElement(TestWrapper, { mcpServers: same },
+            React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
         await waitFor(() => {
             expect(latest.length).toBe(1);
         });
@@ -257,17 +306,33 @@ describe("TamboMcpProvider server list changes", () => {
         });
         MCPClient.create = createSpy;
         let latest = [];
-        const { rerender } = render(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: ["https://a.example", "https://b.example"] },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        const { rerender } = render(React.createElement(TamboClientContext.Provider, { value: {
+                client: useTamboClient(),
+                queryClient: {},
+                isUpdatingToken: false,
+                mcpAccessToken: null,
+                setMcpAccessToken: () => { },
+            } },
+            React.createElement(TamboRegistryProvider, { mcpServers: ["https://a.example", "https://b.example"] },
+                React.createElement(TamboMcpTokenProvider, null,
+                    React.createElement(TamboMcpProvider, null,
+                        React.createElement(Capture, { onUpdate: (s) => (latest = s) }))))));
         await waitFor(() => {
             expect(latest.length).toBe(2);
         });
         expect(closeSpy).not.toHaveBeenCalled();
         // Remove one server
-        rerender(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: ["https://a.example"] },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        rerender(React.createElement(TamboClientContext.Provider, { value: {
+                client: useTamboClient(),
+                queryClient: {},
+                isUpdatingToken: false,
+                mcpAccessToken: null,
+                setMcpAccessToken: () => { },
+            } },
+            React.createElement(TamboRegistryProvider, { mcpServers: ["https://a.example"] },
+                React.createElement(TamboMcpTokenProvider, null,
+                    React.createElement(TamboMcpProvider, null,
+                        React.createElement(Capture, { onUpdate: (s) => (latest = s) }))))));
         await waitFor(() => {
             expect(latest.length).toBe(1);
         });
@@ -282,9 +347,17 @@ describe("TamboMcpProvider server list changes", () => {
         });
         MCPClient.create = createSpy;
         let latest = [];
-        const { unmount } = render(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: ["https://a.example", "https://b.example"] },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        const { unmount } = render(React.createElement(TamboClientContext.Provider, { value: {
+                client: useTamboClient(),
+                queryClient: {},
+                isUpdatingToken: false,
+                mcpAccessToken: null,
+                setMcpAccessToken: () => { },
+            } },
+            React.createElement(TamboRegistryProvider, { mcpServers: ["https://a.example", "https://b.example"] },
+                React.createElement(TamboMcpTokenProvider, null,
+                    React.createElement(TamboMcpProvider, null,
+                        React.createElement(Capture, { onUpdate: (s) => (latest = s) }))))));
         await waitFor(() => {
             expect(latest.length).toBe(2);
         });
@@ -307,15 +380,14 @@ describe("TamboMcpProvider server list changes", () => {
         });
         MCPClient.create = createSpy;
         let latest = [];
-        const { rerender } = render(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: [
-                    {
-                        url: "https://a.example",
-                        transport: MCPTransport.SSE,
-                        customHeaders: { Authorization: "Bearer token1" },
-                    },
-                ] },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        const { rerender } = render(React.createElement(TestWrapper, { mcpServers: [
+                {
+                    url: "https://a.example",
+                    transport: MCPTransport.SSE,
+                    customHeaders: { Authorization: "Bearer token1" },
+                },
+            ] },
+            React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
         await waitFor(() => {
             expect(latest.length).toBe(1);
             expect(createSpy).toHaveBeenCalledTimes(1);
@@ -323,15 +395,14 @@ describe("TamboMcpProvider server list changes", () => {
         const firstClientId = latest[0].client?.id;
         expect(firstClientId).toBe(1);
         // Change the customHeaders
-        rerender(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: [
-                    {
-                        url: "https://a.example",
-                        transport: MCPTransport.SSE,
-                        customHeaders: { Authorization: "Bearer token2" },
-                    },
-                ] },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        rerender(React.createElement(TestWrapper, { mcpServers: [
+                {
+                    url: "https://a.example",
+                    transport: MCPTransport.SSE,
+                    customHeaders: { Authorization: "Bearer token2" },
+                },
+            ] },
+            React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
         // Wait for old client to be closed and new client to be created
         await waitFor(() => {
             expect(closeSpy).toHaveBeenCalledTimes(1);
@@ -383,13 +454,12 @@ describe("TamboMcpProvider handler support", () => {
             elicitation: mockElicitationHandler,
         };
         let latest = [];
-        render(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: ["https://test.example"], handlers: handlers },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        render(React.createElement(TestWrapper, { mcpServers: ["https://test.example"], handlers: handlers },
+            React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
         await waitFor(() => {
             expect(latest.length).toBe(1);
         });
-        // Verify MCPClient.create was called
+        // Verify MCPClient.create was called with an HTTP transport and wrapped handler
         expect(createSpy).toHaveBeenCalledWith("https://test.example", MCPTransport.HTTP, undefined, undefined, undefined, expect.objectContaining({
             elicitation: expect.any(Function),
         }));
@@ -405,7 +475,7 @@ describe("TamboMcpProvider handler support", () => {
         await passedHandlers.elicitation(mockRequest, mockExtra);
         expect(mockElicitationHandler).toHaveBeenCalledWith(mockRequest, mockExtra, expect.objectContaining({
             url: "https://test.example",
-            transport: MCPTransport.HTTP,
+            serverKey: "test",
         }));
     });
     it("should pass provider-level sampling handler to MCPClient.create", async () => {
@@ -419,13 +489,12 @@ describe("TamboMcpProvider handler support", () => {
             sampling: mockSamplingHandler,
         };
         let latest = [];
-        render(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: ["https://test.example"], handlers: handlers },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        render(React.createElement(TestWrapper, { mcpServers: ["https://test.example"], handlers: handlers },
+            React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
         await waitFor(() => {
             expect(latest.length).toBe(1);
         });
-        // Verify MCPClient.create was called with sampling handler
+        // Verify MCPClient.create was called with HTTP transport and sampling handler
         expect(createSpy).toHaveBeenCalledWith("https://test.example", MCPTransport.HTTP, undefined, undefined, undefined, expect.objectContaining({
             sampling: expect.any(Function),
         }));
@@ -442,7 +511,7 @@ describe("TamboMcpProvider handler support", () => {
         await passedHandlers.sampling(mockRequest, mockExtra);
         expect(mockSamplingHandler).toHaveBeenCalledWith(mockRequest, mockExtra, expect.objectContaining({
             url: "https://test.example",
-            transport: MCPTransport.HTTP,
+            serverKey: "test",
         }));
     });
     it("should allow per-server handlers to override provider-level handlers", async () => {
@@ -456,16 +525,15 @@ describe("TamboMcpProvider handler support", () => {
             elicitation: providerElicitationHandler,
         };
         let latest = [];
-        render(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: [
-                    {
-                        url: "https://test.example",
-                        handlers: {
-                            elicitation: serverElicitationHandler,
-                        },
+        render(React.createElement(TestWrapper, { mcpServers: [
+                {
+                    url: "https://test.example",
+                    handlers: {
+                        elicitation: serverElicitationHandler,
                     },
-                ], handlers: handlers },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+                },
+            ], handlers: handlers },
+            React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
         await waitFor(() => {
             expect(latest.length).toBe(1);
         });
@@ -481,12 +549,11 @@ describe("TamboMcpProvider handler support", () => {
             elicitation: mockElicitationHandler,
         };
         let latest = [];
-        render(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: [
-                    { url: "https://server-a.example", name: "Server A" },
-                    { url: "https://server-b.example", name: "Server B" },
-                ], handlers: handlers },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        render(React.createElement(TestWrapper, { mcpServers: [
+                { url: "https://server-a.example", name: "Server A" },
+                { url: "https://server-b.example", name: "Server B" },
+            ], handlers: handlers },
+            React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
         await waitFor(() => {
             expect(latest.length).toBe(2);
         });
@@ -522,16 +589,14 @@ describe("TamboMcpProvider handler support", () => {
             content: [{ type: "text", text: "updated" }],
         });
         let latest = [];
-        const { rerender } = render(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: ["https://test.example"], handlers: { elicitation: initialHandler } },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        const { rerender } = render(React.createElement(TestWrapper, { mcpServers: ["https://test.example"], handlers: { elicitation: initialHandler } },
+            React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
         await waitFor(() => {
             expect(latest.length).toBe(1);
         });
         // Update the handlers
-        rerender(React.createElement(TamboMcpTokenProvider, null,
-            React.createElement(TamboMcpProvider, { mcpServers: ["https://test.example"], handlers: { elicitation: updatedHandler } },
-                React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+        rerender(React.createElement(TestWrapper, { mcpServers: ["https://test.example"], handlers: { elicitation: updatedHandler } },
+            React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
         await waitFor(() => {
             expect(mockClient.updateElicitationHandler).toHaveBeenCalled();
         });
@@ -564,9 +629,8 @@ describe("TamboMcpProvider serverKey derivation and tool prefixing", () => {
                 close: jest.fn(),
             });
             let latest = [];
-            render(React.createElement(TamboMcpTokenProvider, null,
-                React.createElement(TamboMcpProvider, { mcpServers: ["https://mcp.linear.app/mcp"] },
-                    React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+            render(React.createElement(TestWrapper, { mcpServers: ["https://mcp.linear.app/mcp"] },
+                React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
             await waitFor(() => {
                 expect(latest.length).toBe(1);
                 expect(latest[0].serverKey).toBe("linear");
@@ -578,14 +642,13 @@ describe("TamboMcpProvider serverKey derivation and tool prefixing", () => {
                 close: jest.fn(),
             });
             let latest = [];
-            render(React.createElement(TamboMcpTokenProvider, null,
-                React.createElement(TamboMcpProvider, { mcpServers: [
-                        {
-                            url: "https://mcp.linear.app/mcp",
-                            serverKey: "custom-key",
-                        },
-                    ] },
-                    React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+            render(React.createElement(TestWrapper, { mcpServers: [
+                    {
+                        url: "https://mcp.linear.app/mcp",
+                        serverKey: "custom-key",
+                    },
+                ] },
+                React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
             await waitFor(() => {
                 expect(latest.length).toBe(1);
                 expect(latest[0].serverKey).toBe("custom-key");
@@ -605,9 +668,8 @@ describe("TamboMcpProvider serverKey derivation and tool prefixing", () => {
             ];
             for (const { url, expected } of testCases) {
                 let latest = [];
-                const { unmount } = render(React.createElement(TamboMcpTokenProvider, null,
-                    React.createElement(TamboMcpProvider, { mcpServers: [url] },
-                        React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+                const { unmount } = render(React.createElement(TestWrapper, { mcpServers: [url] },
+                    React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
                 await waitFor(() => {
                     expect(latest.length).toBe(1);
                     expect(latest[0].serverKey).toBe(expected);
@@ -627,9 +689,8 @@ describe("TamboMcpProvider serverKey derivation and tool prefixing", () => {
                 close: jest.fn(),
             });
             let latest = [];
-            render(React.createElement(TamboMcpTokenProvider, null,
-                React.createElement(TamboMcpProvider, { mcpServers: ["https://mcp.linear.app/mcp"] },
-                    React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+            render(React.createElement(TestWrapper, { mcpServers: ["https://mcp.linear.app/mcp"] },
+                React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
             await waitFor(() => {
                 expect(latest.length).toBe(1);
                 expect(mockRegisterTool).toHaveBeenCalledWith(expect.objectContaining({
@@ -647,12 +708,8 @@ describe("TamboMcpProvider serverKey derivation and tool prefixing", () => {
                 close: jest.fn(),
             });
             let latest = [];
-            render(React.createElement(TamboMcpTokenProvider, null,
-                React.createElement(TamboMcpProvider, { mcpServers: [
-                        "https://mcp.linear.app/mcp",
-                        "https://api.github.com",
-                    ] },
-                    React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+            render(React.createElement(TestWrapper, { mcpServers: ["https://mcp.linear.app/mcp", "https://api.github.com"] },
+                React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
             await waitFor(() => {
                 expect(latest.length).toBe(2);
                 // Check that tools are registered with prefixed names
@@ -676,15 +733,14 @@ describe("TamboMcpProvider serverKey derivation and tool prefixing", () => {
                 close: jest.fn(),
             });
             let latest = [];
-            render(React.createElement(TamboMcpTokenProvider, null,
-                React.createElement(TamboMcpProvider, { mcpServers: [
-                        {
-                            url: "https://mcp.linear.app/mcp",
-                            serverKey: "my-server",
-                        },
-                        "https://api.github.com",
-                    ] },
-                    React.createElement(Capture, { onUpdate: (s) => (latest = s) }))));
+            render(React.createElement(TestWrapper, { mcpServers: [
+                    {
+                        url: "https://mcp.linear.app/mcp",
+                        serverKey: "my-server",
+                    },
+                    "https://api.github.com",
+                ] },
+                React.createElement(Capture, { onUpdate: (s) => (latest = s) })));
             await waitFor(() => {
                 expect(latest.length).toBe(2);
                 const calls = mockRegisterTool.mock.calls;