@tambo-ai/react 0.58.0 → 0.59.0

package/dist/providers/__tests__/tambo-thread-provider.test.js

@@ -11,6 +11,7 @@ const generate_component_response_1 = require("../../model/generate-component-re
 const tools_1 = require("../../testing/tools");
 const tambo_client_provider_1 = require("../tambo-client-provider");
 const tambo_context_helpers_provider_1 = require("../tambo-context-helpers-provider");
+const tambo_mcp_token_provider_1 = require("../tambo-mcp-token-provider");
 const tambo_registry_provider_1 = require("../tambo-registry-provider");
 const tambo_thread_provider_1 = require("../tambo-thread-provider");
 // Mock crypto.randomUUID
@@ -116,7 +117,8 @@ describe("TamboThreadProvider", () => {
                 currentTimeContextHelper: () => null,
                 currentPageContextHelper: () => null,
             } },
-            react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: false }, children))));
+            react_2.default.createElement(tambo_mcp_token_provider_1.TamboMcpTokenProvider, null,
+                react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: false }, children)))));
     beforeEach(() => {
         jest.clearAllMocks();
         // Setup mock query client
@@ -332,7 +334,8 @@ describe("TamboThreadProvider", () => {
                     currentTimeContextHelper: () => null,
                     currentPageContextHelper: () => null,
                 } },
-                react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: false }, children))));
+                react_2.default.createElement(tambo_mcp_token_provider_1.TamboMcpTokenProvider, null,
+                    react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: false }, children)))));
         const mockUnregisteredToolCallResponse = {
             responseMessageDto: {
                 id: "unregistered-tool-call-1",
@@ -430,7 +433,8 @@ describe("TamboThreadProvider", () => {
                         currentTimeContextHelper: () => null,
                         currentPageContextHelper: () => null,
                     } },
-                    react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: true }, children))));
+                    react_2.default.createElement(tambo_mcp_token_provider_1.TamboMcpTokenProvider, null,
+                        react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: true }, children)))));
             const mockStreamResponse = {
                 responseMessageDto: {
                     id: "stream-response",
@@ -491,7 +495,8 @@ describe("TamboThreadProvider", () => {
                         currentTimeContextHelper: () => null,
                         currentPageContextHelper: () => null,
                     } },
-                    react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: true }, children))));
+                    react_2.default.createElement(tambo_mcp_token_provider_1.TamboMcpTokenProvider, null,
+                        react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: true }, children)))));
             const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
                 wrapper: wrapperWithStreaming,
             });
@@ -533,7 +538,8 @@ describe("TamboThreadProvider", () => {
                         currentTimeContextHelper: () => null,
                         currentPageContextHelper: () => null,
                     } },
-                    react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: false }, children))));
+                    react_2.default.createElement(tambo_mcp_token_provider_1.TamboMcpTokenProvider, null,
+                        react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: false }, children)))));
             const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
                 wrapper: wrapperWithoutStreaming,
             });
@@ -575,7 +581,8 @@ describe("TamboThreadProvider", () => {
                         currentTimeContextHelper: () => null,
                         currentPageContextHelper: () => null,
                     } },
-                    react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, null, children))));
+                    react_2.default.createElement(tambo_mcp_token_provider_1.TamboMcpTokenProvider, null,
+                        react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, null, children)))));
             const mockStreamResponse = {
                 responseMessageDto: {
                     id: "stream-response",
@@ -636,7 +643,8 @@ describe("TamboThreadProvider", () => {
                         currentTimeContextHelper: () => null,
                         currentPageContextHelper: () => null,
                     } },
-                    react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: true }, children))));
+                    react_2.default.createElement(tambo_mcp_token_provider_1.TamboMcpTokenProvider, null,
+                        react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: true }, children)))));
             const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
                 wrapper: wrapperWithStreaming,
             });
@@ -680,7 +688,8 @@ describe("TamboThreadProvider", () => {
                         currentTimeContextHelper: () => null,
                         currentPageContextHelper: () => null,
                     } },
-                    react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: false }, children))));
+                    react_2.default.createElement(tambo_mcp_token_provider_1.TamboMcpTokenProvider, null,
+                        react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: false }, children)))));
             const mockStreamResponse = {
                 responseMessageDto: {
                     id: "stream-response",
@@ -849,5 +858,383 @@ describe("TamboThreadProvider", () => {
             expect(result.current.thread.id).toBe("existing-thread-123");
         });
     });
