@tambo-ai/react 0.68.0 → 0.69.1

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

@@ -115,8 +115,18 @@ describe("TamboThreadProvider", () => {
             ],
         },
     ];
-    // Use helpers that explicitly return null so they don't appear in additionalContext
-    const Wrapper = ({ children }) => {
+    /**
+     * Creates a test wrapper component with configurable options.
+     * Reduces duplication across tests by centralizing provider setup.
+     * @param options - Configuration options for the wrapper
+     * @param options.components - The Tambo components to register
+     * @param options.streaming - Whether to enable streaming responses
+     * @param options.onCallUnregisteredTool - Handler for unregistered tool calls
+     * @param options.autoGenerateThreadName - Whether to auto-generate thread names
+     * @param options.autoGenerateNameThreshold - Token threshold for auto-generating names
+     * @returns A React component that wraps children with the necessary providers
+     */
+    const createWrapper = ({ components = mockRegistry, streaming = false, onCallUnregisteredTool, autoGenerateThreadName, autoGenerateNameThreshold, } = {}) => function TestWrapper({ children }) {
         const client = (0, tambo_client_provider_1.useTamboClient)();
         const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
         return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
@@ -124,14 +134,16 @@ describe("TamboThreadProvider", () => {
                 queryClient,
                 isUpdatingToken: false,
             } },
-            react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: mockRegistry },
+            react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: components, onCallUnregisteredTool: onCallUnregisteredTool },
                 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))))));
+                        react_2.default.createElement(tambo_thread_provider_1.TamboThreadProvider, { streaming: streaming, autoGenerateThreadName: autoGenerateThreadName, autoGenerateNameThreshold: autoGenerateNameThreshold }, children))))));
     };
