@tambo-ai/react 0.67.1 → 0.69.0

package/dist/providers/__tests__/thread-input-resource-resolution.test.js

@@ -0,0 +1,592 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_query_1 = require("@tanstack/react-query");
+const react_1 = require("@testing-library/react");
+const react_2 = __importDefault(require("react"));
+const mcp_constants_1 = require("../../mcp/mcp-constants");
+const tambo_provider_1 = require("../tambo-provider");
+const tambo_thread_input_provider_1 = require("../tambo-thread-input-provider");
+// Mock the Tambo client provider to avoid needing real API credentials
+jest.mock("../tambo-client-provider", () => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const ReactModule = require("react");
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { QueryClient: QC } = require("@tanstack/react-query");
+    const mockQueryClient = new QC();
+    const MockContext = ReactModule.createContext({
+        client: {},
+        queryClient: mockQueryClient,
+        isUpdatingToken: false,
+    });
+    return {
+        TamboClientProvider: ({ children }) => (react_2.default.createElement(MockContext.Provider, { value: {
+                client: {},
+                queryClient: mockQueryClient,
+                isUpdatingToken: false,
+            } }, children)),
+        TamboClientContext: MockContext,
+        useTamboClient: () => ({
+            client: {},
+            queryClient: mockQueryClient,
+            isUpdatingToken: false,
+        }),
+    };
+});
+// Mock the thread provider to capture sendThreadMessage calls
+const mockSendThreadMessage = jest.fn();
+const mockContextKey = "test-context-key";
+jest.mock("../tambo-thread-provider", () => ({
+    TamboThreadProvider: ({ children }) => children,
+    useTamboThread: () => ({
+        thread: { id: "test-thread-id" },
+        sendThreadMessage: mockSendThreadMessage,
+        contextKey: mockContextKey,
+    }),
+}));
+// Mock servers array - will be updated per test
+let mockServers = [];
+// Mock the MCP provider to avoid real MCP connections
+jest.mock("../../mcp/tambo-mcp-provider", () => ({
+    TamboMcpProvider: ({ children }) => children,
+    useTamboMcpServers: () => mockServers,
+}));
+// Mock the MCP token provider
+jest.mock("../tambo-mcp-token-provider", () => ({
+    TamboMcpTokenProvider: ({ children }) => children,
+    useTamboMcpToken: () => ({
+        mcpAccessToken: null,
+        tamboBaseUrl: null,
+    }),
+}));
+// Helper to create internal server
+const createMockInternalServer = (serverKey) => ({
+    key: serverKey,
+    serverKey,
+    url: "https://api.tambo.ai/mcp",
+    name: "__tambo_internal_mcp_server__",
+    transport: "http",
+    serverType: mcp_constants_1.ServerType.TAMBO_INTERNAL,
+    connectionError: undefined, // Internal servers resolved by backend
+});
+// Mock the message images hook
+jest.mock("../../hooks/use-message-images", () => ({
+    useMessageImages: () => ({
+        images: [],
+        addImage: jest.fn(),
+        addImages: jest.fn(),
+        removeImage: jest.fn(),
+        clearImages: jest.fn(),
+    }),
+}));
+// Mock the mutation hook to execute the mutation function directly
+jest.mock("../../hooks/react-query-hooks", () => ({
+    useTamboMutation: ({ mutationFn }) => ({
+        mutateAsync: mutationFn,
+        mutate: mutationFn,
+        isLoading: false,
+        isError: false,
+        isSuccess: false,
+        error: null,
+        reset: jest.fn(),
+    }),
+}));
+describe("TamboProvider - Resource Content Resolution Integration", () => {
+    let queryClient;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockSendThreadMessage.mockResolvedValue(undefined);
+        // Default: no MCP servers (registry resources don't need a server entry)
+        mockServers = [];
+        queryClient = new react_query_1.QueryClient({
+            defaultOptions: {
+                queries: { retry: false },
+                mutations: { retry: false },
+            },
+        });
+    });
+    afterEach(() => {
+        queryClient.clear();
+        mockServers = [];
+    });
+    const createWrapper = (options) => {
+        function Wrapper({ children }) {
+            return (react_2.default.createElement(react_query_1.QueryClientProvider, { client: queryClient },
+                react_2.default.createElement(tambo_provider_1.TamboProvider, { apiKey: "test-api-key", tamboUrl: "https://api.tambo.ai", listResources: options?.listResources, 
+                    // Cast to any because test mocks return simplified types
+                    getResource: options?.getResource, resources: options?.resources, contextKey: mockContextKey }, children)));
+        }
+        return Wrapper;
+    };
+    it("should resolve registry resource content when submitting a message", async () => {
+        const mockGetResource = jest.fn().mockResolvedValue({
+            contents: [
+                {
+                    uri: "file:///my-document.txt",
+                    mimeType: "text/plain",
+                    text: "This is the document content from the registry",
+                },
+            ],
+        });
+        const mockListResources = jest.fn().mockResolvedValue([
+            {
+                uri: "file:///my-document.txt",
+                name: "My Document",
+                mimeType: "text/plain",
+            },
+        ]);
+        const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_input_provider_1.useTamboThreadInput)(), {
+            wrapper: createWrapper({
+                listResources: mockListResources,
+                getResource: mockGetResource,
+            }),
+        });
+        // Set the input value with a registry resource reference
+        (0, react_1.act)(() => {
+            result.current.setValue("Show me the contents of @registry:file:///my-document.txt in a table");
+        });
+        // Submit the message
+        await (0, react_1.act)(async () => {
+            await result.current.submit();
+        });
+        // Verify getResource was called with the correct URI (without the registry: prefix)
+        expect(mockGetResource).toHaveBeenCalledWith("file:///my-document.txt");
+        // Verify sendThreadMessage was called with the resolved content
+        expect(mockSendThreadMessage).toHaveBeenCalledTimes(1);
+        const [, options] = mockSendThreadMessage.mock.calls[0];
+        const content = options.content;
+        // Should have: text "Show me the contents of ", resource with resolved content, text " in a table"
+        expect(content).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "Show me the contents of ",
+          "type": "text",
+        },
+        {
+          "resource": {
+            "mimeType": "text/plain",
+            "text": "This is the document content from the registry",
+            "uri": "file:///my-document.txt",
+          },
+          "type": "resource",
+        },
+        {
+          "text": " in a table",
+          "type": "text",
+        },
+      ]
+    `);
+    });
+    it("should resolve multiple registry resources in a single message", async () => {
+        const mockGetResource = jest
+            .fn()
+            .mockImplementation(async (uri) => {
+            if (uri === "file:///doc1.txt") {
+                return { contents: [{ uri, text: "Content of doc1" }] };
+            }
+            if (uri === "file:///doc2.txt") {
+                return { contents: [{ uri, text: "Content of doc2" }] };
+            }
+            return null;
+        });
+        const mockListResources = jest.fn().mockResolvedValue([]);
+        const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_input_provider_1.useTamboThreadInput)(), {
+            wrapper: createWrapper({
+                listResources: mockListResources,
+                getResource: mockGetResource,
+            }),
+        });
+        (0, react_1.act)(() => {
+            result.current.setValue("Compare @registry:file:///doc1.txt with @registry:file:///doc2.txt");
+        });
+        await (0, react_1.act)(async () => {
+            await result.current.submit();
+        });
+        // Both resources should have been fetched
+        expect(mockGetResource).toHaveBeenCalledWith("file:///doc1.txt");
+        expect(mockGetResource).toHaveBeenCalledWith("file:///doc2.txt");
+        const [, options] = mockSendThreadMessage.mock.calls[0];
+        const content = options.content;
+        expect(content).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "Compare ",
+          "type": "text",
+        },
+        {
+          "resource": {
+            "text": "Content of doc1",
+            "uri": "file:///doc1.txt",
+          },
+          "type": "resource",
+        },
+        {
+          "text": " with ",
+          "type": "text",
+        },
+        {
+          "resource": {
+            "text": "Content of doc2",
+            "uri": "file:///doc2.txt",
+          },
+          "type": "resource",
+        },
+      ]
+    `);
+    });
+    it("should resolve registry resource with blob content", async () => {
+        const mockGetResource = jest.fn().mockResolvedValue({
+            contents: [
+                {
+                    uri: "file:///image.png",
+                    mimeType: "image/png",
+                    blob: "base64encodedimagedata",
+                },
+            ],
+        });
+        const mockListResources = jest.fn().mockResolvedValue([]);
+        const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_input_provider_1.useTamboThreadInput)(), {
+            wrapper: createWrapper({
+                listResources: mockListResources,
+                getResource: mockGetResource,
+            }),
+        });
+        (0, react_1.act)(() => {
+            result.current.setValue("Analyze @registry:file:///image.png");
+        });
+        await (0, react_1.act)(async () => {
+            await result.current.submit();
+        });
+        const [, options] = mockSendThreadMessage.mock.calls[0];
+        const content = options.content;
+        expect(content).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "Analyze ",
+          "type": "text",
+        },
+        {
+          "resource": {
+            "blob": "base64encodedimagedata",
+            "mimeType": "image/png",
+            "uri": "file:///image.png",
+          },
+          "type": "resource",
+        },
+      ]
+    `);
+    });
+    it("should continue with submission even if resource fetch fails (graceful fallback)", async () => {
+        const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
+        const mockGetResource = jest
+            .fn()
+            .mockRejectedValue(new Error("Resource fetch failed"));
+        const mockListResources = jest.fn().mockResolvedValue([]);
+        const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_input_provider_1.useTamboThreadInput)(), {
+            wrapper: createWrapper({
+                listResources: mockListResources,
+                getResource: mockGetResource,
+            }),
+        });
+        (0, react_1.act)(() => {
+            result.current.setValue("Check @registry:file:///missing.txt");
+        });
+        // Should not throw, should continue with submission
+        await (0, react_1.act)(async () => {
+            await result.current.submit();
+        });
+        // Resource fetch was attempted
+        expect(mockGetResource).toHaveBeenCalledWith("file:///missing.txt");
+        // Warning should be logged
+        expect(consoleSpy).toHaveBeenCalledWith("Failed to fetch resource content for registry:file:///missing.txt:", expect.any(Error));
+        // Message should still be sent (without the resolved content)
+        expect(mockSendThreadMessage).toHaveBeenCalledTimes(1);
+        const [, options] = mockSendThreadMessage.mock.calls[0];
+        const content = options.content;
+        // Resource should be present but without text/blob content
+        expect(content).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "Check ",
+          "type": "text",
+        },
+        {
+          "resource": {
+            "uri": "file:///missing.txt",
+          },
+          "type": "resource",
+        },
+      ]
+    `);
+        consoleSpy.mockRestore();
+    });
+    it("should NOT resolve internal server resources (serverType: TAMBO_INTERNAL)", async () => {
+        // Add internal server to mock servers
+        mockServers = [createMockInternalServer("tambo-abc123")];
+        const mockGetResource = jest.fn().mockResolvedValue({
+            contents: [{ uri: "tambo:test://resource/1", text: "Should not fetch" }],
+        });
+        const mockListResources = jest.fn().mockResolvedValue([]);
+        const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_input_provider_1.useTamboThreadInput)(), {
+            wrapper: createWrapper({
+                listResources: mockListResources,
+                getResource: mockGetResource,
+            }),
+        });
+        (0, react_1.act)(() => {
+            result.current.setValue("Check @tambo-abc123:tambo:test://internal/resource/1");
+        });
+        await (0, react_1.act)(async () => {
+            await result.current.submit();
+        });
+        // getResource should NOT be called for internal server resources
+        expect(mockGetResource).not.toHaveBeenCalled();
+        // Message should still be sent with resource (but without resolved content)
+        expect(mockSendThreadMessage).toHaveBeenCalledTimes(1);
+        const [, options] = mockSendThreadMessage.mock.calls[0];
+        const content = options.content;
+        expect(content).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "Check ",
+          "type": "text",
+        },
+        {
+          "resource": {
+            "uri": "tambo:test://internal/resource/1",
+          },
+          "type": "resource",
+        },
+      ]
+    `);
+    });
+    it("should handle mixed registry and internal server resources", async () => {
+        // Add internal server
+        mockServers = [createMockInternalServer("tambo-xyz")];
+        const mockGetResource = jest.fn().mockResolvedValue({
+            contents: [{ uri: "file:///registry-doc.txt", text: "Registry content" }],
+        });
+        const mockListResources = jest.fn().mockResolvedValue([]);
+        const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_input_provider_1.useTamboThreadInput)(), {
+            wrapper: createWrapper({
+                listResources: mockListResources,
+                getResource: mockGetResource,
+            }),
+        });
+        (0, react_1.act)(() => {
+            result.current.setValue("@registry:file:///registry-doc.txt and @tambo-xyz:tambo:test://internal");
+        });
+        await (0, react_1.act)(async () => {
+            await result.current.submit();
+        });
+        // Only the registry resource should be fetched
+        expect(mockGetResource).toHaveBeenCalledTimes(1);
+        expect(mockGetResource).toHaveBeenCalledWith("file:///registry-doc.txt");
+        const [, options] = mockSendThreadMessage.mock.calls[0];
+        const content = options.content;
+        expect(content).toMatchInlineSnapshot(`
+      [
+        {
+          "resource": {
+            "text": "Registry content",
+            "uri": "file:///registry-doc.txt",
+          },
+          "type": "resource",
+        },
+        {
+          "text": " and ",
+          "type": "text",
+        },
+        {
+          "resource": {
+            "uri": "tambo:test://internal",
+          },
+          "type": "resource",
+        },
+      ]
+    `);
+    });
+    it("should include resource names when provided in submit options", async () => {
+        const mockGetResource = jest.fn().mockResolvedValue({
+            contents: [
+                {
+                    uri: "file:///doc.txt",
+                    text: "Document content",
+                },
+            ],
+        });
+        const mockListResources = jest.fn().mockResolvedValue([]);
+        const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_input_provider_1.useTamboThreadInput)(), {
+            wrapper: createWrapper({
+                listResources: mockListResources,
+                getResource: mockGetResource,
+            }),
+        });
+        (0, react_1.act)(() => {
+            result.current.setValue("Check @registry:file:///doc.txt");
+        });
+        await (0, react_1.act)(async () => {
+            await result.current.submit({
+                resourceNames: {
+                    "registry:file:///doc.txt": "Important Document.txt",
+                },
+            });
+        });
+        const [, options] = mockSendThreadMessage.mock.calls[0];
+        const content = options.content;
+        expect(content).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "Check ",
+          "type": "text",
+        },
+        {
+          "resource": {
+            "name": "Important Document.txt",
+            "text": "Document content",
+            "uri": "file:///doc.txt",
+          },
+          "type": "resource",
+        },
+      ]
+    `);
+    });
+    it("should handle message without any resource references", async () => {
+        const mockGetResource = jest.fn();
+        const mockListResources = jest.fn().mockResolvedValue([]);
+        const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_input_provider_1.useTamboThreadInput)(), {
+            wrapper: createWrapper({
+                listResources: mockListResources,
+                getResource: mockGetResource,
+            }),
+        });
+        (0, react_1.act)(() => {
+            result.current.setValue("Just a regular message without resources");
+        });
+        await (0, react_1.act)(async () => {
+            await result.current.submit();
+        });
+        // No resource fetch should happen
+        expect(mockGetResource).not.toHaveBeenCalled();
+        // Message should be sent as plain text
+        const [, options] = mockSendThreadMessage.mock.calls[0];
+        const content = options.content;
+        expect(content).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "Just a regular message without resources",
+          "type": "text",
+        },
+      ]
+    `);
+    });
+    it("should handle null returned from getResource", async () => {
+        const mockGetResource = jest.fn().mockResolvedValue(null);
+        const mockListResources = jest.fn().mockResolvedValue([]);
+        const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_input_provider_1.useTamboThreadInput)(), {
+            wrapper: createWrapper({
+                listResources: mockListResources,
+                getResource: mockGetResource,
+            }),
+        });
+        (0, react_1.act)(() => {
+            result.current.setValue("Check @registry:file:///unknown.txt");
+        });
+        await (0, react_1.act)(async () => {
+            await result.current.submit();
+        });
+        expect(mockGetResource).toHaveBeenCalled();
+        const [, options] = mockSendThreadMessage.mock.calls[0];
+        const content = options.content;
+        // Resource should be present but without content
+        expect(content).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "Check ",
+          "type": "text",
+        },
+        {
+          "resource": {
+            "uri": "file:///unknown.txt",
+          },
+          "type": "resource",
+        },
+      ]
+    `);
+    });
+    it("should warn when no resourceSource is available for registry resource", async () => {
+        const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
+        // No listResources/getResource provided
+        const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_input_provider_1.useTamboThreadInput)(), {
+            wrapper: createWrapper(),
+        });
+        (0, react_1.act)(() => {
+            result.current.setValue("Check @registry:file:///doc.txt");
+        });
+        await (0, react_1.act)(async () => {
+            await result.current.submit();
+        });
+        expect(consoleSpy).toHaveBeenCalledWith("No resource source available to resolve registry resource: registry:file:///doc.txt");
+        consoleSpy.mockRestore();
+    });
+    it("should resolve static resources passed via resources prop", async () => {
+        // When using static resources, we need both listResources and getResource
+        // to form the resourceSource, even though the resources are static
+        const mockGetResource = jest.fn().mockResolvedValue({
+            contents: [
+                {
+                    uri: "static://my-static-resource",
+                    text: "Static resource content",
+                    mimeType: "text/plain",
+                },
+            ],
+        });
+        const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_input_provider_1.useTamboThreadInput)(), {
+            wrapper: createWrapper({
+                resources: [
+                    {
+                        uri: "static://my-static-resource",
+                        name: "My Static Resource",
+                        mimeType: "text/plain",
+                    },
+                ],
+                // Need getResource to actually fetch the content
+                getResource: mockGetResource,
+                listResources: async () => [],
+            }),
+        });
+        (0, react_1.act)(() => {
+            result.current.setValue("Show me @registry:static://my-static-resource please");
+        });
+        await (0, react_1.act)(async () => {
+            await result.current.submit();
+        });
+        // getResource should be called to fetch the content
+        expect(mockGetResource).toHaveBeenCalledWith("static://my-static-resource");
+        const [, options] = mockSendThreadMessage.mock.calls[0];
+        const content = options.content;
+        expect(content).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "Show me ",
+          "type": "text",
+        },
+        {
+          "resource": {
+            "mimeType": "text/plain",
+            "text": "Static resource content",
+            "uri": "static://my-static-resource",
+          },
+          "type": "resource",
+        },
+        {
+          "text": " please",
+          "type": "text",
+        },
+      ]
+    `);
+    });
+});
+//# sourceMappingURL=thread-input-resource-resolution.test.js.map