@tambo-ai/react 0.63.0 → 0.64.0

package/esm/mcp/__tests__/mcp-hooks.test.js

@@ -6,7 +6,7 @@ import { TamboMcpTokenProvider } from "../../providers/tambo-mcp-token-provider"
 import { TamboRegistryProvider } from "../../providers/tambo-registry-provider";
 import { MCPTransport } from "../mcp-client";
 import { TamboMcpProvider, useTamboMcpServers } from "../tambo-mcp-provider";
-import { useTamboMcpPromptList } from "../mcp-hooks";
+import { useTamboMcpPromptList, useTamboMcpResourceList, useTamboMcpResource, } from "../mcp-hooks";
 // Mock the MCP client to avoid ES module issues
 let createImpl = jest.fn();
 jest.mock("../mcp-client", () => ({
@@ -102,16 +102,16 @@ describe("useTamboMcpPromptList - individual server caching", () => {
         await waitFor(() => {
             expect(capturedPrompts.length).toBe(4);
         });
-        // Verify all prompts are present
+        // Verify all prompts are present (with prefixes since we have 2 servers)
         const promptNames = capturedPrompts.map((p) => p.prompt.name);
-        expect(promptNames).toContain("prompt-a1");
-        expect(promptNames).toContain("prompt-a2");
-        expect(promptNames).toContain("prompt-b1");
-        expect(promptNames).toContain("prompt-b2");
+        expect(promptNames).toContain("server-a:prompt-a1");
+        expect(promptNames).toContain("server-a:prompt-a2");
+        expect(promptNames).toContain("server-b:prompt-b1");
+        expect(promptNames).toContain("server-b:prompt-b2");
         // Verify each prompt has the correct server info
-        const promptA1 = capturedPrompts.find((p) => p.prompt.name === "prompt-a1");
+        const promptA1 = capturedPrompts.find((p) => p.prompt.name === "server-a:prompt-a1");
         expect(promptA1?.server.url).toBe("https://server-a.example");
-        const promptB1 = capturedPrompts.find((p) => p.prompt.name === "prompt-b1");
+        const promptB1 = capturedPrompts.find((p) => p.prompt.name === "server-b:prompt-b1");
         expect(promptB1?.server.url).toBe("https://server-b.example");
     });
     it("should remove prompts when a server is removed", async () => {
@@ -188,10 +188,10 @@ describe("useTamboMcpPromptList - individual server caching", () => {
             expect(capturedPrompts.length).toBe(4);
         });
         const initialPromptNames = capturedPrompts.map((p) => p.prompt.name);
-        expect(initialPromptNames).toContain("prompt-a1");
-        expect(initialPromptNames).toContain("prompt-a2");
-        expect(initialPromptNames).toContain("prompt-b1");
-        expect(initialPromptNames).toContain("prompt-b2");
+        expect(initialPromptNames).toContain("server-a:prompt-a1");
+        expect(initialPromptNames).toContain("server-a:prompt-a2");
+        expect(initialPromptNames).toContain("server-b:prompt-b1");
+        expect(initialPromptNames).toContain("server-b:prompt-b2");
         // Remove server B
         rerender(React.createElement(TamboClientContext.Provider, { value: {
                 client: { baseURL: "https://api.tambo.co" },
@@ -208,6 +208,7 @@ describe("useTamboMcpPromptList - individual server caching", () => {
                         ] },
                         React.createElement(Capture, null))))));
         // Wait for prompts to be updated (server B prompts should disappear)
+        // When only 1 server remains, prompts should NOT be prefixed
         await waitFor(() => {
             expect(capturedPrompts.length).toBe(2);
         });
@@ -216,6 +217,7 @@ describe("useTamboMcpPromptList - individual server caching", () => {
         expect(updatedPromptNames).toContain("prompt-a2");
         expect(updatedPromptNames).not.toContain("prompt-b1");
         expect(updatedPromptNames).not.toContain("prompt-b2");
+        expect(updatedPromptNames).not.toContain("server-a:prompt-a1"); // No prefix when only 1 server
         // Verify server B's client was closed
         expect(clientB.close).toHaveBeenCalled();
     });
@@ -370,10 +372,10 @@ describe("useTamboMcpPromptList - individual server caching", () => {
             expect(capturedPrompts.length).toBe(1);
             expect(mcpServersCount).toBe(2); // Both servers should be in the list
         });
-        // Verify only server A's prompts are present
+        // Verify only server A's prompts are present (with prefix since 2 servers configured)
         const promptNames = capturedPrompts.map((p) => p.prompt.name);
-        expect(promptNames).toContain("prompt-a");
-        expect(promptNames).not.toContain("prompt-b");
+        expect(promptNames).toContain("server-a:prompt-a");
+        expect(promptNames).not.toContain("server-b:prompt-b");
     });
     it("should add prompts when a new server is added", async () => {
         const serverAPrompts = {
@@ -458,12 +460,473 @@ describe("useTamboMcpPromptList - individual server caching", () => {
                         ] },
                         React.createElement(Capture, null))))));
         // Wait for server B prompts to be added