+    // Default wrapper for most tests
+    const Wrapper = createWrapper();
     beforeEach(() => {
         jest.clearAllMocks();
         // Setup mock query client
@@ -349,22 +361,6 @@ describe("TamboThreadProvider", () => {
         const mockOnCallUnregisteredTool = jest
             .fn()
             .mockResolvedValue("unregistered-tool-result");
-        const WrapperWithUnregisteredTool = ({ children, }) => {
-            const client = (0, tambo_client_provider_1.useTamboClient)();
-            const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-            return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                    client,
-                    queryClient,
-                    isUpdatingToken: false,
-                } },
-                react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: mockRegistry, onCallUnregisteredTool: mockOnCallUnregisteredTool },
-                    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 mockUnregisteredToolCallResponse = {
             responseMessageDto: {
                 id: "unregistered-tool-call-1",
@@ -399,7 +395,9 @@ describe("TamboThreadProvider", () => {
             mcpAccessToken: "test-mcp-access-token",
         });
         const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-            wrapper: WrapperWithUnregisteredTool,
+            wrapper: createWrapper({
+                onCallUnregisteredTool: mockOnCallUnregisteredTool,
+            }),
         });
         await (0, react_1.act)(async () => {
             await result.current.sendThreadMessage("Use unregistered tool", {
@@ -456,23 +454,6 @@ 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, }) => {
-                const client = (0, tambo_client_provider_1.useTamboClient)();
-                const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-                return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: mockRegistry },
-                        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 mockStreamResponse = {
                 responseMessageDto: {
                     id: "stream-response",
@@ -493,7 +474,7 @@ describe("TamboThreadProvider", () => {
             };
             jest.mocked(typescript_sdk_1.advanceStream).mockResolvedValue(mockAsyncIterator);
             const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-                wrapper: WrapperWithStreaming,
+                wrapper: createWrapper({ streaming: true }),
             });
             await (0, react_1.act)(async () => {
                 await result.current.sendThreadMessage("Hello streaming", {
@@ -528,24 +509,8 @@ 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, }) => {
-                const client = (0, tambo_client_provider_1.useTamboClient)();
-                const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-                return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: mockRegistry },
-                        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 { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-                wrapper: WrapperWithStreaming,
+                wrapper: createWrapper({ streaming: true }),
             });
             await (0, react_1.act)(async () => {
                 await result.current.sendThreadMessage("Hello non-streaming", {
@@ -580,24 +545,8 @@ 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, }) => {
-                const client = (0, tambo_client_provider_1.useTamboClient)();
-                const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-                return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: mockRegistry },
-                        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 { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-                wrapper: WrapperWithoutStreaming,
+                wrapper: createWrapper({ streaming: false }),
             });
             await (0, react_1.act)(async () => {
                 await result.current.sendThreadMessage("Hello default", {
@@ -631,23 +580,6 @@ describe("TamboThreadProvider", () => {
             expect(typescript_sdk_1.advanceStream).not.toHaveBeenCalled();
         });
         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, }) => {
-                const client = (0, tambo_client_provider_1.useTamboClient)();
-                const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-                return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: mockRegistry },
-                        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, null, children))))));
-            };
             const mockStreamResponse = {
                 responseMessageDto: {
                     id: "stream-response",
@@ -668,7 +600,7 @@ describe("TamboThreadProvider", () => {
             };
             jest.mocked(typescript_sdk_1.advanceStream).mockResolvedValue(mockAsyncIterator);
             const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-                wrapper: WrapperWithDefaultStreaming,
+                wrapper: createWrapper({ streaming: true }),
             });
             await (0, react_1.act)(async () => {
                 await result.current.sendThreadMessage("Hello default streaming", {
@@ -703,24 +635,8 @@ 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, }) => {
-                const client = (0, tambo_client_provider_1.useTamboClient)();
-                const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-                return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: mockRegistry },
-                        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 { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-                wrapper: WrapperWithStreaming,
+                wrapper: createWrapper({ streaming: true }),
             });
             // Start with placeholder thread (which is the default state)
             expect(result.current.thread.id).toBe("placeholder");
@@ -756,23 +672,6 @@ describe("TamboThreadProvider", () => {
             expect(typescript_sdk_1.advanceStream).not.toHaveBeenCalled();
         });
         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, }) => {
-                const client = (0, tambo_client_provider_1.useTamboClient)();
-                const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-                return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: mockRegistry },
-                        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 mockStreamResponse = {
                 responseMessageDto: {
                     id: "stream-response",
@@ -793,7 +692,7 @@ describe("TamboThreadProvider", () => {
             };
             jest.mocked(typescript_sdk_1.advanceStream).mockResolvedValue(mockAsyncIterator);
             const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-                wrapper: WrapperWithoutStreaming,
+                wrapper: createWrapper({ streaming: false }),
             });
             // Start with placeholder thread (which is the default state)
             expect(result.current.thread.id).toBe("placeholder");
@@ -828,6 +727,94 @@ describe("TamboThreadProvider", () => {
             expect(mockThreadsApi.advance).not.toHaveBeenCalled();
             expect(mockThreadsApi.advanceByID).not.toHaveBeenCalled();
         });
+        it("should handle multiple sequential messages during streaming (server tool scenario)", async () => {
+            // This test verifies the fix for the bug where the second message doesn't render
+            // during server tool response streaming. The scenario:
+            // 1. First message: "I will call the tool..." with statusMessage
+            // 2. Second message: The tool result response streaming in
+            // First message - tool announcement (server tools don't have componentName set during streaming)
+            const mockFirstMessage = {
+                responseMessageDto: {
+                    id: "msg-first",
+                    content: [{ type: "text", text: "I will search the docs..." }],
+                    role: "assistant",
+                    threadId: "test-thread-1",
+                    component: {
+                        componentName: "",
+                        componentState: {},
+                        message: "",
+                        props: {},
+                        statusMessage: "searching the Tambo docs...",
+                    },
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.STREAMING_RESPONSE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            // Second message - tool result (different ID!)
+            const mockSecondMessageChunk1 = {
+                responseMessageDto: {
+                    id: "msg-second",
+                    content: [{ type: "text", text: "Here's what I found..." }],
+                    role: "assistant",
+                    threadId: "test-thread-1",
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.STREAMING_RESPONSE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            const mockSecondMessageChunk2 = {
+                responseMessageDto: {
+                    id: "msg-second",
+                    content: [
+                        {
+                            type: "text",
+                            text: "Here's what I found in the documentation about that topic.",
+                        },
+                    ],
+                    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 mockFirstMessage;
+                    yield mockSecondMessageChunk1;
+                    yield mockSecondMessageChunk2;
+                },
+            };
+            jest.mocked(typescript_sdk_1.advanceStream).mockResolvedValue(mockAsyncIterator);
+            const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
+                wrapper: createWrapper({ streaming: true }),
+            });
+            await (0, react_1.act)(async () => {
+                await result.current.sendThreadMessage("Search the docs", {
+                    threadId: "test-thread-1",
+                    streamResponse: true,
+                });
+            });
+            // Thread should have 3 messages: user message + 2 assistant messages
+            expect(result.current.thread.messages).toHaveLength(3);
+            // Filter to assistant messages only
+            const assistantMessages = result.current.thread.messages.filter((m) => m.role === "assistant");
+            expect(assistantMessages).toHaveLength(2);
+            // First assistant message should have the tool status
+            const firstMsg = result.current.thread.messages.find((m) => m.id === "msg-first");
+            expect(firstMsg).toBeDefined();
+            expect(firstMsg?.content[0]?.text).toContain("search the docs");
+            // Second assistant message should have the final content
+            const secondMsg = result.current.thread.messages.find((m) => m.id === "msg-second");
+            expect(secondMsg).toBeDefined();
+            expect(secondMsg?.content[0]?.text).toContain("what I found in the documentation");
+            // Generation should be complete
+            expect(result.current.generationStage).toBe(generate_component_response_1.GenerationStage.COMPLETE);
+        });
     });
     describe("error handling", () => {
         it("should set generation stage to ERROR when non-streaming sendThreadMessage fails", async () => {
@@ -978,22 +965,6 @@ describe("TamboThreadProvider", () => {
                     ],
                 },
             ];
-            const WrapperWithCustomTool = ({ children, }) => {
-                const client = (0, tambo_client_provider_1.useTamboClient)();
-                const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-                return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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",
@@ -1026,7 +997,7 @@ describe("TamboThreadProvider", () => {
                 mcpAccessToken: "test-mcp-access-token",
             });
             const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-                wrapper: WrapperWithCustomTool,
+                wrapper: createWrapper({ components: customToolRegistry }),
             });
             await (0, react_1.act)(async () => {
                 await result.current.sendThreadMessage("Use custom tool", {
@@ -1079,22 +1050,6 @@ describe("TamboThreadProvider", () => {
                     ],
                 },
             ];
-            const WrapperWithAsyncTool = ({ children, }) => {
-                const client = (0, tambo_client_provider_1.useTamboClient)();
-                const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-                return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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",
@@ -1140,7 +1095,10 @@ describe("TamboThreadProvider", () => {
                 },
             });
             const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-                wrapper: WrapperWithAsyncTool,
+                wrapper: createWrapper({
+                    components: customToolRegistry,
+                    streaming: true,
+                }),
             });
             await (0, react_1.act)(async () => {
                 await result.current.sendThreadMessage("Use async tool", {
@@ -1188,22 +1146,6 @@ describe("TamboThreadProvider", () => {
                     ],
                 },
             ];
-            const WrapperWithoutTransform = ({ children, }) => {
-                const client = (0, tambo_client_provider_1.useTamboClient)();
-                const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-                return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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",
@@ -1236,7 +1178,7 @@ describe("TamboThreadProvider", () => {
                 mcpAccessToken: "test-mcp-access-token",
             });
             const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-                wrapper: WrapperWithoutTransform,
+                wrapper: createWrapper({ components: toolWithoutTransform }),
             });
             await (0, react_1.act)(async () => {
                 await result.current.sendThreadMessage("Use tool without transform", {
@@ -1286,22 +1228,6 @@ describe("TamboThreadProvider", () => {
                     ],
                 },
             ];
-            const WrapperWithErrorTool = ({ children, }) => {
-                const client = (0, tambo_client_provider_1.useTamboClient)();
-                const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-                return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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",
@@ -1334,7 +1260,7 @@ describe("TamboThreadProvider", () => {
                 mcpAccessToken: "test-mcp-access-token",
             });
             const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-                wrapper: WrapperWithErrorTool,
+                wrapper: createWrapper({ components: toolWithTransform }),
             });
             await (0, react_1.act)(async () => {
                 await result.current.sendThreadMessage("Use error tool", {
@@ -1360,26 +1286,339 @@ describe("TamboThreadProvider", () => {
             }));
         });
     });
+    describe("tamboStreamableHint streaming behavior", () => {
+        it("should call streamable tool during streaming when tamboStreamableHint is true", async () => {
+            const streamableToolFn = jest
+                .fn()
+                .mockResolvedValue({ data: "streamed" });
+            const customToolRegistry = [
+                {
+                    name: "TestComponent",
+                    component: () => react_2.default.createElement("div", null, "Test"),
+                    description: "Test",
+                    propsSchema: v4_1.z.object({ test: v4_1.z.string() }),
+                    associatedTools: [
+                        {
+                            name: "streamable-tool",
+                            tool: streamableToolFn,
+                            description: "Tool safe for streaming",
+                            inputSchema: v4_1.z.object({ input: v4_1.z.string() }),
+                            outputSchema: v4_1.z.object({ data: v4_1.z.string() }),
+                            annotations: { tamboStreamableHint: true },
+                        },
+                    ],
+                },
+            ];
+            // First chunk initializes finalMessage
+            const mockInitialChunk = {
+                responseMessageDto: {
+                    id: "initial-chunk",
+                    content: [{ type: "text", text: "Starting..." }],
+                    role: "assistant",
+                    threadId: "test-thread-1",
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.STREAMING_RESPONSE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            // Second chunk has the tool call - this triggers streaming tool handling
+            const mockToolCallChunk = {
+                responseMessageDto: {
+                    id: "initial-chunk", // Same ID as initial - it's an update
+                    content: [{ type: "text", text: "Streaming..." }],
+                    role: "assistant",
+                    threadId: "test-thread-1",
+                    component: {
+                        componentName: "",
+                        componentState: {},
+                        message: "",
+                        props: {},
+                        toolCallRequest: {
+                            toolName: "streamable-tool",
+                            parameters: [
+                                { parameterName: "input", parameterValue: "stream-test" },
+                            ],
+                        },
+                    },
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.STREAMING_RESPONSE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            const mockFinalChunk = {
+                responseMessageDto: {
+                    id: "initial-chunk",
+                    content: [{ type: "text", text: "Complete" }],
+                    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 mockInitialChunk;
+                    yield mockToolCallChunk;
+                    yield mockFinalChunk;
+                },
+            };
+            jest.mocked(typescript_sdk_1.advanceStream).mockResolvedValueOnce(mockAsyncIterator);
+            const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
+                wrapper: createWrapper({
+                    components: customToolRegistry,
+                    streaming: true,
+                }),
+            });
+            await (0, react_1.act)(async () => {
+                await result.current.sendThreadMessage("Test streamable tool", {
+                    threadId: "test-thread-1",
+                    streamResponse: true,
+                });
+            });
+            // Streamable tool should be called during streaming
+            expect(streamableToolFn).toHaveBeenCalledWith({ input: "stream-test" });
+        });
+        it("should NOT call non-streamable tool during streaming", async () => {
+            const nonStreamableToolFn = jest
+                .fn()
+                .mockResolvedValue({ data: "result" });
+            const customToolRegistry = [
+                {
+                    name: "TestComponent",
+                    component: () => react_2.default.createElement("div", null, "Test"),
+                    description: "Test",
+                    propsSchema: v4_1.z.object({ test: v4_1.z.string() }),
+                    associatedTools: [
+                        {
+                            name: "non-streamable-tool",
+                            tool: nonStreamableToolFn,
+                            description: "Tool not safe for streaming",
+                            inputSchema: v4_1.z.object({ input: v4_1.z.string() }),
+                            outputSchema: v4_1.z.object({ data: v4_1.z.string() }),
+                            // No tamboStreamableHint - defaults to false
+                        },
+                    ],
+                },
+            ];
+            // First chunk initializes finalMessage
+            const mockInitialChunk = {
+                responseMessageDto: {
+                    id: "streaming-chunk",
+                    content: [{ type: "text", text: "Starting..." }],
+                    role: "assistant",
+                    threadId: "test-thread-1",
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.STREAMING_RESPONSE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            // Second chunk has the tool call - but tool is NOT streamable
+            const mockToolCallChunk = {
+                responseMessageDto: {
+                    id: "streaming-chunk",
+                    content: [{ type: "text", text: "Streaming..." }],
+                    role: "assistant",
+                    threadId: "test-thread-1",
+                    component: {
+                        componentName: "",
+                        componentState: {},
+                        message: "",
+                        props: {},
+                        toolCallRequest: {
+                            toolName: "non-streamable-tool",
+                            parameters: [{ parameterName: "input", parameterValue: "test" }],
+                        },
+                    },
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.STREAMING_RESPONSE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            const mockFinalChunk = {
+                responseMessageDto: {
+                    id: "streaming-chunk",
+                    content: [{ type: "text", text: "Complete" }],
+                    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 mockInitialChunk;
+                    yield mockToolCallChunk;
+                    yield mockFinalChunk;
+                },
+            };
+            jest.mocked(typescript_sdk_1.advanceStream).mockResolvedValueOnce(mockAsyncIterator);
+            const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
+                wrapper: createWrapper({
+                    components: customToolRegistry,
+                    streaming: true,
+                }),
+            });
+            await (0, react_1.act)(async () => {
+                await result.current.sendThreadMessage("Test non-streamable tool", {
+                    threadId: "test-thread-1",
+                    streamResponse: true,
+                });
+            });
+            // Non-streamable tool should NOT be called during the streaming chunk phase
+            // (it would only be called when generationStage is COMPLETE with a toolCallRequest)
+            expect(nonStreamableToolFn).not.toHaveBeenCalled();
+        });
+        it("should only call streamable tools during streaming when mixed", async () => {
+            const streamableToolFn = jest
+                .fn()
+                .mockResolvedValue({ data: "streamed" });
+            const nonStreamableToolFn = jest
+                .fn()
+                .mockResolvedValue({ data: "not-streamed" });
+            const customToolRegistry = [
+                {
+                    name: "TestComponent",
+                    component: () => react_2.default.createElement("div", null, "Test"),
+                    description: "Test",
+                    propsSchema: v4_1.z.object({ test: v4_1.z.string() }),
+                    associatedTools: [
+                        {
+                            name: "streamable-tool",
+                            tool: streamableToolFn,
+                            description: "Tool safe for streaming",
+                            inputSchema: v4_1.z.object({ input: v4_1.z.string() }),
+                            outputSchema: v4_1.z.object({ data: v4_1.z.string() }),
+                            annotations: { tamboStreamableHint: true },
+                        },
+                        {
+                            name: "non-streamable-tool",
+                            tool: nonStreamableToolFn,
+                            description: "Tool not safe for streaming",
+                            inputSchema: v4_1.z.object({ input: v4_1.z.string() }),
+                            outputSchema: v4_1.z.object({ data: v4_1.z.string() }),
+                            annotations: { tamboStreamableHint: false },
+                        },
+                    ],
+                },
+            ];
+            // First chunk initializes finalMessage
+            const mockInitialChunk = {
+                responseMessageDto: {
+                    id: "streaming-chunk",
+                    content: [{ type: "text", text: "Starting..." }],
+                    role: "assistant",
+                    threadId: "test-thread-1",
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.STREAMING_RESPONSE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            // Second chunk calls the streamable tool
+            const mockStreamableToolChunk = {
+                responseMessageDto: {
+                    id: "streaming-chunk",
+                    content: [{ type: "text", text: "Calling streamable..." }],
+                    role: "assistant",
+                    threadId: "test-thread-1",
+                    component: {
+                        componentName: "",
+                        componentState: {},
+                        message: "",
+                        props: {},
+                        toolCallRequest: {
+                            toolName: "streamable-tool",
+                            parameters: [
+                                { parameterName: "input", parameterValue: "streamed-input" },
+                            ],
+                        },
+                    },
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.STREAMING_RESPONSE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            // Third chunk calls the non-streamable tool
+            const mockNonStreamableToolChunk = {
+                responseMessageDto: {
+                    id: "streaming-chunk",
+                    content: [{ type: "text", text: "Calling non-streamable..." }],
+                    role: "assistant",
+                    threadId: "test-thread-1",
+                    component: {
+                        componentName: "",
+                        componentState: {},
+                        message: "",
+                        props: {},
+                        toolCallRequest: {
+                            toolName: "non-streamable-tool",
+                            parameters: [
+                                {
+                                    parameterName: "input",
+                                    parameterValue: "non-streamed-input",
+                                },
+                            ],
+                        },
+                    },
+                    componentState: {},
+                    createdAt: new Date().toISOString(),
+                },
+                generationStage: generate_component_response_1.GenerationStage.STREAMING_RESPONSE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            const mockFinalChunk = {
+                responseMessageDto: {
+                    id: "streaming-chunk",
+                    content: [{ type: "text", text: "Complete" }],
+                    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 mockInitialChunk;
+                    yield mockStreamableToolChunk;
+                    yield mockNonStreamableToolChunk;
+                    yield mockFinalChunk;
+                },
+            };
+            jest.mocked(typescript_sdk_1.advanceStream).mockResolvedValueOnce(mockAsyncIterator);
+            const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
+                wrapper: createWrapper({
+                    components: customToolRegistry,
+                    streaming: true,
+                }),
+            });
+            await (0, react_1.act)(async () => {
+                await result.current.sendThreadMessage("Test mixed tools", {
+                    threadId: "test-thread-1",
+                    streamResponse: true,
+                });
+            });
+            // Only the streamable tool should be called during streaming
+            expect(streamableToolFn).toHaveBeenCalledWith({
+                input: "streamed-input",
+            });
+            expect(nonStreamableToolFn).not.toHaveBeenCalled();
+        });
+    });
     describe("auto-generate thread name", () => {
         it("should auto-generate thread name after reaching threshold", async () => {
-            const WrapperWithAutoGenerate = ({ children, }) => {
-                const client = (0, tambo_client_provider_1.useTamboClient)();
-                const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-                return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: mockRegistry },
-                        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, autoGenerateNameThreshold: 2 }, children))))));
-            };
             const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-                wrapper: WrapperWithAutoGenerate,
+                wrapper: createWrapper({ autoGenerateNameThreshold: 2 }),
             });
             const existingThread = createMockThread({
                 id: "test-thread-1",
@@ -1416,24 +1655,11 @@ 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, }) => {
-                const client = (0, tambo_client_provider_1.useTamboClient)();
-                const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-                return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: mockRegistry },
-                        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, autoGenerateThreadName: false, autoGenerateNameThreshold: 2 }, children))))));
-            };
             const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-                wrapper: WrapperWithDisabled,
+                wrapper: createWrapper({
+                    autoGenerateThreadName: false,
+                    autoGenerateNameThreshold: 2,
+                }),
             });
             const existingThread = createMockThread({
                 id: "test-thread-1",
@@ -1466,24 +1692,8 @@ describe("TamboThreadProvider", () => {
             expect(mockThreadsApi.generateName).not.toHaveBeenCalled();
         });
         it("should NOT auto-generate when thread already has a name", async () => {
-            const WrapperWithAutoGenerate = ({ children, }) => {
-                const client = (0, tambo_client_provider_1.useTamboClient)();
-                const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-                return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: mockRegistry },
-                        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, autoGenerateNameThreshold: 2 }, children))))));
-            };
             const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-                wrapper: WrapperWithAutoGenerate,
+                wrapper: createWrapper({ autoGenerateNameThreshold: 2 }),
             });
             const threadWithName = createMockThread({
                 id: "test-thread-1",
@@ -1521,24 +1731,8 @@ describe("TamboThreadProvider", () => {
             expect(mockThreadsApi.generateName).not.toHaveBeenCalled();
         });
         it("should NOT auto-generate for placeholder thread", async () => {
-            const WrapperWithAutoGenerate = ({ children, }) => {
-                const client = (0, tambo_client_provider_1.useTamboClient)();
-                const queryClient = (0, tambo_client_provider_1.useTamboQueryClient)();
-                return (react_2.default.createElement(tambo_client_provider_1.TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    react_2.default.createElement(tambo_registry_provider_1.TamboRegistryProvider, { components: mockRegistry },
-                        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, autoGenerateNameThreshold: 2 }, children))))));
-            };
             const { result } = (0, react_1.renderHook)(() => (0, tambo_thread_provider_1.useTamboThread)(), {
-                wrapper: WrapperWithAutoGenerate,
+                wrapper: createWrapper({ autoGenerateNameThreshold: 2 }),
             });
             // Stay on placeholder thread
             expect(result.current.thread.id).toBe("placeholder");