@tambo-ai/react 0.64.1 → 0.65.1

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

@@ -4,7 +4,7 @@ import React from "react";
 import { z } from "zod";
 import { GenerationStage, } from "../../model/generate-component-response";
 import { serializeRegistry } from "../../testing/tools";
-import { useTamboClient, useTamboQueryClient } from "../tambo-client-provider";
+import { TamboClientContext, useTamboClient, useTamboQueryClient, } from "../tambo-client-provider";
 import { TamboContextHelpersProvider } from "../tambo-context-helpers-provider";
 import { TamboMcpTokenProvider } from "../tambo-mcp-token-provider";
 import { TamboRegistryProvider } from "../tambo-registry-provider";
@@ -16,10 +16,13 @@ Object.defineProperty(global, "crypto", {
     },
 });
 // Mock the required providers
-jest.mock("../tambo-client-provider", () => ({
-    useTamboClient: jest.fn(),
-    useTamboQueryClient: jest.fn(),
-}));
+jest.mock("../tambo-client-provider", () => {
+    return {
+        useTamboClient: jest.fn(),
+        useTamboQueryClient: jest.fn(),
+        TamboClientContext: React.createContext(undefined),
+    };
+});
 jest.mock("@tambo-ai/typescript-sdk", () => ({
     advanceStream: jest.fn(),
 }));
@@ -108,13 +111,24 @@ describe("TamboThreadProvider", () => {
         },
     ];
     // Use helpers that explicitly return null so they don't appear in additionalContext
