@tambo-ai/react 0.74.1 → 1.0.0-rc.3

package/esm/v1/hooks/use-tambo-v1-send-message.test.js

@@ -5,22 +5,28 @@ import React from "react";
 import { z } from "zod";
 import { useTamboClient, useTamboQueryClient, } from "../../providers/tambo-client-provider.js";
 import { TamboRegistryContext } from "../../providers/tambo-registry-provider.js";
-import { useTamboV1Config } from "../providers/tambo-v1-provider.js";
-import { TamboV1StreamProvider } from "../providers/tambo-v1-stream-context.js";
-import { createRunStream, useTamboV1SendMessage, } from "./use-tambo-v1-send-message.js";
+import { useTamboConfig } from "../providers/tambo-v1-provider.js";
+import { TamboStreamProvider } from "../providers/tambo-v1-stream-context.js";
+import { createRunStream, useTamboSendMessage, } from "./use-tambo-v1-send-message.js";
 jest.mock("../../providers/tambo-client-provider", () => ({
     useTamboClient: jest.fn(),
     useTamboQueryClient: jest.fn(),
 }));
 jest.mock("../providers/tambo-v1-provider", () => ({
-    useTamboV1Config: jest.fn(),
+    useTamboConfig: jest.fn(),
+}));
+jest.mock("./use-tambo-v1-auth-state", () => ({
+    useTamboAuthState: () => ({
+        status: "identified",
+        source: "userKey",
+    }),
 }));
 jest.mock("../../providers/tambo-context-helpers-provider", () => ({
     useTamboContextHelpers: () => ({
         getAdditionalContext: jest.fn().mockResolvedValue([]),
     }),
 }));