+    describe("transformToContent", () => {
+        it("should use custom transformToContent when provided (non-streaming)", async () => {
+            const mockTransformToContent = jest.fn().mockReturnValue([
+                { type: "text", text: "Custom transformed content" },
+                {
+                    type: "image_url",
+                    image_url: { url: "https://example.com/image.png" },
+                },
+            ]);
+            const customToolRegistry = [
+                {
+                    name: "TestComponent",
+                    component: () => react_2.default.createElement("div", null, "Test"),
+                    description: "Test",
+                    propsSchema: zod_1.z.object({ test: zod_1.z.string() }),
+                    associatedTools: [
+                        {
+                            name: "custom-tool",
+                            tool: jest.fn().mockResolvedValue({ data: "tool result" }),
+                            description: "Tool with custom transform",
+                            toolSchema: zod_1.z
+                                .function()
+                                .args(zod_1.z.string())
+                                .returns(zod_1.z.object({ data: zod_1.z.string() })),
+                            transformToContent: mockTransformToContent,
+                        },
+                    ],
+                },
+            ];
+            const wrapperWithCustomTool = ({ children, }) => (react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: customToolRegistry },
+                react_2.default.createElement(tambo_context_helpers_provider_1.TamboContextHelpersProvider, { contextHelpers: {
+                        currentTimeContextHelper: () => null,
+                        currentPageContextHelper: () => null,
+                    } },
+                    react_2.default.createElement(tambo_mcp_token_provider_1.TamboMcpTokenProvider, null,
+                        react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: false }, children)))));
+            const mockToolCallResponse = {
+                responseMessageDto: {
+                    id: "tool-call-1",
+                    content: [{ type: "text", text: "Tool response" }],
+                    role: "tool",
+                    threadId: "test-thread-1",
+                    toolCallRequest: {
+                        toolName: "custom-tool",
+                        parameters: [{ parameterName: "input", parameterValue: "test" }],
+                    },
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.COMPLETE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            jest
+                .mocked(mockThreadsApi.advanceByID)
+                .mockResolvedValueOnce(mockToolCallResponse)
+                .mockResolvedValueOnce({
+                responseMessageDto: {
+                    id: "final-response",
+                    content: [{ type: "text", text: "Final response" }],
+                    role: "assistant",
+                    threadId: "test-thread-1",
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.COMPLETE,
+                mcpAccessToken: "test-mcp-access-token",
+            });
+            const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
+                wrapper: wrapperWithCustomTool,
+            });
+            await (0, react_1.act)(async () => {
+                await result.current.sendThreadMessage("Use custom tool", {
+                    threadId: "test-thread-1",
+                    streamResponse: false,
+                });
+            });
+            // Verify the tool was called
+            expect(customToolRegistry[0]?.associatedTools?.[0]?.tool).toHaveBeenCalledWith("test");
+            // Verify transformToContent was called with the tool result
+            expect(mockTransformToContent).toHaveBeenCalledWith({
+                data: "tool result",
+            });
+            // Verify the second advance call included the transformed content
+            expect(mockThreadsApi.advanceByID).toHaveBeenCalledTimes(2);
+            expect(mockThreadsApi.advanceByID).toHaveBeenLastCalledWith("test-thread-1", expect.objectContaining({
+                messageToAppend: expect.objectContaining({
+                    content: [
+                        { type: "text", text: "Custom transformed content" },
+                        {
+                            type: "image_url",
+                            image_url: { url: "https://example.com/image.png" },
+                        },
+                    ],
+                    role: "tool",
+                }),
+            }));
+        });
+        it("should use custom async transformToContent when provided (streaming)", async () => {
+            const mockTransformToContent = jest
+                .fn()
+                .mockResolvedValue([
+                { type: "text", text: "Async transformed content" },
+            ]);
+            const customToolRegistry = [
+                {
+                    name: "TestComponent",
+                    component: () => react_2.default.createElement("div", null, "Test"),
+                    description: "Test",
+                    propsSchema: zod_1.z.object({ test: zod_1.z.string() }),
+                    associatedTools: [
+                        {
+                            name: "async-tool",
+                            tool: jest.fn().mockResolvedValue({ data: "async tool result" }),
+                            description: "Tool with async transform",
+                            toolSchema: zod_1.z
+                                .function()
+                                .args(zod_1.z.string())
+                                .returns(zod_1.z.object({ data: zod_1.z.string() })),
+                            transformToContent: mockTransformToContent,
+                        },
+                    ],
+                },
+            ];
+            const wrapperWithAsyncTool = ({ children, }) => (react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: customToolRegistry },
+                react_2.default.createElement(tambo_context_helpers_provider_1.TamboContextHelpersProvider, { contextHelpers: {
+                        currentTimeContextHelper: () => null,
+                        currentPageContextHelper: () => null,
+                    } },
+                    react_2.default.createElement(tambo_mcp_token_provider_1.TamboMcpTokenProvider, null,
+                        react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: true }, children)))));
+            const mockToolCallChunk = {
+                responseMessageDto: {
+                    id: "tool-call-chunk",
+                    content: [{ type: "text", text: "Tool call" }],
+                    role: "tool",
+                    threadId: "test-thread-1",
+                    toolCallRequest: {
+                        toolName: "async-tool",
+                        parameters: [
+                            { parameterName: "input", parameterValue: "async-test" },
+                        ],
+                    },
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.COMPLETE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            const mockFinalChunk = {
+                responseMessageDto: {
+                    id: "final-chunk",
+                    content: [{ type: "text", text: "Final streaming response" }],
+                    role: "assistant",
+                    threadId: "test-thread-1",
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.COMPLETE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            const mockAsyncIterator = {
+                [Symbol.asyncIterator]: async function* () {
+                    yield mockToolCallChunk;
+                    yield mockFinalChunk;
+                },
+            };
+            jest
+                .mocked(typescript_sdk_1.advanceStream)
+                .mockResolvedValueOnce(mockAsyncIterator)
+                .mockResolvedValueOnce({
+                [Symbol.asyncIterator]: async function* () {
+                    yield mockFinalChunk;
+                },
+            });
+            const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
+                wrapper: wrapperWithAsyncTool,
+            });
+            await (0, react_1.act)(async () => {
+                await result.current.sendThreadMessage("Use async tool", {
+                    threadId: "test-thread-1",
+                    streamResponse: true,
+                });
+            });
+            // Verify the tool was called
+            expect(customToolRegistry[0]?.associatedTools?.[0]?.tool).toHaveBeenCalledWith("async-test");
+            // Verify transformToContent was called
+            expect(mockTransformToContent).toHaveBeenCalledWith({
+                data: "async tool result",
+            });
+            // Verify advanceStream was called twice (initial request and tool response)
+            expect(typescript_sdk_1.advanceStream).toHaveBeenCalledTimes(2);
+            // Verify the second advanceStream call included the transformed content
+            expect(typescript_sdk_1.advanceStream).toHaveBeenLastCalledWith(mockTamboAI, expect.objectContaining({
+                messageToAppend: expect.objectContaining({
+                    content: [{ type: "text", text: "Async transformed content" }],
+                    role: "tool",
+                }),
+            }), "test-thread-1");
+        });
+        it("should fallback to stringified text when transformToContent is not provided", async () => {
+            const toolWithoutTransform = [
+                {
+                    name: "TestComponent",
+                    component: () => react_2.default.createElement("div", null, "Test"),
+                    description: "Test",
+                    propsSchema: zod_1.z.object({ test: zod_1.z.string() }),
+                    associatedTools: [
+                        {
+                            name: "no-transform-tool",
+                            tool: jest
+                                .fn()
+                                .mockResolvedValue({ complex: "data", nested: { value: 42 } }),
+                            description: "Tool without custom transform",
+                            toolSchema: zod_1.z
+                                .function()
+                                .args(zod_1.z.string())
+                                .returns(zod_1.z.object({
+                                complex: zod_1.z.string(),
+                                nested: zod_1.z.object({ value: zod_1.z.number() }),
+                            })),
+                            // No transformToContent provided
+                        },
+                    ],
+                },
+            ];
+            const wrapperWithoutTransform = ({ children, }) => (react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: toolWithoutTransform },
+                react_2.default.createElement(tambo_context_helpers_provider_1.TamboContextHelpersProvider, { contextHelpers: {
+                        currentTimeContextHelper: () => null,
+                        currentPageContextHelper: () => null,
+                    } },
+                    react_2.default.createElement(tambo_mcp_token_provider_1.TamboMcpTokenProvider, null,
+                        react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: false }, children)))));
+            const mockToolCallResponse = {
+                responseMessageDto: {
+                    id: "tool-call-1",
+                    content: [{ type: "text", text: "Tool call" }],
+                    role: "tool",
+                    threadId: "test-thread-1",
+                    toolCallRequest: {
+                        toolName: "no-transform-tool",
+                        parameters: [{ parameterName: "input", parameterValue: "test" }],
+                    },
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.COMPLETE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            jest
+                .mocked(mockThreadsApi.advanceByID)
+                .mockResolvedValueOnce(mockToolCallResponse)
+                .mockResolvedValueOnce({
+                responseMessageDto: {
+                    id: "final-response",
+                    content: [{ type: "text", text: "Final response" }],
+                    role: "assistant",
+                    threadId: "test-thread-1",
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.COMPLETE,
+                mcpAccessToken: "test-mcp-access-token",
+            });
+            const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
+                wrapper: wrapperWithoutTransform,
+            });
+            await (0, react_1.act)(async () => {
+                await result.current.sendThreadMessage("Use tool without transform", {
+                    threadId: "test-thread-1",
+                    streamResponse: false,
+                });
+            });
+            // Verify the tool was called
+            expect(toolWithoutTransform[0]?.associatedTools?.[0]?.tool).toHaveBeenCalledWith("test");
+            // Verify the second advance call used stringified content
+            expect(mockThreadsApi.advanceByID).toHaveBeenLastCalledWith("test-thread-1", expect.objectContaining({
+                messageToAppend: expect.objectContaining({
+                    content: [
+                        {
+                            type: "text",
+                            text: '{"complex":"data","nested":{"value":42}}',
+                        },
+                    ],
+                    role: "tool",
+                }),
+            }));
+        });
+        it("should always return text for error responses even with transformToContent", async () => {
+            const mockTransformToContent = jest.fn().mockReturnValue([
+                {
+                    type: "image_url",
+                    image_url: { url: "https://example.com/error.png" },
+                },
+            ]);
+            const toolWithTransform = [
+                {
+                    name: "TestComponent",
+                    component: () => react_2.default.createElement("div", null, "Test"),
+                    description: "Test",
+                    propsSchema: zod_1.z.object({ test: zod_1.z.string() }),
+                    associatedTools: [
+                        {
+                            name: "error-tool",
+                            tool: jest
+                                .fn()
+                                .mockRejectedValue(new Error("Tool execution failed")),
+                            description: "Tool that errors",
+                            toolSchema: zod_1.z.function().args(zod_1.z.string()).returns(zod_1.z.string()),
+                            transformToContent: mockTransformToContent,
+                        },
+                    ],
+                },
+            ];
+            const wrapperWithErrorTool = ({ children, }) => (react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: toolWithTransform },
+                react_2.default.createElement(tambo_context_helpers_provider_1.TamboContextHelpersProvider, { contextHelpers: {
+                        currentTimeContextHelper: () => null,
+                        currentPageContextHelper: () => null,
+                    } },
+                    react_2.default.createElement(tambo_mcp_token_provider_1.TamboMcpTokenProvider, null,
+                        react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: false }, children)))));
+            const mockToolCallResponse = {
+                responseMessageDto: {
+                    id: "tool-call-1",
+                    content: [{ type: "text", text: "Tool call" }],
+                    role: "tool",
+                    threadId: "test-thread-1",
+                    toolCallRequest: {
+                        toolName: "error-tool",
+                        parameters: [{ parameterName: "input", parameterValue: "test" }],
+                    },
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.COMPLETE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            jest
+                .mocked(mockThreadsApi.advanceByID)
+                .mockResolvedValueOnce(mockToolCallResponse)
+                .mockResolvedValueOnce({
+                responseMessageDto: {
+                    id: "final-response",
+                    content: [{ type: "text", text: "Final response" }],
+                    role: "assistant",
+                    threadId: "test-thread-1",
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.COMPLETE,
+                mcpAccessToken: "test-mcp-access-token",
+            });
+            const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
+                wrapper: wrapperWithErrorTool,
+            });
+            await (0, react_1.act)(async () => {
+                await result.current.sendThreadMessage("Use error tool", {
+                    threadId: "test-thread-1",
+                    streamResponse: false,
+                });
+            });
+            // Verify the tool was called
+            expect(toolWithTransform[0]?.associatedTools?.[0]?.tool).toHaveBeenCalledWith("test");
+            // Verify transformToContent was NOT called for error responses
+            expect(mockTransformToContent).not.toHaveBeenCalled();
+            // Verify the second advance call used text content with the error message
+            expect(mockThreadsApi.advanceByID).toHaveBeenLastCalledWith("test-thread-1", expect.objectContaining({
+                messageToAppend: expect.objectContaining({
+                    content: [
+                        expect.objectContaining({
+                            type: "text",
+                            // Error message should be in text format
+                        }),
+                    ],
+                    role: "tool",
+                }),
+            }));
+        });
+    });
 });
 //# sourceMappingURL=tambo-thread-provider.test.js.map