-    const wrapper = ({ children }) => (React.createElement(TamboRegistryProvider, { components: mockRegistry },
-        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                currentTimeContextHelper: () => null,
-                currentPageContextHelper: () => null,
+    const Wrapper = ({ children }) => {
+        const client = useTamboClient();
+        const queryClient = useTamboQueryClient();
+        return (React.createElement(TamboClientContext.Provider, { value: {
+                client,
+                queryClient,
+                isUpdatingToken: false,
+                mcpAccessToken: null,
+                setMcpAccessToken: () => { },
             } },
-            React.createElement(TamboMcpTokenProvider, null,
-                React.createElement(TamboThreadProvider, { streaming: false }, children)))));
+            React.createElement(TamboRegistryProvider, { components: mockRegistry },
+                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                        currentTimeContextHelper: () => null,
+                        currentPageContextHelper: () => null,
+                    } },
+                    React.createElement(TamboMcpTokenProvider, null,
+                        React.createElement(TamboThreadProvider, { streaming: false }, children))))));
+    };
     beforeEach(() => {
         jest.clearAllMocks();
         // Setup mock query client
@@ -149,13 +163,13 @@ describe("TamboThreadProvider", () => {
         jest.mocked(useTamboClient).mockReturnValue(mockTamboAI);
     });
     it("should initialize with placeholder thread", () => {
-        const { result } = renderHook(() => useTamboThread(), { wrapper });
+        const { result } = renderHook(() => useTamboThread(), { wrapper: Wrapper });
         expect(result.current.thread.id).toBe("placeholder");
         expect(result.current.isIdle).toBe(true);
         expect(result.current.generationStage).toBe(GenerationStage.IDLE);
     });
     it("should switch to a new thread", async () => {
-        const { result } = renderHook(() => useTamboThread(), { wrapper });
+        const { result } = renderHook(() => useTamboThread(), { wrapper: Wrapper });
         await act(async () => {
             await result.current.switchCurrentThread("test-thread-1");
         });
@@ -163,7 +177,7 @@ describe("TamboThreadProvider", () => {
         expect(result.current.thread.id).toBe("test-thread-1");
     });
     it("should start a new thread", async () => {
-        const { result } = renderHook(() => useTamboThread(), { wrapper });
+        const { result } = renderHook(() => useTamboThread(), { wrapper: Wrapper });
         await act(async () => {
             result.current.startNewThread();
         });
@@ -171,7 +185,7 @@ describe("TamboThreadProvider", () => {
         expect(result.current.isIdle).toBe(true);
     });
     it("should add a message to the thread", async () => {
-        const { result } = renderHook(() => useTamboThread(), { wrapper });
+        const { result } = renderHook(() => useTamboThread(), { wrapper: Wrapper });
         const testMessage = {
             id: "test-message-1",
             content: [{ type: "text", text: "Hello" }],
@@ -189,7 +203,7 @@ describe("TamboThreadProvider", () => {
         });
     });
     it("should update a message in the thread", async () => {
-        const { result } = renderHook(() => useTamboThread(), { wrapper });
+        const { result } = renderHook(() => useTamboThread(), { wrapper: Wrapper });
         const testMessage = {
             id: "test-message-1",
             content: [{ type: "text", text: "Updated message" }],
@@ -223,7 +237,7 @@ describe("TamboThreadProvider", () => {
         jest
             .mocked(mockThreadsApi.advanceByID)
             .mockResolvedValue(mockAdvanceResponse);
-        const { result } = renderHook(() => useTamboThread(), { wrapper });
+        const { result } = renderHook(() => useTamboThread(), { wrapper: Wrapper });
         await act(async () => {
             await result.current.sendThreadMessage("Hello", {
                 threadId: "test-thread-1",
@@ -274,7 +288,7 @@ describe("TamboThreadProvider", () => {
         };
         // Mock advanceStream to return our async iterator
         jest.mocked(advanceStream).mockResolvedValue(mockAsyncIterator);
-        const { result } = renderHook(() => useTamboThread(), { wrapper });
+        const { result } = renderHook(() => useTamboThread(), { wrapper: Wrapper });
         await act(async () => {
             await result.current.sendThreadMessage("Hello", {
                 threadId: "test-thread-1",
@@ -315,7 +329,7 @@ describe("TamboThreadProvider", () => {
             generationStage: GenerationStage.COMPLETE,
             mcpAccessToken: "test-mcp-access-token",
         });
-        const { result } = renderHook(() => useTamboThread(), { wrapper });
+        const { result } = renderHook(() => useTamboThread(), { wrapper: Wrapper });
         await act(async () => {
             await result.current.sendThreadMessage("Use tool", {
                 threadId: "test-thread-1",
@@ -329,13 +343,24 @@ describe("TamboThreadProvider", () => {
         const mockOnCallUnregisteredTool = jest
             .fn()
             .mockResolvedValue("unregistered-tool-result");
-        const wrapperWithUnregisteredTool = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: mockRegistry, onCallUnregisteredTool: mockOnCallUnregisteredTool },
-            React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                    currentTimeContextHelper: () => null,
-                    currentPageContextHelper: () => null,
+        const WrapperWithUnregisteredTool = ({ children, }) => {
+            const client = useTamboClient();
+            const queryClient = useTamboQueryClient();
+            return (React.createElement(TamboClientContext.Provider, { value: {
+                    client,
+                    queryClient,
+                    isUpdatingToken: false,
+                    mcpAccessToken: null,
+                    setMcpAccessToken: () => { },
                 } },
-                React.createElement(TamboMcpTokenProvider, null,
-                    React.createElement(TamboThreadProvider, { streaming: false }, children)))));
+                React.createElement(TamboRegistryProvider, { components: mockRegistry, onCallUnregisteredTool: mockOnCallUnregisteredTool },
+                    React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                            currentTimeContextHelper: () => null,
+                            currentPageContextHelper: () => null,
+                        } },
+                        React.createElement(TamboMcpTokenProvider, null,
+                            React.createElement(TamboThreadProvider, { streaming: false }, children))))));
+        };
         const mockUnregisteredToolCallResponse = {
             responseMessageDto: {
                 id: "unregistered-tool-call-1",
@@ -370,7 +395,7 @@ describe("TamboThreadProvider", () => {
             mcpAccessToken: "test-mcp-access-token",
         });
         const { result } = renderHook(() => useTamboThread(), {
-            wrapper: wrapperWithUnregisteredTool,
+            wrapper: WrapperWithUnregisteredTool,
         });
         await act(async () => {
             await result.current.sendThreadMessage("Use unregistered tool", {
@@ -415,7 +440,7 @@ describe("TamboThreadProvider", () => {
             generationStage: GenerationStage.COMPLETE,
             mcpAccessToken: "test-mcp-access-token",
         });
-        const { result } = renderHook(() => useTamboThread(), { wrapper });
+        const { result } = renderHook(() => useTamboThread(), { wrapper: Wrapper });
         await act(async () => {
             await result.current.sendThreadMessage("Use unregistered tool", {
                 threadId: "test-thread-1",
@@ -428,13 +453,24 @@ describe("TamboThreadProvider", () => {
     describe("streaming behavior", () => {
         it("should call advanceStream when streamResponse=true", async () => {
             // Use wrapper with streaming=true to show that explicit streamResponse=true works
-            const wrapperWithStreaming = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: mockRegistry },
-                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                        currentTimeContextHelper: () => null,
-                        currentPageContextHelper: () => null,
+            const WrapperWithStreaming = ({ children, }) => {
+                const client = useTamboClient();
+                const queryClient = useTamboQueryClient();
+                return (React.createElement(TamboClientContext.Provider, { value: {
+                        client,
+                        queryClient,
+                        isUpdatingToken: false,
+                        mcpAccessToken: null,
+                        setMcpAccessToken: () => { },
                     } },
-                    React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, { streaming: true }, children)))));
+                    React.createElement(TamboRegistryProvider, { components: mockRegistry },
+                        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                                currentTimeContextHelper: () => null,
+                                currentPageContextHelper: () => null,
+                            } },
+                            React.createElement(TamboMcpTokenProvider, null,
+                                React.createElement(TamboThreadProvider, { streaming: true }, children))))));
+            };
             const mockStreamResponse = {
                 responseMessageDto: {
                     id: "stream-response",
@@ -455,7 +491,7 @@ describe("TamboThreadProvider", () => {
             };
             jest.mocked(advanceStream).mockResolvedValue(mockAsyncIterator);
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: wrapperWithStreaming,
+                wrapper: WrapperWithStreaming,
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Hello streaming", {
@@ -490,15 +526,26 @@ describe("TamboThreadProvider", () => {
         });
         it("should call advanceById when streamResponse=false for existing thread", async () => {
             // Use wrapper with streaming=true to show that explicit streamResponse=false overrides provider setting
-            const wrapperWithStreaming = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: mockRegistry },
-                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                        currentTimeContextHelper: () => null,
-                        currentPageContextHelper: () => null,
+            const WrapperWithStreaming = ({ children, }) => {
+                const client = useTamboClient();
+                const queryClient = useTamboQueryClient();
+                return (React.createElement(TamboClientContext.Provider, { value: {
+                        client,
+                        queryClient,
+                        isUpdatingToken: false,
+                        mcpAccessToken: null,
+                        setMcpAccessToken: () => { },
                     } },
-                    React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, { streaming: true }, children)))));
+                    React.createElement(TamboRegistryProvider, { components: mockRegistry },
+                        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                                currentTimeContextHelper: () => null,
+                                currentPageContextHelper: () => null,
+                            } },
+                            React.createElement(TamboMcpTokenProvider, null,
+                                React.createElement(TamboThreadProvider, { streaming: true }, children))))));
+            };
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: wrapperWithStreaming,
+                wrapper: WrapperWithStreaming,
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Hello non-streaming", {
@@ -533,15 +580,26 @@ describe("TamboThreadProvider", () => {
         });
         it("should call advanceById when streamResponse is undefined and provider streaming=false", async () => {
             // Use wrapper with streaming=false to test that undefined streamResponse respects provider setting
-            const wrapperWithoutStreaming = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: mockRegistry },
-                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                        currentTimeContextHelper: () => null,
-                        currentPageContextHelper: () => null,
+            const WrapperWithoutStreaming = ({ children, }) => {
+                const client = useTamboClient();
+                const queryClient = useTamboQueryClient();
+                return (React.createElement(TamboClientContext.Provider, { value: {
+                        client,
+                        queryClient,
+                        isUpdatingToken: false,
+                        mcpAccessToken: null,
+                        setMcpAccessToken: () => { },
                     } },
-                    React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, { streaming: false }, children)))));
+                    React.createElement(TamboRegistryProvider, { components: mockRegistry },
+                        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                                currentTimeContextHelper: () => null,
+                                currentPageContextHelper: () => null,
+                            } },
+                            React.createElement(TamboMcpTokenProvider, null,
+                                React.createElement(TamboThreadProvider, { streaming: false }, children))))));
+            };
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: wrapperWithoutStreaming,
+                wrapper: WrapperWithoutStreaming,
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Hello default", {
@@ -576,13 +634,24 @@ describe("TamboThreadProvider", () => {
         });
         it("should call advanceStream when streamResponse is undefined and provider streaming=true (default)", async () => {
             // Use wrapper with streaming=true (default) to test that undefined streamResponse respects provider setting
-            const wrapperWithDefaultStreaming = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: mockRegistry },
-                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                        currentTimeContextHelper: () => null,
-                        currentPageContextHelper: () => null,
+            const WrapperWithDefaultStreaming = ({ children, }) => {
+                const client = useTamboClient();
+                const queryClient = useTamboQueryClient();
+                return (React.createElement(TamboClientContext.Provider, { value: {
+                        client,
+                        queryClient,
+                        isUpdatingToken: false,
+                        mcpAccessToken: null,
+                        setMcpAccessToken: () => { },
                     } },
-                    React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, null, children)))));
+                    React.createElement(TamboRegistryProvider, { components: mockRegistry },
+                        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                                currentTimeContextHelper: () => null,
+                                currentPageContextHelper: () => null,
+                            } },
+                            React.createElement(TamboMcpTokenProvider, null,
+                                React.createElement(TamboThreadProvider, null, children))))));
+            };
             const mockStreamResponse = {
                 responseMessageDto: {
                     id: "stream-response",
@@ -603,7 +672,7 @@ describe("TamboThreadProvider", () => {
             };
             jest.mocked(advanceStream).mockResolvedValue(mockAsyncIterator);
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: wrapperWithDefaultStreaming,
+                wrapper: WrapperWithDefaultStreaming,
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Hello default streaming", {
@@ -638,15 +707,26 @@ describe("TamboThreadProvider", () => {
         });
         it("should call advance when streamResponse=false for placeholder thread", async () => {
             // Use wrapper with streaming=true to show that explicit streamResponse=false overrides provider setting
-            const wrapperWithStreaming = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: mockRegistry },
-                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                        currentTimeContextHelper: () => null,
-                        currentPageContextHelper: () => null,
+            const WrapperWithStreaming = ({ children, }) => {
+                const client = useTamboClient();
+                const queryClient = useTamboQueryClient();
+                return (React.createElement(TamboClientContext.Provider, { value: {
+                        client,
+                        queryClient,
+                        isUpdatingToken: false,
+                        mcpAccessToken: null,
+                        setMcpAccessToken: () => { },
                     } },
-                    React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, { streaming: true }, children)))));
+                    React.createElement(TamboRegistryProvider, { components: mockRegistry },
+                        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                                currentTimeContextHelper: () => null,
+                                currentPageContextHelper: () => null,
+                            } },
+                            React.createElement(TamboMcpTokenProvider, null,
+                                React.createElement(TamboThreadProvider, { streaming: true }, children))))));
+            };
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: wrapperWithStreaming,
+                wrapper: WrapperWithStreaming,
             });
             // Start with placeholder thread (which is the default state)
             expect(result.current.thread.id).toBe("placeholder");
@@ -683,13 +763,24 @@ describe("TamboThreadProvider", () => {
         });
         it("should call advanceStream when streamResponse=true for placeholder thread", async () => {
             // Use wrapper with streaming=false to show that explicit streamResponse=true overrides provider setting
-            const wrapperWithoutStreaming = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: mockRegistry },
-                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                        currentTimeContextHelper: () => null,
-                        currentPageContextHelper: () => null,
+            const WrapperWithoutStreaming = ({ children, }) => {
+                const client = useTamboClient();
+                const queryClient = useTamboQueryClient();
+                return (React.createElement(TamboClientContext.Provider, { value: {
+                        client,
+                        queryClient,
+                        isUpdatingToken: false,
+                        mcpAccessToken: null,
+                        setMcpAccessToken: () => { },
                     } },
-                    React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, { streaming: false }, children)))));
+                    React.createElement(TamboRegistryProvider, { components: mockRegistry },
+                        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                                currentTimeContextHelper: () => null,
+                                currentPageContextHelper: () => null,
+                            } },
+                            React.createElement(TamboMcpTokenProvider, null,
+                                React.createElement(TamboThreadProvider, { streaming: false }, children))))));
+            };
             const mockStreamResponse = {
                 responseMessageDto: {
                     id: "stream-response",
@@ -710,7 +801,7 @@ describe("TamboThreadProvider", () => {
             };
             jest.mocked(advanceStream).mockResolvedValue(mockAsyncIterator);
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: wrapperWithoutStreaming,
+                wrapper: WrapperWithoutStreaming,
             });
             // Start with placeholder thread (which is the default state)
             expect(result.current.thread.id).toBe("placeholder");
@@ -751,7 +842,9 @@ describe("TamboThreadProvider", () => {
             const testError = new Error("API call failed");
             // Mock advanceById to throw an error
             jest.mocked(mockThreadsApi.advanceByID).mockRejectedValue(testError);
-            const { result } = renderHook(() => useTamboThread(), { wrapper });
+            const { result } = renderHook(() => useTamboThread(), {
+                wrapper: Wrapper,
+            });
             // Expect the error to be thrown
             await act(async () => {
                 await result.current.switchCurrentThread("test-thread-1");
@@ -767,7 +860,9 @@ describe("TamboThreadProvider", () => {
             const testError = new Error("Streaming API call failed");
             // Mock advanceStream to throw an error
             jest.mocked(advanceStream).mockRejectedValue(testError);
-            const { result } = renderHook(() => useTamboThread(), { wrapper });
+            const { result } = renderHook(() => useTamboThread(), {
+                wrapper: Wrapper,
+            });
             // Expect the error to be thrown
             await act(async () => {
                 await result.current.switchCurrentThread("test-thread-1");
@@ -783,7 +878,9 @@ describe("TamboThreadProvider", () => {
             const testError = new Error("Advance API call failed");
             // Mock advance to throw an error
             jest.mocked(mockThreadsApi.advance).mockRejectedValue(testError);
-            const { result } = renderHook(() => useTamboThread(), { wrapper });
+            const { result } = renderHook(() => useTamboThread(), {
+                wrapper: Wrapper,
+            });
             // Start with placeholder thread (which is the default state)
             expect(result.current.thread.id).toBe("placeholder");
             // Expect the error to be thrown
@@ -799,7 +896,9 @@ describe("TamboThreadProvider", () => {
     });
     describe("refetch threads list behavior", () => {
         it("should refetch threads list when creating a new thread via sendThreadMessage", async () => {
-            const { result } = renderHook(() => useTamboThread(), { wrapper });
+            const { result } = renderHook(() => useTamboThread(), {
+                wrapper: Wrapper,
+            });
             // Mock the advance response to return a new thread ID
             const mockAdvanceResponse = {
                 responseMessageDto: {
@@ -835,7 +934,9 @@ describe("TamboThreadProvider", () => {
             });
         });
         it("should not refetch threads list when switching between existing threads", async () => {
-            const { result } = renderHook(() => useTamboThread(), { wrapper });
+            const { result } = renderHook(() => useTamboThread(), {
+                wrapper: Wrapper,
+            });
             // Start with placeholder thread
             expect(result.current.thread.id).toBe("placeholder");
             // Clear any previous mock calls
@@ -887,13 +988,24 @@ describe("TamboThreadProvider", () => {
                     ],
                 },
             ];
-            const wrapperWithCustomTool = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: customToolRegistry },
-                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                        currentTimeContextHelper: () => null,
-                        currentPageContextHelper: () => null,
+            const WrapperWithCustomTool = ({ children, }) => {
+                const client = useTamboClient();
+                const queryClient = useTamboQueryClient();
+                return (React.createElement(TamboClientContext.Provider, { value: {
+                        client,
+                        queryClient,
+                        isUpdatingToken: false,
+                        mcpAccessToken: null,
+                        setMcpAccessToken: () => { },
                     } },
-                    React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, { streaming: false }, children)))));
+                    React.createElement(TamboRegistryProvider, { components: customToolRegistry },
+                        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                                currentTimeContextHelper: () => null,
+                                currentPageContextHelper: () => null,
+                            } },
+                            React.createElement(TamboMcpTokenProvider, null,
+                                React.createElement(TamboThreadProvider, { streaming: false }, children))))));
+            };
             const mockToolCallResponse = {
                 responseMessageDto: {
                     id: "tool-call-1",
@@ -926,7 +1038,7 @@ describe("TamboThreadProvider", () => {
                 mcpAccessToken: "test-mcp-access-token",
             });
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: wrapperWithCustomTool,
+                wrapper: WrapperWithCustomTool,
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Use custom tool", {
@@ -981,13 +1093,24 @@ describe("TamboThreadProvider", () => {
                     ],
                 },
             ];
-            const wrapperWithAsyncTool = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: customToolRegistry },
-                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                        currentTimeContextHelper: () => null,
-                        currentPageContextHelper: () => null,
+            const WrapperWithAsyncTool = ({ children, }) => {
+                const client = useTamboClient();
+                const queryClient = useTamboQueryClient();
+                return (React.createElement(TamboClientContext.Provider, { value: {
+                        client,
+                        queryClient,
+                        isUpdatingToken: false,
+                        mcpAccessToken: null,
+                        setMcpAccessToken: () => { },
                     } },
-                    React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, { streaming: true }, children)))));
+                    React.createElement(TamboRegistryProvider, { components: customToolRegistry },
+                        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                                currentTimeContextHelper: () => null,
+                                currentPageContextHelper: () => null,
+                            } },
+                            React.createElement(TamboMcpTokenProvider, null,
+                                React.createElement(TamboThreadProvider, { streaming: true }, children))))));
+            };
             const mockToolCallChunk = {
                 responseMessageDto: {
                     id: "tool-call-chunk",
@@ -1033,7 +1156,7 @@ describe("TamboThreadProvider", () => {
                 },
             });
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: wrapperWithAsyncTool,
+                wrapper: WrapperWithAsyncTool,
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Use async tool", {
@@ -1083,13 +1206,24 @@ describe("TamboThreadProvider", () => {
                     ],
                 },
             ];