-describe("useTamboV1SendMessage", () => {
+describe("useTamboSendMessage", () => {
     const mockThreadsRunsApi = {
         run: jest.fn(),
         create: jest.fn(),
@@ -39,7 +45,7 @@ describe("useTamboV1SendMessage", () => {
     function TestWrapper({ children }) {
         return (React.createElement(QueryClientProvider, { client: queryClient },
             React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
-                React.createElement(TamboV1StreamProvider, null, children))));
+                React.createElement(TamboStreamProvider, null, children))));
     }
     beforeEach(() => {
         queryClient = new QueryClient({
@@ -50,12 +56,12 @@ describe("useTamboV1SendMessage", () => {
         });
         jest.mocked(useTamboClient).mockReturnValue(mockTamboAI);
         jest.mocked(useTamboQueryClient).mockReturnValue(queryClient);
-        jest.mocked(useTamboV1Config).mockReturnValue({ userKey: undefined });
+        jest.mocked(useTamboConfig).mockReturnValue({ userKey: undefined });
         mockThreadsRunsApi.run.mockReset();
         mockThreadsRunsApi.create.mockReset();
     });
     it("returns a mutation object", () => {
-        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
             wrapper: TestWrapper,
         });
         expect(result.current.mutate).toBeDefined();
@@ -63,7 +69,7 @@ describe("useTamboV1SendMessage", () => {
         expect(result.current.isPending).toBe(false);
     });
     it("returns a mutation object when threadId is not provided", () => {
-        const { result } = renderHook(() => useTamboV1SendMessage(), {
+        const { result } = renderHook(() => useTamboSendMessage(), {
             wrapper: TestWrapper,
         });
         expect(result.current.mutate).toBeDefined();
@@ -240,7 +246,7 @@ describe("createRunStream", () => {
         expect(callArgs.tools).toEqual([]);
     });
 });
-describe("useTamboV1SendMessage mutation", () => {
+describe("useTamboSendMessage mutation", () => {
     const mockThreadsRunsApi = {
         run: jest.fn(),
         create: jest.fn(),
@@ -270,7 +276,7 @@ describe("useTamboV1SendMessage mutation", () => {
         });
         jest.mocked(useTamboClient).mockReturnValue(mockTamboAI);
         jest.mocked(useTamboQueryClient).mockReturnValue(queryClient);
-        jest.mocked(useTamboV1Config).mockReturnValue({ userKey: undefined });
+        jest.mocked(useTamboConfig).mockReturnValue({ userKey: undefined });
         mockThreadsRunsApi.run.mockReset();
         mockThreadsRunsApi.create.mockReset();
     });
@@ -291,9 +297,9 @@ describe("useTamboV1SendMessage mutation", () => {
         function TestWrapper({ children }) {
             return (React.createElement(QueryClientProvider, { client: queryClient },
                 React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
-                    React.createElement(TamboV1StreamProvider, null, children))));
+                    React.createElement(TamboStreamProvider, null, children))));
         }
-        const { result } = renderHook(() => useTamboV1SendMessage(), {
+        const { result } = renderHook(() => useTamboSendMessage(), {
             wrapper: TestWrapper,
         });
         let mutationResult;
@@ -319,9 +325,9 @@ describe("useTamboV1SendMessage mutation", () => {
         function TestWrapper({ children }) {
             return (React.createElement(QueryClientProvider, { client: queryClient },
                 React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
-                    React.createElement(TamboV1StreamProvider, null, children))));
+                    React.createElement(TamboStreamProvider, null, children))));
         }
-        const { result } = renderHook(() => useTamboV1SendMessage(), {
+        const { result } = renderHook(() => useTamboSendMessage(), {
             wrapper: TestWrapper,
         });
         await expect(act(async () => {
@@ -396,9 +402,9 @@ describe("useTamboV1SendMessage mutation", () => {
         function TestWrapper({ children }) {
             return (React.createElement(QueryClientProvider, { client: queryClient },
                 React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
-                    React.createElement(TamboV1StreamProvider, null, children))));
+                    React.createElement(TamboStreamProvider, null, children))));
         }
-        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
             wrapper: TestWrapper,
         });
         await act(async () => {
@@ -494,9 +500,9 @@ describe("useTamboV1SendMessage mutation", () => {
         function TestWrapper({ children }) {
             return (React.createElement(QueryClientProvider, { client: queryClient },
                 React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
-                    React.createElement(TamboV1StreamProvider, null, children))));
+                    React.createElement(TamboStreamProvider, null, children))));
         }
-        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
             wrapper: TestWrapper,
         });
         await act(async () => {
@@ -570,9 +576,9 @@ describe("useTamboV1SendMessage mutation", () => {
         function TestWrapper({ children }) {
             return (React.createElement(QueryClientProvider, { client: queryClient },
                 React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
-                    React.createElement(TamboV1StreamProvider, null, children))));
+                    React.createElement(TamboStreamProvider, null, children))));
         }
-        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
             wrapper: TestWrapper,
         });
         await act(async () => {
@@ -641,9 +647,9 @@ describe("useTamboV1SendMessage mutation", () => {
         function TestWrapper({ children }) {
             return (React.createElement(QueryClientProvider, { client: queryClient },
                 React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
-                    React.createElement(TamboV1StreamProvider, null, children))));
+                    React.createElement(TamboStreamProvider, null, children))));
         }
-        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
             wrapper: TestWrapper,
         });
         await act(async () => {
@@ -672,10 +678,10 @@ describe("useTamboV1SendMessage mutation", () => {
         // (though with an empty registry)
         function TestWrapperWithoutRegistry({ children, }) {
             return (React.createElement(QueryClientProvider, { client: queryClient },
-                React.createElement(TamboV1StreamProvider, null, children)));
+                React.createElement(TamboStreamProvider, null, children)));
         }
         // Should not throw - default context is used
-        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
             wrapper: TestWrapperWithoutRegistry,
         });
         expect(result.current.mutate).toBeDefined();
@@ -697,10 +703,10 @@ describe("useTamboV1SendMessage mutation", () => {
         function TestWrapper({ children }) {
             return (React.createElement(QueryClientProvider, { client: queryClient },
                 React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
-                    React.createElement(TamboV1StreamProvider, null, children))));
+                    React.createElement(TamboStreamProvider, null, children))));
         }
         const invalidateQueriesSpy = jest.spyOn(queryClient, "invalidateQueries");
-        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
             wrapper: TestWrapper,
         });
         await act(async () => {
@@ -825,9 +831,9 @@ describe("useTamboV1SendMessage mutation", () => {
         function TestWrapper({ children }) {
             return (React.createElement(QueryClientProvider, { client: queryClient },
                 React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
-                    React.createElement(TamboV1StreamProvider, null, children))));
+                    React.createElement(TamboStreamProvider, null, children))));
         }
-        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
             wrapper: TestWrapper,
         });
         await act(async () => {
@@ -860,6 +866,67 @@ describe("useTamboV1SendMessage mutation", () => {
             content: [{ type: "text", text: "result from tool 2" }],
         });
     });