+        // Now with 2 servers, prompts should be prefixed
         await waitFor(() => {
             expect(capturedPrompts.length).toBe(2);
         });
         const promptNames = capturedPrompts.map((p) => p.prompt.name);
-        expect(promptNames).toContain("prompt-a");
-        expect(promptNames).toContain("prompt-b");
+        expect(promptNames).toContain("server-a:prompt-a");
+        expect(promptNames).toContain("server-b:prompt-b");
+    });
+});
+describe("useTamboMcpResourceList - resource management", () => {
+    let queryClient;
+    beforeEach(() => {
+        createImpl = jest.fn();
+        queryClient = new QueryClient({
+            defaultOptions: {
+                queries: {
+                    retry: false,
+                },
+            },
+        });
+    });
+    afterEach(() => {
+        queryClient.clear();
+    });
+    it("should fetch and combine resources from multiple servers", async () => {
+        // Mock two servers with different resources
+        const serverAResources = {
+            resources: [
+                {
+                    uri: "file:///home/user/doc1.txt",
+                    name: "Document 1",
+                    mimeType: "text/plain",
+                },
+                {
+                    uri: "file:///home/user/doc2.txt",
+                    name: "Document 2",
+                    mimeType: "text/plain",
+                },
+            ],
+        };
+        const serverBResources = {
+            resources: [
+                {
+                    uri: "file:///workspace/code.js",
+                    name: "Code File",
+                    mimeType: "text/javascript",
+                },
+                {
+                    uri: "file:///workspace/README.md",
+                    name: "Readme",
+                    mimeType: "text/markdown",
+                },
+            ],
+        };
+        const mockClientA = {
+            listTools: jest.fn().mockResolvedValue([]),
+            listPrompts: jest.fn().mockResolvedValue({ prompts: [] }),
+            listResources: jest.fn().mockResolvedValue(serverAResources),
+            close: jest.fn(),
+        };
+        const mockClientB = {
+            listTools: jest.fn().mockResolvedValue([]),
+            listPrompts: jest.fn().mockResolvedValue({ prompts: [] }),
+            listResources: jest.fn().mockResolvedValue(serverBResources),
+            close: jest.fn(),
+        };
+        const clientA = {
+            client: mockClientA,
+            listTools: jest.fn().mockResolvedValue([]),
+            close: jest.fn(),
+        };
+        const clientB = {
+            client: mockClientB,
+            listTools: jest.fn().mockResolvedValue([]),
+            close: jest.fn(),
+        };
+        createImpl.mockImplementation(async (url) => {
+            if (url === "https://server-a.example")
+                return clientA;
+            if (url === "https://server-b.example")
+                return clientB;
+            throw new Error(`Unexpected URL: ${url}`);
+        });
+        let capturedResources = [];
+        const Capture = () => {
+            const { data: resources } = useTamboMcpResourceList();
+            useEffect(() => {
+                if (resources) {
+                    capturedResources = resources;
+                }
+            }, [resources]);
+            return null;
+        };
+        render(React.createElement(TamboClientContext.Provider, { value: {
+                client: { baseURL: "https://api.tambo.co" },
+                queryClient,
+                isUpdatingToken: false,
+            } },
+            React.createElement(TamboRegistryProvider, null,
+                React.createElement(TamboMcpTokenProvider, null,
+                    React.createElement(TamboMcpProvider, { mcpServers: [
+                            {
+                                url: "https://server-a.example",
+                                transport: MCPTransport.SSE,
+                            },
+                            {
+                                url: "https://server-b.example",
+                                transport: MCPTransport.SSE,
+                            },
+                        ] },
+                        React.createElement(Capture, null))))));
+        // Wait for all resources to be loaded
+        await waitFor(() => {
+            expect(capturedResources.length).toBe(4);
+        });
+        // Verify all resources are present (with prefixes since we have 2 servers)
+        const resourceUris = capturedResources.map((r) => r.resource.uri);
+        expect(resourceUris).toContain("server-a:file:///home/user/doc1.txt");
+        expect(resourceUris).toContain("server-a:file:///home/user/doc2.txt");
+        expect(resourceUris).toContain("server-b:file:///workspace/code.js");
+        expect(resourceUris).toContain("server-b:file:///workspace/README.md");
+        // Verify each resource has the correct server info
+        const resource1 = capturedResources.find((r) => r.resource.uri === "server-a:file:///home/user/doc1.txt");
+        expect(resource1?.server.url).toBe("https://server-a.example");
+        const resource2 = capturedResources.find((r) => r.resource.uri === "server-b:file:///workspace/code.js");
+        expect(resource2?.server.url).toBe("https://server-b.example");
+    });
+    it("should not prefix resources when only one server exists", async () => {
+        const serverAResources = {
+            resources: [
+                {
+                    uri: "file:///home/user/doc.txt",
+                    name: "Document",
+                    mimeType: "text/plain",
+                },
+            ],
+        };
+        const mockClientA = {
+            listTools: jest.fn().mockResolvedValue([]),
+            listPrompts: jest.fn().mockResolvedValue({ prompts: [] }),
+            listResources: jest.fn().mockResolvedValue(serverAResources),
+            close: jest.fn(),
+        };
+        const clientA = {
+            client: mockClientA,
+            listTools: jest.fn().mockResolvedValue([]),
+            close: jest.fn(),
+        };
+        createImpl.mockImplementation(async () => clientA);
+        let capturedResources = [];
+        const Capture = () => {
+            const { data: resources } = useTamboMcpResourceList();
+            useEffect(() => {
+                if (resources) {
+                    capturedResources = resources;
+                }
+            }, [resources]);
+            return null;
+        };
+        render(React.createElement(TamboClientContext.Provider, { value: {
+                client: { baseURL: "https://api.tambo.co" },
+                queryClient,
+                isUpdatingToken: false,
+            } },
+            React.createElement(TamboRegistryProvider, null,
+                React.createElement(TamboMcpTokenProvider, null,
+                    React.createElement(TamboMcpProvider, { mcpServers: [
+                            {
+                                url: "https://server-a.example",
+                                transport: MCPTransport.SSE,
+                            },
+                        ] },
+                        React.createElement(Capture, null))))));
+        await waitFor(() => {
+            expect(capturedResources.length).toBe(1);
+        });
+        // No prefix when only 1 server
+        expect(capturedResources[0].resource.uri).toBe("file:///home/user/doc.txt");
+    });
+    it("should remove resource prefixes when a server is removed", async () => {
+        const serverAResources = {
+            resources: [
+                {
+                    uri: "file:///home/user/doc1.txt",
+                    name: "Document 1",
+                    mimeType: "text/plain",
+                },
+                {
+                    uri: "file:///home/user/doc2.txt",
+                    name: "Document 2",
+                    mimeType: "text/plain",
+                },
+            ],
+        };
+        const serverBResources = {
+            resources: [
+                {
+                    uri: "file:///workspace/code.js",
+                    name: "Code File",
+                    mimeType: "text/javascript",
+                },
+            ],
+        };
+        const mockClientA = {
+            listTools: jest.fn().mockResolvedValue([]),
+            listPrompts: jest.fn().mockResolvedValue({ prompts: [] }),
+            listResources: jest.fn().mockResolvedValue(serverAResources),
+            close: jest.fn(),
+        };
+        const mockClientB = {
+            listTools: jest.fn().mockResolvedValue([]),
+            listPrompts: jest.fn().mockResolvedValue({ prompts: [] }),
+            listResources: jest.fn().mockResolvedValue(serverBResources),
+            close: jest.fn(),
+        };
+        const clientA = {
+            client: mockClientA,
+            listTools: jest.fn().mockResolvedValue([]),
+            close: jest.fn(),
+        };
+        const clientB = {
+            client: mockClientB,
+            listTools: jest.fn().mockResolvedValue([]),
+            close: jest.fn(),
+        };
+        createImpl.mockImplementation(async (url) => {
+            if (url === "https://server-a.example")
+                return clientA;
+            if (url === "https://server-b.example")
+                return clientB;
+            throw new Error(`Unexpected URL: ${url}`);
+        });
+        let capturedResources = [];
+        const Capture = () => {
+            const { data: resources } = useTamboMcpResourceList();
+            useEffect(() => {
+                if (resources) {
+                    capturedResources = resources;
+                }
+            }, [resources]);
+            return null;
+        };
+        const { rerender } = render(React.createElement(TamboClientContext.Provider, { value: {
+                client: { baseURL: "https://api.tambo.co" },
+                queryClient,
+                isUpdatingToken: false,
+            } },
+            React.createElement(TamboRegistryProvider, null,
+                React.createElement(TamboMcpTokenProvider, null,
+                    React.createElement(TamboMcpProvider, { mcpServers: [
+                            {
+                                url: "https://server-a.example",
+                                transport: MCPTransport.SSE,
+                            },
+                            {
+                                url: "https://server-b.example",
+                                transport: MCPTransport.SSE,
+                            },
+                        ] },
+                        React.createElement(Capture, null))))));
+        // Wait for all resources to be loaded (prefixed)
+        await waitFor(() => {
+            expect(capturedResources.length).toBe(3);
+        });
+        const initialUris = capturedResources.map((r) => r.resource.uri);
+        expect(initialUris).toContain("server-a:file:///home/user/doc1.txt");
+        expect(initialUris).toContain("server-b:file:///workspace/code.js");
+        // Now remove server B
+        rerender(React.createElement(TamboClientContext.Provider, { value: {
+                client: { baseURL: "https://api.tambo.co" },
+                queryClient,
+                isUpdatingToken: false,
+            } },
+            React.createElement(TamboRegistryProvider, null,
+                React.createElement(TamboMcpTokenProvider, null,
+                    React.createElement(TamboMcpProvider, { mcpServers: [
+                            {
+                                url: "https://server-a.example",
+                                transport: MCPTransport.SSE,
+                            },
+                        ] },
+                        React.createElement(Capture, null))))));
+        // Wait for server B resources to be removed and prefixes stripped
+        await waitFor(() => {
+            expect(capturedResources.length).toBe(2);
+        });
+        const updatedUris = capturedResources.map((r) => r.resource.uri);
+        expect(updatedUris).toContain("file:///home/user/doc1.txt"); // No prefix
+        expect(updatedUris).toContain("file:///home/user/doc2.txt");
+        expect(updatedUris).not.toContain("server-a:file:///home/user/doc1.txt"); // No prefix when only 1 server
+        expect(updatedUris).not.toContain("server-b:file:///workspace/code.js"); // Server B removed
+    });
+});
+describe("useTamboMcpResource - read individual resource", () => {
+    let queryClient;
+    beforeEach(() => {
+        createImpl = jest.fn();
+        queryClient = new QueryClient({
+            defaultOptions: {
+                queries: {
+                    retry: false,
+                },
+            },
+        });
+    });
+    afterEach(() => {
+        queryClient.clear();
+    });
+    it("should read a resource from a single server (unprefixed)", async () => {
+        const serverAResources = {
+            resources: [
+                {
+                    uri: "file:///home/user/doc.txt",
+                    name: "Document",
+                    mimeType: "text/plain",
+                },
+            ],
+        };
+        const resourceContents = {
+            contents: [
+                {
+                    uri: "file:///home/user/doc.txt",
+                    mimeType: "text/plain",
+                    text: "Hello, world!",
+                },
+            ],
+        };
+        const mockClientA = {
+            listTools: jest.fn().mockResolvedValue([]),
+            listPrompts: jest.fn().mockResolvedValue({ prompts: [] }),
+            listResources: jest.fn().mockResolvedValue(serverAResources),
+            readResource: jest.fn().mockResolvedValue(resourceContents),
+            close: jest.fn(),
+        };
+        const clientA = {
+            client: mockClientA,
+            listTools: jest.fn().mockResolvedValue([]),
+            close: jest.fn(),
+        };
+        createImpl.mockImplementation(async () => clientA);
+        let capturedResourceData = null;
+        const Capture = () => {
+            const { data: resourceData } = useTamboMcpResource("file:///home/user/doc.txt");
+            useEffect(() => {
+                if (resourceData) {
+                    capturedResourceData = resourceData;
+                }
+            }, [resourceData]);
+            return null;
+        };
+        render(React.createElement(TamboClientContext.Provider, { value: {
+                client: { baseURL: "https://api.tambo.co" },
+                queryClient,
+                isUpdatingToken: false,
+            } },
+            React.createElement(TamboRegistryProvider, null,
+                React.createElement(TamboMcpTokenProvider, null,
+                    React.createElement(TamboMcpProvider, { mcpServers: [
+                            {
+                                url: "https://server-a.example",
+                                transport: MCPTransport.SSE,
+                            },
+                        ] },
+                        React.createElement(Capture, null))))));
+        await waitFor(() => {
+            expect(capturedResourceData).not.toBeNull();
+        });
+        expect(capturedResourceData.contents[0].text).toBe("Hello, world!");
+        expect(mockClientA.readResource).toHaveBeenCalledWith({
+            uri: "file:///home/user/doc.txt",
+        });
+    });
+    it("should read a resource from multiple servers (prefixed)", async () => {
+        const serverAResources = {
+            resources: [
+                {
+                    uri: "file:///home/user/doc.txt",
+                    name: "Document",
+                    mimeType: "text/plain",
+                },
+            ],
+        };
+        const serverBResources = {
+            resources: [
+                {
+                    uri: "file:///workspace/code.js",
+                    name: "Code",
+                    mimeType: "text/javascript",
+                },
+            ],
+        };
+        const resourceContentsA = {
+            contents: [
+                {
+                    uri: "file:///home/user/doc.txt",
+                    mimeType: "text/plain",
+                    text: "From server A",
+                },
+            ],
+        };
+        const mockClientA = {
+            listTools: jest.fn().mockResolvedValue([]),
+            listPrompts: jest.fn().mockResolvedValue({ prompts: [] }),
+            listResources: jest.fn().mockResolvedValue(serverAResources),
+            readResource: jest.fn().mockResolvedValue(resourceContentsA),
+            close: jest.fn(),
+        };
+        const mockClientB = {
+            listTools: jest.fn().mockResolvedValue([]),
+            listPrompts: jest.fn().mockResolvedValue({ prompts: [] }),
+            listResources: jest.fn().mockResolvedValue(serverBResources),
+            close: jest.fn(),
+        };
+        const clientA = {
+            client: mockClientA,
+            listTools: jest.fn().mockResolvedValue([]),
+            close: jest.fn(),
+        };
+        const clientB = {
+            client: mockClientB,
+            listTools: jest.fn().mockResolvedValue([]),
+            close: jest.fn(),
+        };
+        createImpl.mockImplementation(async (url) => {
+            if (url === "https://server-a.example")
+                return clientA;
+            if (url === "https://server-b.example")
+                return clientB;
+            throw new Error(`Unexpected URL: ${url}`);
+        });
+        let capturedResourceData = null;
+        const Capture = () => {
+            // Request with prefix
+            const { data: resourceData } = useTamboMcpResource("server-a:file:///home/user/doc.txt");
+            useEffect(() => {
+                if (resourceData) {
+                    capturedResourceData = resourceData;
+                }
+            }, [resourceData]);
+            return null;
+        };
+        render(React.createElement(TamboClientContext.Provider, { value: {
+                client: { baseURL: "https://api.tambo.co" },
+                queryClient,
+                isUpdatingToken: false,
+            } },
+            React.createElement(TamboRegistryProvider, null,
+                React.createElement(TamboMcpTokenProvider, null,
+                    React.createElement(TamboMcpProvider, { mcpServers: [
+                            {
+                                url: "https://server-a.example",
+                                transport: MCPTransport.SSE,
+                            },
+                            {
+                                url: "https://server-b.example",
+                                transport: MCPTransport.SSE,
+                            },
+                        ] },
+                        React.createElement(Capture, null))))));
+        await waitFor(() => {
+            expect(capturedResourceData).not.toBeNull();
+        });
+        expect(capturedResourceData.contents[0].text).toBe("From server A");
+        // Verify the prefix was stripped before calling the server
+        expect(mockClientA.readResource).toHaveBeenCalledWith({
+            uri: "file:///home/user/doc.txt",
+        });
     });
 });
 //# sourceMappingURL=mcp-hooks.test.js.map