@tambo-ai/react 0.68.0 → 0.69.1

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

@@ -110,8 +110,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 = useTamboClient();
         const queryClient = useTamboQueryClient();
         return (React.createElement(TamboClientContext.Provider, { value: {
@@ -119,14 +129,16 @@ describe("TamboThreadProvider", () => {
                 queryClient,
                 isUpdatingToken: false,
             } },
-            React.createElement(TamboRegistryProvider, { components: mockRegistry },
+            React.createElement(TamboRegistryProvider, { components: components, onCallUnregisteredTool: onCallUnregisteredTool },
                 React.createElement(TamboContextHelpersProvider, { contextHelpers: {
                         currentTimeContextHelper: () => null,
                         currentPageContextHelper: () => null,
                     } },
                     React.createElement(TamboMcpTokenProvider, null,
-                        React.createElement(TamboThreadProvider, { streaming: false }, children))))));
+                        React.createElement(TamboThreadProvider, { streaming: streaming, autoGenerateThreadName: autoGenerateThreadName, autoGenerateNameThreshold: autoGenerateNameThreshold }, children))))));
     };
+    // Default wrapper for most tests
+    const Wrapper = createWrapper();
     beforeEach(() => {
         jest.clearAllMocks();
         // Setup mock query client
@@ -344,22 +356,6 @@ describe("TamboThreadProvider", () => {
         const mockOnCallUnregisteredTool = jest
             .fn()
             .mockResolvedValue("unregistered-tool-result");
-        const WrapperWithUnregisteredTool = ({ children, }) => {
-            const client = useTamboClient();
-            const queryClient = useTamboQueryClient();
-            return (React.createElement(TamboClientContext.Provider, { value: {
-                    client,
-                    queryClient,
-                    isUpdatingToken: false,
-                } },
-                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",
@@ -394,7 +390,9 @@ describe("TamboThreadProvider", () => {
             mcpAccessToken: "test-mcp-access-token",
         });
         const { result } = renderHook(() => useTamboThread(), {
-            wrapper: WrapperWithUnregisteredTool,
+            wrapper: createWrapper({
+                onCallUnregisteredTool: mockOnCallUnregisteredTool,
+            }),
         });
         await act(async () => {
             await result.current.sendThreadMessage("Use unregistered tool", {
@@ -451,23 +449,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 = useTamboClient();
-                const queryClient = useTamboQueryClient();
-                return (React.createElement(TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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",
@@ -488,7 +469,7 @@ describe("TamboThreadProvider", () => {
             };
             jest.mocked(advanceStream).mockResolvedValue(mockAsyncIterator);
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: WrapperWithStreaming,
+                wrapper: createWrapper({ streaming: true }),
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Hello streaming", {
@@ -523,24 +504,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 = useTamboClient();
-                const queryClient = useTamboQueryClient();
-                return (React.createElement(TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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: createWrapper({ streaming: true }),
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Hello non-streaming", {
@@ -575,24 +540,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 = useTamboClient();
-                const queryClient = useTamboQueryClient();
-                return (React.createElement(TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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: createWrapper({ streaming: false }),
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Hello default", {
@@ -626,23 +575,6 @@ describe("TamboThreadProvider", () => {
             expect(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 = useTamboClient();
-                const queryClient = useTamboQueryClient();
-                return (React.createElement(TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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",
@@ -663,7 +595,7 @@ describe("TamboThreadProvider", () => {
             };
             jest.mocked(advanceStream).mockResolvedValue(mockAsyncIterator);
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: WrapperWithDefaultStreaming,
+                wrapper: createWrapper({ streaming: true }),
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Hello default streaming", {
@@ -698,24 +630,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 = useTamboClient();
-                const queryClient = useTamboQueryClient();
-                return (React.createElement(TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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: createWrapper({ streaming: true }),
             });
             // Start with placeholder thread (which is the default state)
             expect(result.current.thread.id).toBe("placeholder");
@@ -751,23 +667,6 @@ describe("TamboThreadProvider", () => {
             expect(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 = useTamboClient();
-                const queryClient = useTamboQueryClient();
-                return (React.createElement(TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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",
@@ -788,7 +687,7 @@ describe("TamboThreadProvider", () => {
             };
             jest.mocked(advanceStream).mockResolvedValue(mockAsyncIterator);
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: WrapperWithoutStreaming,
+                wrapper: createWrapper({ streaming: false }),
             });
             // Start with placeholder thread (which is the default state)
             expect(result.current.thread.id).toBe("placeholder");
@@ -823,6 +722,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: 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: 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: GenerationStage.COMPLETE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            const mockAsyncIterator = {
+                [Symbol.asyncIterator]: async function* () {
+                    yield mockFirstMessage;
+                    yield mockSecondMessageChunk1;
+                    yield mockSecondMessageChunk2;
+                },
+            };
+            jest.mocked(advanceStream).mockResolvedValue(mockAsyncIterator);
+            const { result } = renderHook(() => useTamboThread(), {
+                wrapper: createWrapper({ streaming: true }),
+            });
+            await 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(GenerationStage.COMPLETE);
+        });
     });
     describe("error handling", () => {
         it("should set generation stage to ERROR when non-streaming sendThreadMessage fails", async () => {
@@ -973,22 +960,6 @@ describe("TamboThreadProvider", () => {
                     ],
                 },
             ];
-            const WrapperWithCustomTool = ({ children, }) => {
-                const client = useTamboClient();
-                const queryClient = useTamboQueryClient();
-                return (React.createElement(TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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",
@@ -1021,7 +992,7 @@ describe("TamboThreadProvider", () => {
                 mcpAccessToken: "test-mcp-access-token",
             });
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: WrapperWithCustomTool,
+                wrapper: createWrapper({ components: customToolRegistry }),
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Use custom tool", {
@@ -1074,22 +1045,6 @@ describe("TamboThreadProvider", () => {
                     ],
                 },
             ];
-            const WrapperWithAsyncTool = ({ children, }) => {
-                const client = useTamboClient();
-                const queryClient = useTamboQueryClient();
-                return (React.createElement(TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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",
@@ -1135,7 +1090,10 @@ describe("TamboThreadProvider", () => {
                 },
             });
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: WrapperWithAsyncTool,
+                wrapper: createWrapper({
+                    components: customToolRegistry,
+                    streaming: true,
+                }),
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Use async tool", {
@@ -1183,22 +1141,6 @@ describe("TamboThreadProvider", () => {
                     ],
                 },
             ];
-            const WrapperWithoutTransform = ({ children, }) => {
-                const client = useTamboClient();
-                const queryClient = useTamboQueryClient();
-                return (React.createElement(TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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",
@@ -1231,7 +1173,7 @@ describe("TamboThreadProvider", () => {
                 mcpAccessToken: "test-mcp-access-token",
             });
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: WrapperWithoutTransform,
+                wrapper: createWrapper({ components: toolWithoutTransform }),
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Use tool without transform", {
@@ -1281,22 +1223,6 @@ describe("TamboThreadProvider", () => {
                     ],
                 },
             ];
-            const WrapperWithErrorTool = ({ children, }) => {
-                const client = useTamboClient();
-                const queryClient = useTamboQueryClient();
-                return (React.createElement(TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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",
@@ -1329,7 +1255,7 @@ describe("TamboThreadProvider", () => {
                 mcpAccessToken: "test-mcp-access-token",
             });
             const { result } = renderHook(() => useTamboThread(), {
-                wrapper: WrapperWithErrorTool,
+                wrapper: createWrapper({ components: toolWithTransform }),
             });
             await act(async () => {
                 await result.current.sendThreadMessage("Use error tool", {
@@ -1355,26 +1281,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.createElement("div", null, "Test"),
+                    description: "Test",
+                    propsSchema: z.object({ test: z.string() }),
+                    associatedTools: [
+                        {
+                            name: "streamable-tool",
+                            tool: streamableToolFn,
+                            description: "Tool safe for streaming",
+                            inputSchema: z.object({ input: z.string() }),
+                            outputSchema: z.object({ data: 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: 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: 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: GenerationStage.COMPLETE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            const mockAsyncIterator = {
+                [Symbol.asyncIterator]: async function* () {
+                    yield mockInitialChunk;
+                    yield mockToolCallChunk;
+                    yield mockFinalChunk;
+                },
+            };
+            jest.mocked(advanceStream).mockResolvedValueOnce(mockAsyncIterator);
+            const { result } = renderHook(() => useTamboThread(), {
+                wrapper: createWrapper({
+                    components: customToolRegistry,
+                    streaming: true,
+                }),
+            });
+            await 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.createElement("div", null, "Test"),
+                    description: "Test",
+                    propsSchema: z.object({ test: z.string() }),
+                    associatedTools: [
+                        {
+                            name: "non-streamable-tool",
+                            tool: nonStreamableToolFn,
+                            description: "Tool not safe for streaming",
+                            inputSchema: z.object({ input: z.string() }),
+                            outputSchema: z.object({ data: 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: 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: 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: GenerationStage.COMPLETE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            const mockAsyncIterator = {
+                [Symbol.asyncIterator]: async function* () {
+                    yield mockInitialChunk;
+                    yield mockToolCallChunk;
+                    yield mockFinalChunk;
+                },
+            };
+            jest.mocked(advanceStream).mockResolvedValueOnce(mockAsyncIterator);
+            const { result } = renderHook(() => useTamboThread(), {
+                wrapper: createWrapper({
+                    components: customToolRegistry,
+                    streaming: true,
+                }),
+            });
+            await 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.createElement("div", null, "Test"),
+                    description: "Test",
+                    propsSchema: z.object({ test: z.string() }),
+                    associatedTools: [
+                        {
+                            name: "streamable-tool",
+                            tool: streamableToolFn,
+                            description: "Tool safe for streaming",
+                            inputSchema: z.object({ input: z.string() }),
+                            outputSchema: z.object({ data: z.string() }),
+                            annotations: { tamboStreamableHint: true },
+                        },
+                        {
+                            name: "non-streamable-tool",
+                            tool: nonStreamableToolFn,
+                            description: "Tool not safe for streaming",
+                            inputSchema: z.object({ input: z.string() }),
+                            outputSchema: z.object({ data: 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: 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: 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: 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: GenerationStage.COMPLETE,
+                mcpAccessToken: "test-mcp-access-token",
+            };
+            const mockAsyncIterator = {
+                [Symbol.asyncIterator]: async function* () {
+                    yield mockInitialChunk;
+                    yield mockStreamableToolChunk;
+                    yield mockNonStreamableToolChunk;
+                    yield mockFinalChunk;
+                },
+            };
+            jest.mocked(advanceStream).mockResolvedValueOnce(mockAsyncIterator);
+            const { result } = renderHook(() => useTamboThread(), {
+                wrapper: createWrapper({
+                    components: customToolRegistry,
+                    streaming: true,
+                }),
+            });
+            await 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 = useTamboClient();
-                const queryClient = useTamboQueryClient();
-                return (React.createElement(TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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: createWrapper({ autoGenerateNameThreshold: 2 }),
             });
             const existingThread = createMockThread({
                 id: "test-thread-1",
@@ -1411,24 +1650,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 = useTamboClient();
-                const queryClient = useTamboQueryClient();
-                return (React.createElement(TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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: createWrapper({
+                    autoGenerateThreadName: false,
+                    autoGenerateNameThreshold: 2,
+                }),
             });
             const existingThread = createMockThread({
                 id: "test-thread-1",
@@ -1461,24 +1687,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 = useTamboClient();
-                const queryClient = useTamboQueryClient();
-                return (React.createElement(TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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: createWrapper({ autoGenerateNameThreshold: 2 }),
             });
             const threadWithName = createMockThread({
                 id: "test-thread-1",
@@ -1516,24 +1726,8 @@ describe("TamboThreadProvider", () => {
             expect(mockThreadsApi.generateName).not.toHaveBeenCalled();
         });
         it("should NOT auto-generate for placeholder thread", async () => {
-            const WrapperWithAutoGenerate = ({ children, }) => {
-                const client = useTamboClient();
-                const queryClient = useTamboQueryClient();
-                return (React.createElement(TamboClientContext.Provider, { value: {
-                        client,
-                        queryClient,
-                        isUpdatingToken: false,
-                    } },
-                    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: createWrapper({ autoGenerateNameThreshold: 2 }),
             });
             // Stay on placeholder thread
             expect(result.current.thread.id).toBe("placeholder");