+    it("uses lastCompletedRunId as previousRunId when streaming.runId is absent", async () => {
+        const mockStream = createAsyncIterator([
+            {
+                type: EventType.RUN_STARTED,
+                runId: "run_2",
+                threadId: "thread_123",
+            },
+            { type: EventType.RUN_FINISHED },
+        ]);
+        mockThreadsRunsApi.run.mockResolvedValue(mockStream);
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map(),
+        };
+        // Provide stream state with lastCompletedRunId but no active streaming.runId
+        const stateWithLastRun = {
+            currentThreadId: "thread_123",
+            threadMap: {
+                thread_123: {
+                    thread: {
+                        id: "thread_123",
+                        messages: [
+                            {
+                                id: "msg_1",
+                                role: "user",
+                                content: [{ type: "text", text: "Hello" }],
+                                createdAt: "2024-01-01T00:00:00.000Z",
+                            },
+                        ],
+                        status: "idle",
+                        createdAt: "2024-01-01T00:00:00.000Z",
+                        updatedAt: "2024-01-01T00:00:00.000Z",
+                        lastRunCancelled: false,
+                    },
+                    streaming: { status: "idle" },
+                    accumulatingToolArgs: new Map(),
+                    lastCompletedRunId: "run_1",
+                },
+            },
+        };
+        function TestWrapper({ children }) {
+            return (React.createElement(QueryClientProvider, { client: queryClient },
+                React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
+                    React.createElement(TamboStreamProvider, { state: stateWithLastRun, dispatch: jest.fn() }, children))));
+        }
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await act(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Follow-up" }],
+                },
+            });
+        });
+        // Should have used lastCompletedRunId as previousRunId
+        expect(mockThreadsRunsApi.run).toHaveBeenCalledWith("thread_123", expect.objectContaining({
+            previousRunId: "run_1",
+        }));
+    });
     it("logs error on mutation failure", async () => {
         const consoleSpy = jest
             .spyOn(console, "error")
@@ -873,9 +940,9 @@ describe("useTamboV1SendMessage mutation", () => {
         function TestWrapper({ children }) {
             return (React.createElement(QueryClientProvider, { client: queryClient },
                 React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
-                    React.createElement(TamboV1StreamProvider, null, children))));
+                    React.createElement(TamboStreamProvider, null, children))));
         }
-        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
             wrapper: TestWrapper,
         });
         try {
@@ -892,12 +959,12 @@ describe("useTamboV1SendMessage mutation", () => {
             // Expected to throw
         }
         await waitFor(() => {
-            expect(consoleSpy).toHaveBeenCalledWith("[useTamboV1SendMessage] Mutation failed:", testError);
+            expect(consoleSpy).toHaveBeenCalledWith("[useTamboSendMessage] Mutation failed:", testError);
         });
         consoleSpy.mockRestore();
     });
 });
