@tambo-ai/react 0.70.0 → 0.71.0

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

@@ -0,0 +1,822 @@
+import { EventType } from "@ag-ui/core";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { renderHook, waitFor, act } from "@testing-library/react";
+import React from "react";
+import { z } from "zod";
+import { useTamboClient } from "../../providers/tambo-client-provider";
+import { TamboRegistryContext } from "../../providers/tambo-registry-provider";
+import { TamboV1StreamProvider } from "../providers/tambo-v1-stream-context";
+import { createRunStream, useTamboV1SendMessage, } from "./use-tambo-v1-send-message";
+jest.mock("../../providers/tambo-client-provider", () => ({
+    useTamboClient: jest.fn(),
+}));
+describe("useTamboV1SendMessage", () => {
+    const mockThreadsRunsApi = {
+        run: jest.fn(),
+        create: jest.fn(),
+    };
+    const mockTamboAI = {
+        apiKey: "",
+        threads: {
+            runs: mockThreadsRunsApi,
+        },
+    };
+    const mockRegistry = {
+        componentList: new Map(),
+        toolRegistry: new Map(),
+    };
+    let queryClient;
+    function TestWrapper({ children }) {
+        return (React.createElement(QueryClientProvider, { client: queryClient },
+            React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
+                React.createElement(TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+    }
+    beforeEach(() => {
+        queryClient = new QueryClient({
+            defaultOptions: {
+                queries: { retry: false },
+                mutations: { retry: false },
+            },
+        });
+        jest.mocked(useTamboClient).mockReturnValue(mockTamboAI);
+        mockThreadsRunsApi.run.mockReset();
+        mockThreadsRunsApi.create.mockReset();
+    });
+    it("returns a mutation object", () => {
+        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        expect(result.current.mutate).toBeDefined();
+        expect(result.current.mutateAsync).toBeDefined();
+        expect(result.current.isPending).toBe(false);
+    });
+    it("returns a mutation object when threadId is not provided", () => {
+        const { result } = renderHook(() => useTamboV1SendMessage(), {
+            wrapper: TestWrapper,
+        });
+        expect(result.current.mutate).toBeDefined();
+        expect(result.current.mutateAsync).toBeDefined();
+    });
+});
+describe("createRunStream", () => {
+    const mockStream = {
+        [Symbol.asyncIterator]: async function* () {
+            yield { type: "RUN_STARTED", runId: "run_1", threadId: "thread_123" };
+        },
+    };
+    const mockThreadsRunsApi = {
+        run: jest.fn(),
+        create: jest.fn(),
+    };
+    const mockClient = {
+        threads: {
+            runs: mockThreadsRunsApi,
+        },
+    };
+    const mockRegistry = {
+        componentList: new Map([
+            [
+                "TestComponent",
+                {
+                    name: "TestComponent",
+                    description: "A test component",
+                    component: () => null,
+                    propsSchema: z.object({ title: z.string() }),
+                },
+            ],
+        ]),
+        toolRegistry: new Map([
+            [
+                "testTool",
+                {
+                    name: "testTool",
+                    description: "A test tool",
+                    tool: async () => "result",
+                    inputSchema: z.object({ query: z.string() }),
+                },
+            ],
+        ]),
+    };
+    const testMessage = {
+        role: "user",
+        content: [{ type: "text", text: "Hello" }],
+    };
+    beforeEach(() => {
+        mockThreadsRunsApi.run.mockReset();
+        mockThreadsRunsApi.create.mockReset();
+    });
+    it("calls client.threads.runs.run when threadId is provided", async () => {
+        mockThreadsRunsApi.run.mockResolvedValue(mockStream);
+        const result = await createRunStream({
+            client: mockClient,
+            threadId: "thread_123",
+            message: testMessage,
+            registry: mockRegistry,
+        });
+        expect(mockThreadsRunsApi.run).toHaveBeenCalledWith("thread_123", {
+            message: testMessage,
+            availableComponents: expect.any(Array),
+            tools: expect.any(Array),
+        });
+        expect(mockThreadsRunsApi.create).not.toHaveBeenCalled();
+        expect(result.stream).toBe(mockStream);
+        expect(result.initialThreadId).toBe("thread_123");
+    });
+    it("calls client.threads.runs.create when threadId is not provided", async () => {
+        mockThreadsRunsApi.create.mockResolvedValue(mockStream);
+        const result = await createRunStream({
+            client: mockClient,
+            threadId: undefined,
+            message: testMessage,
+            registry: mockRegistry,
+        });
+        expect(mockThreadsRunsApi.create).toHaveBeenCalledWith({
+            message: testMessage,
+            availableComponents: expect.any(Array),
+            tools: expect.any(Array),
+        });
+        expect(mockThreadsRunsApi.run).not.toHaveBeenCalled();
+        expect(result.stream).toBe(mockStream);
+        expect(result.initialThreadId).toBeUndefined();
+    });
+    it("converts registry components to availableComponents format", async () => {
+        mockThreadsRunsApi.run.mockResolvedValue(mockStream);
+        await createRunStream({
+            client: mockClient,
+            threadId: "thread_123",
+            message: testMessage,
+            registry: mockRegistry,
+        });
+        const callArgs = mockThreadsRunsApi.run.mock.calls[0][1];
+        expect(callArgs.availableComponents).toEqual([
+            {
+                name: "TestComponent",
+                description: "A test component",
+                propsSchema: expect.any(Object),
+            },
+        ]);
+    });
+    it("converts registry tools to tools format", async () => {
+        mockThreadsRunsApi.run.mockResolvedValue(mockStream);
+        await createRunStream({
+            client: mockClient,
+            threadId: "thread_123",
+            message: testMessage,
+            registry: mockRegistry,
+        });
+        const callArgs = mockThreadsRunsApi.run.mock.calls[0][1];
+        expect(callArgs.tools).toEqual([
+            expect.objectContaining({
+                name: "testTool",
+                description: "A test tool",
+            }),
+        ]);
+    });
+    it("handles empty registry", async () => {
+        mockThreadsRunsApi.run.mockResolvedValue(mockStream);
+        const emptyRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map(),
+        };
+        await createRunStream({
+            client: mockClient,
+            threadId: "thread_123",
+            message: testMessage,
+            registry: emptyRegistry,
+        });
+        const callArgs = mockThreadsRunsApi.run.mock.calls[0][1];
+        expect(callArgs.availableComponents).toEqual([]);
+        expect(callArgs.tools).toEqual([]);
+    });
+});
+describe("useTamboV1SendMessage mutation", () => {
+    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);
+        mockThreadsRunsApi.run.mockReset();
+        mockThreadsRunsApi.create.mockReset();
+    });
+    it("extracts threadId from RUN_STARTED event when creating new thread", async () => {
+        const mockStream = createAsyncIterator([
+            {
+                type: EventType.RUN_STARTED,
+                runId: "run_1",
+                threadId: "new_thread_123",
+            },
+            { type: EventType.RUN_FINISHED },
+        ]);
+        mockThreadsRunsApi.create.mockResolvedValue(mockStream);
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map(),
+        };
+        function TestWrapper({ children }) {
+            return (React.createElement(QueryClientProvider, { client: queryClient },
+                React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
+                    React.createElement(TamboV1StreamProvider, null, children))));
+        }
+        const { result } = renderHook(() => useTamboV1SendMessage(), {
+            wrapper: TestWrapper,
+        });
+        let mutationResult;
+        await act(async () => {
+            mutationResult = await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Hello" }],
+                },
+            });
+        });
+        expect(mutationResult?.threadId).toBe("new_thread_123");
+    });
+    it("throws error when first event is not RUN_STARTED on new thread", async () => {
+        const mockStream = createAsyncIterator([
+            { type: EventType.TEXT_MESSAGE_START, messageId: "msg_1" },
+        ]);
+        mockThreadsRunsApi.create.mockResolvedValue(mockStream);
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map(),
+        };
+        function TestWrapper({ children }) {
+            return (React.createElement(QueryClientProvider, { client: queryClient },
+                React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
+                    React.createElement(TamboV1StreamProvider, null, children))));
+        }
+        const { result } = renderHook(() => useTamboV1SendMessage(), {
+            wrapper: TestWrapper,
+        });
+        await expect(act(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Hello" }],
+                },
+            });
+        })).rejects.toThrow("Expected first event to be RUN_STARTED with threadId");
+    });
+    it("executes tools on awaiting_input event", async () => {
+        const toolExecuted = jest.fn().mockResolvedValue("tool result");
+        const testTool = {
+            name: "test_tool",
+            description: "A test tool",
+            tool: toolExecuted,
+            inputSchema: z.object({ query: z.string() }),
+            outputSchema: z.string(),
+        };
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map([["test_tool", testTool]]),
+        };
+        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: "test_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: { pendingToolCallIds: ["call_1"] },
+            },
+        ]);
+        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(TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+        }
+        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await act(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Hello" }],
+                },
+            });
+        });
+        expect(toolExecuted).toHaveBeenCalledWith({ query: "test" });
+        // Verify continuation was called with tool results
+        expect(mockThreadsRunsApi.run).toHaveBeenCalledTimes(2);
+        const continueCall = mockThreadsRunsApi.run.mock.calls[1];
+        expect(continueCall[0]).toBe("thread_123");
+        expect(continueCall[1].previousRunId).toBe("run_1");
+        expect(continueCall[1].message.content[0]).toEqual({
+            type: "tool_result",
+            toolUseId: "call_1",
+            content: [{ type: "text", text: "tool result" }],
+        });
+    });
+    it("handles tool calls with chunked args", async () => {
+        const toolExecuted = jest.fn().mockResolvedValue({ result: 42 });
+        const testTool = {
+            name: "chunked_tool",
+            description: "Tool with chunked args",
+            tool: toolExecuted,
+            inputSchema: z.object({ a: z.number(), b: z.number() }),
+            outputSchema: z.object({ result: z.number() }),
+        };
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map([["chunked_tool", testTool]]),
+        };
+        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: "chunked_tool",
+                parentMessageId: "msg_1",
+            },
+            {
+                type: EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_1",
+                delta: '{"a":',
+            },
+            {
+                type: EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_1",
+                delta: "10,",
+            },
+            {
+                type: EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_1",
+                delta: '"b":20}',
+            },
+            {
+                type: EventType.TOOL_CALL_END,
+                toolCallId: "call_1",
+            },
+            {
+                type: EventType.CUSTOM,
+                name: "tambo.run.awaiting_input",
+                value: { pendingToolCallIds: ["call_1"] },
+            },
+        ]);
+        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(TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+        }
+        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await act(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Calculate" }],
+                },
+            });
+        });
+        expect(toolExecuted).toHaveBeenCalledWith({ a: 10, b: 20 });
+    });
+    it("handles missing TOOL_CALL_ARGS gracefully", async () => {
+        // Test that tools can be executed even when no args events are received
+        // (the hook keeps input as empty object)
+        const toolExecuted = jest.fn().mockResolvedValue("result");
+        const testTool = {
+            name: "test_tool",
+            description: "Test tool",
+            tool: toolExecuted,
+            inputSchema: z.object({}),
+            outputSchema: z.string(),
+        };
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map([["test_tool", testTool]]),
+        };
+        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: "test_tool",
+                parentMessageId: "msg_1",
+            },
+            // No TOOL_CALL_ARGS events - args will be empty
+            {
+                type: EventType.TOOL_CALL_END,
+                toolCallId: "call_1",
+            },
+            {
+                type: EventType.CUSTOM,
+                name: "tambo.run.awaiting_input",
+                value: { pendingToolCallIds: ["call_1"] },
+            },
+        ]);
+        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(TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+        }
+        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await act(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Test" }],
+                },
+            });
+        });
+        // Tool should be called with empty input due to no args events
+        expect(toolExecuted).toHaveBeenCalledWith({});
+    });
+    it("handles unknown tool in awaiting_input by returning error result", async () => {
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map(), // Empty registry - tool not found
+        };
+        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: "unknown_tool",
+                parentMessageId: "msg_1",
+            },
+            {
+                type: EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_1",
+                delta: "{}",
+            },
+            {
+                type: EventType.TOOL_CALL_END,
+                toolCallId: "call_1",
+            },
+            {
+                type: EventType.CUSTOM,
+                name: "tambo.run.awaiting_input",
+                value: { pendingToolCallIds: ["call_1"] },
+            },
+        ]);
+        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(TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+        }
+        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await act(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Test" }],
+                },
+            });
+        });
+        // Verify continuation was called (second call)
+        expect(mockThreadsRunsApi.run).toHaveBeenCalledTimes(2);
+        // Continuation should include error message for unknown tool
+        const continueCall = mockThreadsRunsApi.run.mock.calls[1];
+        expect(continueCall[1].message.content[0]).toEqual({
+            type: "tool_result",
+            toolUseId: "call_1",
+            content: [
+                { type: "text", text: 'Tool "unknown_tool" not found in registry' },
+            ],
+        });
+    });
+    it("works with default registry context when no provider is present", () => {
+        // TamboRegistryContext has a default value, so the hook should work
+        // (though with an empty registry)
+        function TestWrapperWithoutRegistry({ children, }) {
+            return (React.createElement(QueryClientProvider, { client: queryClient },
+                React.createElement(TamboV1StreamProvider, { threadId: "thread_123" }, children)));
+        }
+        // Should not throw - default context is used
+        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+            wrapper: TestWrapperWithoutRegistry,
+        });
+        expect(result.current.mutate).toBeDefined();
+    });
+    it("invalidates queries on successful mutation", async () => {
+        const mockStream = createAsyncIterator([
+            {
+                type: EventType.RUN_STARTED,
+                runId: "run_1",
+                threadId: "thread_123",
+            },
+            { type: EventType.RUN_FINISHED },
+        ]);
+        mockThreadsRunsApi.run.mockResolvedValue(mockStream);
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map(),
+        };
+        function TestWrapper({ children }) {
+            return (React.createElement(QueryClientProvider, { client: queryClient },
+                React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
+                    React.createElement(TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+        }
+        const invalidateQueriesSpy = jest.spyOn(queryClient, "invalidateQueries");
+        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await act(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Hello" }],
+                },
+            });
+        });
+        await waitFor(() => {
+            expect(invalidateQueriesSpy).toHaveBeenCalledWith({
+                queryKey: ["v1-threads", "thread_123"],
+            });
+        });
+    });
+    it("handles multi-round tool execution (tool→AI→tool→AI)", async () => {
+        const tool1Executed = jest.fn().mockResolvedValue("result from tool 1");
+        const tool2Executed = jest.fn().mockResolvedValue("result from tool 2");
+        const tool1 = {
+            name: "tool_1",
+            description: "First tool",
+            tool: tool1Executed,
+            inputSchema: z.object({ input: z.string() }),
+            outputSchema: z.string(),
+        };
+        const tool2 = {
+            name: "tool_2",
+            description: "Second tool",
+            tool: tool2Executed,
+            inputSchema: z.object({ input: z.string() }),
+            outputSchema: z.string(),
+        };
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map([
+                ["tool_1", tool1],
+                ["tool_2", tool2],
+            ]),
+        };
+        // Initial stream: AI calls tool_1
+        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: "tool_1",
+                parentMessageId: "msg_1",
+            },
+            {
+                type: EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_1",
+                delta: '{"input":"first"}',
+            },
+            { type: EventType.TOOL_CALL_END, toolCallId: "call_1" },
+            {
+                type: EventType.CUSTOM,
+                name: "tambo.run.awaiting_input",
+                value: { pendingToolCallIds: ["call_1"] },
+            },
+        ]);
+        // Second stream: AI receives tool_1 result, then calls tool_2
+        const secondStream = createAsyncIterator([
+            {
+                type: EventType.RUN_STARTED,
+                runId: "run_2",
+                threadId: "thread_123",
+            },
+            {
+                type: EventType.TEXT_MESSAGE_START,
+                messageId: "msg_2",
+                role: "assistant",
+            },
+            {
+                type: EventType.TOOL_CALL_START,
+                toolCallId: "call_2",
+                toolCallName: "tool_2",
+                parentMessageId: "msg_2",
+            },
+            {
+                type: EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_2",
+                delta: '{"input":"second"}',
+            },
+            { type: EventType.TOOL_CALL_END, toolCallId: "call_2" },
+            {
+                type: EventType.CUSTOM,
+                name: "tambo.run.awaiting_input",
+                value: { pendingToolCallIds: ["call_2"] },
+            },
+        ]);
+        // Third stream: AI receives tool_2 result, finishes
+        const thirdStream = createAsyncIterator([
+            {
+                type: EventType.RUN_STARTED,
+                runId: "run_3",
+                threadId: "thread_123",
+            },
+            { type: EventType.RUN_FINISHED },
+        ]);
+        mockThreadsRunsApi.run
+            .mockResolvedValueOnce(initialStream)
+            .mockResolvedValueOnce(secondStream)
+            .mockResolvedValueOnce(thirdStream);
+        function TestWrapper({ children }) {
+            return (React.createElement(QueryClientProvider, { client: queryClient },
+                React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
+                    React.createElement(TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+        }
+        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await act(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Hello" }],
+                },
+            });
+        });
+        // Both tools should have been executed
+        expect(tool1Executed).toHaveBeenCalledWith({ input: "first" });
+        expect(tool2Executed).toHaveBeenCalledWith({ input: "second" });
+        // Should have made 3 API calls (initial + 2 continuations)
+        expect(mockThreadsRunsApi.run).toHaveBeenCalledTimes(3);
+        // First continuation should have tool_1 result with previousRunId: run_1
+        const firstContinue = mockThreadsRunsApi.run.mock.calls[1];
+        expect(firstContinue[1].previousRunId).toBe("run_1");
+        expect(firstContinue[1].message.content[0]).toEqual({
+            type: "tool_result",
+            toolUseId: "call_1",
+            content: [{ type: "text", text: "result from tool 1" }],
+        });
+        // Second continuation should have tool_2 result with previousRunId: run_2
+        const secondContinue = mockThreadsRunsApi.run.mock.calls[2];
+        expect(secondContinue[1].previousRunId).toBe("run_2");
+        expect(secondContinue[1].message.content[0]).toEqual({
+            type: "tool_result",
+            toolUseId: "call_2",
+            content: [{ type: "text", text: "result from tool 2" }],
+        });
+    });
+    it("logs error on mutation failure", async () => {
+        const consoleSpy = jest
+            .spyOn(console, "error")
+            .mockImplementation(() => { });
+        const testError = new Error("API Error");
+        mockThreadsRunsApi.run.mockRejectedValue(testError);
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map(),
+        };
+        function TestWrapper({ children }) {
+            return (React.createElement(QueryClientProvider, { client: queryClient },
+                React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
+                    React.createElement(TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+        }
+        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        try {
+            await act(async () => {
+                await result.current.mutateAsync({
+                    message: {
+                        role: "user",
+                        content: [{ type: "text", text: "Hello" }],
+                    },
+                });
+            });
+        }
+        catch {
+            // Expected to throw
+        }
+        await waitFor(() => {
+            expect(consoleSpy).toHaveBeenCalledWith("[useTamboV1SendMessage] Mutation failed:", testError);
+        });
+        consoleSpy.mockRestore();
+    });
+});
+//# sourceMappingURL=use-tambo-v1-send-message.test.js.map