-            const wrapperWithoutTransform = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: toolWithoutTransform },
-                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                        currentTimeContextHelper: () => null,
-                        currentPageContextHelper: () => null,
+            const WrapperWithoutTransform = ({ children, }) => {
+                const client = useTamboClient();
+                const queryClient = useTamboQueryClient();
+                return (React.createElement(TamboClientContext.Provider, { value: {
+                        client,
+                        queryClient,
+                        isUpdatingToken: false,
+                        mcpAccessToken: null,
+                        setMcpAccessToken: () => { },
                     } },
-                    React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, { streaming: false }, children)))));
+                    React.createElement(TamboRegistryProvider, { components: toolWithoutTransform },
+                        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                                currentTimeContextHelper: () => null,
+                                currentPageContextHelper: () => null,
+                            } },
+                            React.createElement(TamboMcpTokenProvider, null,
+                                React.createElement(TamboThreadProvider, { streaming: false }, children))))));
+            };
             const mockToolCallResponse = {
                 responseMessageDto: {
                     id: "tool-call-1",
@@ -1122,7 +1256,7 @@ describe("TamboThreadProvider", () => {
                 mcpAccessToken: "test-mcp-access-token",
             });
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: wrapperWithoutTransform,
+                wrapper: WrapperWithoutTransform,
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Use tool without transform", {
@@ -1171,13 +1305,24 @@ describe("TamboThreadProvider", () => {
                     ],
                 },
             ];
-            const wrapperWithErrorTool = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: toolWithTransform },
-                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                        currentTimeContextHelper: () => null,
-                        currentPageContextHelper: () => null,
+            const WrapperWithErrorTool = ({ children, }) => {
+                const client = useTamboClient();
+                const queryClient = useTamboQueryClient();
+                return (React.createElement(TamboClientContext.Provider, { value: {
+                        client,
+                        queryClient,
+                        isUpdatingToken: false,
+                        mcpAccessToken: null,
+                        setMcpAccessToken: () => { },
                     } },
-                    React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, { streaming: false }, children)))));
+                    React.createElement(TamboRegistryProvider, { components: toolWithTransform },
+                        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                                currentTimeContextHelper: () => null,
+                                currentPageContextHelper: () => null,
+                            } },
+                            React.createElement(TamboMcpTokenProvider, null,
+                                React.createElement(TamboThreadProvider, { streaming: false }, children))))));
+            };
             const mockToolCallResponse = {
                 responseMessageDto: {
                     id: "tool-call-1",
@@ -1210,7 +1355,7 @@ describe("TamboThreadProvider", () => {
                 mcpAccessToken: "test-mcp-access-token",
             });
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: wrapperWithErrorTool,
+                wrapper: WrapperWithErrorTool,
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Use error tool", {
@@ -1238,15 +1383,26 @@ describe("TamboThreadProvider", () => {
     });
     describe("auto-generate thread name", () => {
         it("should auto-generate thread name after reaching threshold", async () => {
-            const wrapperWithAutoGenerate = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: mockRegistry },
-                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                        currentTimeContextHelper: () => null,
-                        currentPageContextHelper: () => null,
+            const WrapperWithAutoGenerate = ({ children, }) => {
+                const client = useTamboClient();
+                const queryClient = useTamboQueryClient();
+                return (React.createElement(TamboClientContext.Provider, { value: {
+                        client,
+                        queryClient,
+                        isUpdatingToken: false,
+                        mcpAccessToken: null,
+                        setMcpAccessToken: () => { },
                     } },
-                    React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, { streaming: false, autoGenerateNameThreshold: 2 }, children)))));
+                    React.createElement(TamboRegistryProvider, { components: mockRegistry },
+                        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                                currentTimeContextHelper: () => null,
+                                currentPageContextHelper: () => null,
+                            } },
+                            React.createElement(TamboMcpTokenProvider, null,
+                                React.createElement(TamboThreadProvider, { streaming: false, autoGenerateNameThreshold: 2 }, children))))));
+            };
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: wrapperWithAutoGenerate,
+                wrapper: WrapperWithAutoGenerate,
             });
             const existingThread = createMockThread({
                 id: "test-thread-1",
@@ -1283,15 +1439,26 @@ describe("TamboThreadProvider", () => {
             expect(mockQueryClient.setQueryData).toHaveBeenCalledWith(["threads", "test-project-id", undefined], expect.any(Function));
         });
         it("should NOT auto-generate when autoGenerateThreadName is false", async () => {
-            const wrapperWithDisabled = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: mockRegistry },
-                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                        currentTimeContextHelper: () => null,
-                        currentPageContextHelper: () => null,
+            const WrapperWithDisabled = ({ children, }) => {
+                const client = useTamboClient();
+                const queryClient = useTamboQueryClient();
+                return (React.createElement(TamboClientContext.Provider, { value: {
+                        client,
+                        queryClient,
+                        isUpdatingToken: false,
+                        mcpAccessToken: null,
+                        setMcpAccessToken: () => { },
                     } },
-                    React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, { streaming: false, autoGenerateThreadName: false, autoGenerateNameThreshold: 2 }, children)))));
+                    React.createElement(TamboRegistryProvider, { components: mockRegistry },
+                        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                                currentTimeContextHelper: () => null,
+                                currentPageContextHelper: () => null,
+                            } },
+                            React.createElement(TamboMcpTokenProvider, null,
+                                React.createElement(TamboThreadProvider, { streaming: false, autoGenerateThreadName: false, autoGenerateNameThreshold: 2 }, children))))));
+            };
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: wrapperWithDisabled,
+                wrapper: WrapperWithDisabled,
             });
             const existingThread = createMockThread({
                 id: "test-thread-1",
@@ -1324,15 +1491,26 @@ describe("TamboThreadProvider", () => {
             expect(mockThreadsApi.generateName).not.toHaveBeenCalled();
         });
         it("should NOT auto-generate when thread already has a name", async () => {
-            const wrapperWithAutoGenerate = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: mockRegistry },
-                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                        currentTimeContextHelper: () => null,
-                        currentPageContextHelper: () => null,
+            const WrapperWithAutoGenerate = ({ children, }) => {
+                const client = useTamboClient();
+                const queryClient = useTamboQueryClient();
+                return (React.createElement(TamboClientContext.Provider, { value: {
+                        client,
+                        queryClient,
+                        isUpdatingToken: false,
+                        mcpAccessToken: null,
+                        setMcpAccessToken: () => { },
                     } },
-                    React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, { streaming: false, autoGenerateNameThreshold: 2 }, children)))));
+                    React.createElement(TamboRegistryProvider, { components: mockRegistry },
+                        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                                currentTimeContextHelper: () => null,
+                                currentPageContextHelper: () => null,
+                            } },
+                            React.createElement(TamboMcpTokenProvider, null,
+                                React.createElement(TamboThreadProvider, { streaming: false, autoGenerateNameThreshold: 2 }, children))))));
+            };
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: wrapperWithAutoGenerate,
+                wrapper: WrapperWithAutoGenerate,
             });
             const threadWithName = createMockThread({
                 id: "test-thread-1",
@@ -1370,15 +1548,26 @@ describe("TamboThreadProvider", () => {
             expect(mockThreadsApi.generateName).not.toHaveBeenCalled();
         });
         it("should NOT auto-generate for placeholder thread", async () => {
-            const wrapperWithAutoGenerate = ({ children, }) => (React.createElement(TamboRegistryProvider, { components: mockRegistry },
-                React.createElement(TamboContextHelpersProvider, { contextHelpers: {
-                        currentTimeContextHelper: () => null,
-                        currentPageContextHelper: () => null,
+            const WrapperWithAutoGenerate = ({ children, }) => {
+                const client = useTamboClient();
+                const queryClient = useTamboQueryClient();
+                return (React.createElement(TamboClientContext.Provider, { value: {
+                        client,
+                        queryClient,
+                        isUpdatingToken: false,
+                        mcpAccessToken: null,
+                        setMcpAccessToken: () => { },
                     } },
-                    React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, { streaming: false, autoGenerateNameThreshold: 2 }, children)))));
+                    React.createElement(TamboRegistryProvider, { components: mockRegistry },
+                        React.createElement(TamboContextHelpersProvider, { contextHelpers: {
+                                currentTimeContextHelper: () => null,
+                                currentPageContextHelper: () => null,
+                            } },
+                            React.createElement(TamboMcpTokenProvider, null,
+                                React.createElement(TamboThreadProvider, { streaming: false, autoGenerateNameThreshold: 2 }, children))))));
+            };
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: wrapperWithAutoGenerate,
+                wrapper: WrapperWithAutoGenerate,
             });
             // Stay on placeholder thread
             expect(result.current.thread.id).toBe("placeholder");