-describe("useTamboV1SendMessage auto thread name generation", () => {
+describe("useTamboSendMessage auto thread name generation", () => {
     const mockGenerateName = jest.fn();
     const mockThreadsRunsApi = {
         run: jest.fn(),
@@ -931,7 +998,7 @@ describe("useTamboV1SendMessage auto thread name generation", () => {
     function TestWrapper({ children }) {
         return (React.createElement(QueryClientProvider, { client: queryClient },
             React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
-                React.createElement(TamboV1StreamProvider, null, children))));
+                React.createElement(TamboStreamProvider, null, children))));
     }
     function createFinishedStream(threadId) {
         return createAsyncIterator([
@@ -972,14 +1039,14 @@ describe("useTamboV1SendMessage auto thread name generation", () => {
     });
     it("calls generateName when message count reaches threshold", async () => {
         // Threshold=2. Pre-mutation=0, 0 + 2 = 2 >= 2 → fire
-        jest.mocked(useTamboV1Config).mockReturnValue({
+        jest.mocked(useTamboConfig).mockReturnValue({
             userKey: undefined,
             autoGenerateThreadName: true,
             autoGenerateNameThreshold: 2,
         });
         mockGenerateName.mockResolvedValue({ name: "Generated Thread Name" });
         mockThreadsRunsApi.run.mockResolvedValue(createFinishedStream("thread_123"));
-        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
             wrapper: TestWrapper,
         });
         await act(async () => {
@@ -995,13 +1062,13 @@ describe("useTamboV1SendMessage auto thread name generation", () => {
         });
     });
     it("does not call generateName when autoGenerateThreadName is false", async () => {
-        jest.mocked(useTamboV1Config).mockReturnValue({
+        jest.mocked(useTamboConfig).mockReturnValue({
             userKey: undefined,
             autoGenerateThreadName: false,
             autoGenerateNameThreshold: 3,
         });
         mockThreadsRunsApi.run.mockResolvedValue(createFinishedStream("thread_123"));
-        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
             wrapper: TestWrapper,
         });
         await act(async () => {
@@ -1017,13 +1084,13 @@ describe("useTamboV1SendMessage auto thread name generation", () => {
     });
     it("does not call generateName when message count is below threshold", async () => {
         // With threshold=3, preMutation=0 messages, 0 + 2 = 2 < 3 → skip
-        jest.mocked(useTamboV1Config).mockReturnValue({
+        jest.mocked(useTamboConfig).mockReturnValue({
             userKey: undefined,
             autoGenerateThreadName: true,
             autoGenerateNameThreshold: 3,
         });
         mockThreadsRunsApi.create.mockResolvedValue(createFinishedStream("new_thread"));
-        const { result } = renderHook(() => useTamboV1SendMessage(), {
+        const { result } = renderHook(() => useTamboSendMessage(), {
             wrapper: TestWrapper,
         });
         await act(async () => {
@@ -1038,7 +1105,7 @@ describe("useTamboV1SendMessage auto thread name generation", () => {
     });
     it("logs error when generateName fails (does not throw)", async () => {
         // Threshold=2. Pre-mutation=0, 0 + 2 = 2 >= 2 → fire
-        jest.mocked(useTamboV1Config).mockReturnValue({
+        jest.mocked(useTamboConfig).mockReturnValue({
             userKey: undefined,
             autoGenerateThreadName: true,
             autoGenerateNameThreshold: 2,
@@ -1048,7 +1115,7 @@ describe("useTamboV1SendMessage auto thread name generation", () => {
             .mockImplementation(() => { });
         mockGenerateName.mockRejectedValue(new Error("API error"));
         mockThreadsRunsApi.run.mockResolvedValue(createFinishedStream("thread_123"));
-        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
             wrapper: TestWrapper,
         });
         await act(async () => {
@@ -1060,18 +1127,18 @@ describe("useTamboV1SendMessage auto thread name generation", () => {
             });
         });
         await waitFor(() => {
-            expect(consoleSpy).toHaveBeenCalledWith("[useTamboV1SendMessage] Failed to auto-generate thread name:", expect.any(Error));
+            expect(consoleSpy).toHaveBeenCalledWith("[useTamboSendMessage] Failed to auto-generate thread name:", expect.any(Error));
         });
         consoleSpy.mockRestore();
     });
     it("uses default config values (enabled, threshold=3)", async () => {
         // Don't set autoGenerateThreadName/autoGenerateNameThreshold — defaults apply
-        jest.mocked(useTamboV1Config).mockReturnValue({
+        jest.mocked(useTamboConfig).mockReturnValue({
             userKey: undefined,
         });
         mockGenerateName.mockResolvedValue({ name: "Auto Name" });
         mockThreadsRunsApi.run.mockResolvedValue(createFinishedStream("thread_123"));
-        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
             wrapper: TestWrapper,
         });
         await act(async () => {
@@ -1086,4 +1153,210 @@ describe("useTamboV1SendMessage auto thread name generation", () => {
         expect(mockGenerateName).not.toHaveBeenCalled();
     });
 });
+describe("useTamboSendMessage tamboStreamableHint", () => {
+    const mockThreadsRunsApi = {
+        run: jest.fn(),
+        create: jest.fn(),
+    };
+    const mockTamboAI = {
+        apiKey: "",
+        threads: {
+            runs: mockThreadsRunsApi,
+        },
+    };
+    let queryClient;
+    function createAsyncIterator(events) {
+        return {
+            [Symbol.asyncIterator]: async function* () {
+                for (const event of events) {
+                    yield event;
+                }
+            },
+        };
+    }
+    beforeEach(() => {
+        queryClient = new QueryClient({
+            defaultOptions: {
+                queries: { retry: false },
+                mutations: { retry: false },
+            },
+        });
+        jest.mocked(useTamboClient).mockReturnValue(mockTamboAI);
+        jest.mocked(useTamboQueryClient).mockReturnValue(queryClient);
+        jest.mocked(useTamboConfig).mockReturnValue({ userKey: undefined });
+        mockThreadsRunsApi.run.mockReset();
+        mockThreadsRunsApi.create.mockReset();
+    });
+    it("calls streamable tool on TOOL_CALL_ARGS events during streaming", async () => {
+        const streamableToolFn = jest.fn().mockResolvedValue(undefined);
+        const streamableTool = {
+            name: "write_story",
+            description: "Writes a story",
+            tool: streamableToolFn,
+            inputSchema: z.object({ text: z.string() }),
+            outputSchema: z.void(),
+            annotations: { tamboStreamableHint: true },
+        };
+        // Use Record (not Map) for toolRegistry — matches real runtime type
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: { write_story: streamableTool },
+        };
+        const initialStream = createAsyncIterator([
+            {
+                type: EventType.RUN_STARTED,
+                runId: "run_1",
+                threadId: "thread_123",
+            },
+            {
+                type: EventType.TEXT_MESSAGE_START,
+                messageId: "msg_1",
+                role: "assistant",
+            },
+            {
+                type: EventType.TOOL_CALL_START,
+                toolCallId: "call_1",
+                toolCallName: "write_story",
+                parentMessageId: "msg_1",
+            },
+            {
+                type: EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_1",
+                delta: '{"text":"Once upon',
+            },
+            {
+                type: EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_1",
+                delta: ' a time"}',
+            },
+            {
+                type: EventType.TOOL_CALL_END,
+                toolCallId: "call_1",
+            },
+            {
+                type: EventType.CUSTOM,
+                name: "tambo.run.awaiting_input",
+                value: {
+                    pendingToolCalls: [
+                        { toolCallId: "call_1", toolName: "write_story", arguments: "{}" },
+                    ],
+                },
+            },
+        ]);
+        const continueStream = createAsyncIterator([
+            {
+                type: EventType.RUN_STARTED,
+                runId: "run_2",
+                threadId: "thread_123",
+            },
+            { type: EventType.RUN_FINISHED },
+        ]);
+        mockThreadsRunsApi.run
+            .mockResolvedValueOnce(initialStream)
+            .mockResolvedValueOnce(continueStream);
+        function TestWrapper({ children }) {
+            return (React.createElement(QueryClientProvider, { client: queryClient },
+                React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
+                    React.createElement(TamboStreamProvider, null, children))));
+        }
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await act(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Write me a story" }],
+                },
+            });
+        });
+        // Streamable tool should have been called during TOOL_CALL_ARGS events
+        // (at least once per parseable chunk)
+        expect(streamableToolFn.mock.calls.length).toBeGreaterThanOrEqual(1);
+        // Each streaming call should have had partial args
+        const firstStreamingCall = streamableToolFn.mock.calls[0][0];
+        expect(firstStreamingCall).toHaveProperty("text");
+    });
+    it("does NOT call non-streamable tool during TOOL_CALL_ARGS events", async () => {
+        const normalToolFn = jest.fn().mockResolvedValue("result");
+        const normalTool = {
+            name: "normal_tool",
+            description: "Normal tool (not streamable)",
+            tool: normalToolFn,
+            inputSchema: z.object({ query: z.string() }),
+            outputSchema: z.string(),
+            // No tamboStreamableHint
+        };
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: { normal_tool: normalTool },
+        };
+        const initialStream = createAsyncIterator([
+            {
+                type: EventType.RUN_STARTED,
+                runId: "run_1",
+                threadId: "thread_123",
+            },
+            {
+                type: EventType.TEXT_MESSAGE_START,
+                messageId: "msg_1",
+                role: "assistant",
+            },
+            {
+                type: EventType.TOOL_CALL_START,
+                toolCallId: "call_1",
+                toolCallName: "normal_tool",
+                parentMessageId: "msg_1",
+            },
+            {
+                type: EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_1",
+                delta: '{"query":"test"}',
+            },
+            {
+                type: EventType.TOOL_CALL_END,
+                toolCallId: "call_1",
+            },
+            {
+                type: EventType.CUSTOM,
+                name: "tambo.run.awaiting_input",
+                value: {
+                    pendingToolCalls: [
+                        { toolCallId: "call_1", toolName: "normal_tool", arguments: "{}" },
+                    ],
+                },
+            },
+        ]);
+        const continueStream = createAsyncIterator([
+            {
+                type: EventType.RUN_STARTED,
+                runId: "run_2",
+                threadId: "thread_123",
+            },
+            { type: EventType.RUN_FINISHED },
+        ]);
+        mockThreadsRunsApi.run
+            .mockResolvedValueOnce(initialStream)
+            .mockResolvedValueOnce(continueStream);
+        function TestWrapper({ children }) {
+            return (React.createElement(QueryClientProvider, { client: queryClient },
+                React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
+                    React.createElement(TamboStreamProvider, null, children))));
+        }
+        const { result } = renderHook(() => useTamboSendMessage("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await act(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Test" }],
+                },
+            });
+        });
+        // Tool should only be called once at awaiting_input, not during streaming
+        expect(normalToolFn).toHaveBeenCalledTimes(1);
+        expect(normalToolFn).toHaveBeenCalledWith({ query: "test" });
+    });
+});
 //# sourceMappingURL=use-tambo-v1-send-message.test.js.map