@tambo-ai/react 0.70.0 → 0.71.0

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

@@ -0,0 +1,827 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@ag-ui/core");
+const react_query_1 = require("@tanstack/react-query");
+const react_1 = require("@testing-library/react");
+const react_2 = __importDefault(require("react"));
+const zod_1 = require("zod");
+const tambo_client_provider_1 = require("../../providers/tambo-client-provider");
+const tambo_registry_provider_1 = require("../../providers/tambo-registry-provider");
+const tambo_v1_stream_context_1 = require("../providers/tambo-v1-stream-context");
+const use_tambo_v1_send_message_1 = require("./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_2.default.createElement(react_query_1.QueryClientProvider, { client: queryClient },
+            react_2.default.createElement(tambo_registry_provider_1.TamboRegistryContext.Provider, { value: mockRegistry },
+                react_2.default.createElement(tambo_v1_stream_context_1.TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+    }
+    beforeEach(() => {
+        queryClient = new react_query_1.QueryClient({
+            defaultOptions: {
+                queries: { retry: false },
+                mutations: { retry: false },
+            },
+        });
+        jest.mocked(tambo_client_provider_1.useTamboClient).mockReturnValue(mockTamboAI);
+        mockThreadsRunsApi.run.mockReset();
+        mockThreadsRunsApi.create.mockReset();
+    });
+    it("returns a mutation object", () => {
+        const { result } = (0, react_1.renderHook)(() => (0, use_tambo_v1_send_message_1.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 } = (0, react_1.renderHook)(() => (0, use_tambo_v1_send_message_1.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: zod_1.z.object({ title: zod_1.z.string() }),
+                },
+            ],
+        ]),
+        toolRegistry: new Map([
+            [
+                "testTool",
+                {
+                    name: "testTool",
+                    description: "A test tool",
+                    tool: async () => "result",
+                    inputSchema: zod_1.z.object({ query: zod_1.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 (0, use_tambo_v1_send_message_1.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 (0, use_tambo_v1_send_message_1.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 (0, use_tambo_v1_send_message_1.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 (0, use_tambo_v1_send_message_1.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 (0, use_tambo_v1_send_message_1.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 react_query_1.QueryClient({
+            defaultOptions: {
+                queries: { retry: false },
+                mutations: { retry: false },
+            },
+        });
+        jest.mocked(tambo_client_provider_1.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: core_1.EventType.RUN_STARTED,
+                runId: "run_1",
+                threadId: "new_thread_123",
+            },
+            { type: core_1.EventType.RUN_FINISHED },
+        ]);
+        mockThreadsRunsApi.create.mockResolvedValue(mockStream);
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map(),
+        };
+        function TestWrapper({ children }) {
+            return (react_2.default.createElement(react_query_1.QueryClientProvider, { client: queryClient },
+                react_2.default.createElement(tambo_registry_provider_1.TamboRegistryContext.Provider, { value: mockRegistry },
+                    react_2.default.createElement(tambo_v1_stream_context_1.TamboV1StreamProvider, null, children))));
+        }
+        const { result } = (0, react_1.renderHook)(() => (0, use_tambo_v1_send_message_1.useTamboV1SendMessage)(), {
+            wrapper: TestWrapper,
+        });
+        let mutationResult;
+        await (0, react_1.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: core_1.EventType.TEXT_MESSAGE_START, messageId: "msg_1" },
+        ]);
+        mockThreadsRunsApi.create.mockResolvedValue(mockStream);
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map(),
+        };
+        function TestWrapper({ children }) {
+            return (react_2.default.createElement(react_query_1.QueryClientProvider, { client: queryClient },
+                react_2.default.createElement(tambo_registry_provider_1.TamboRegistryContext.Provider, { value: mockRegistry },
+                    react_2.default.createElement(tambo_v1_stream_context_1.TamboV1StreamProvider, null, children))));
+        }
+        const { result } = (0, react_1.renderHook)(() => (0, use_tambo_v1_send_message_1.useTamboV1SendMessage)(), {
+            wrapper: TestWrapper,
+        });
+        await expect((0, react_1.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: zod_1.z.object({ query: zod_1.z.string() }),
+            outputSchema: zod_1.z.string(),
+        };
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map([["test_tool", testTool]]),
+        };
+        const initialStream = createAsyncIterator([
+            {
+                type: core_1.EventType.RUN_STARTED,
+                runId: "run_1",
+                threadId: "thread_123",
+            },
+            {
+                type: core_1.EventType.TEXT_MESSAGE_START,
+                messageId: "msg_1",
+                role: "assistant",
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_START,
+                toolCallId: "call_1",
+                toolCallName: "test_tool",
+                parentMessageId: "msg_1",
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_1",
+                delta: '{"query":"test"}',
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_END,
+                toolCallId: "call_1",
+            },
+            {
+                type: core_1.EventType.CUSTOM,
+                name: "tambo.run.awaiting_input",
+                value: { pendingToolCallIds: ["call_1"] },
+            },
+        ]);
+        const continueStream = createAsyncIterator([
+            {
+                type: core_1.EventType.RUN_STARTED,
+                runId: "run_2",
+                threadId: "thread_123",
+            },
+            { type: core_1.EventType.RUN_FINISHED },
+        ]);
+        mockThreadsRunsApi.run
+            .mockResolvedValueOnce(initialStream)
+            .mockResolvedValueOnce(continueStream);
+        function TestWrapper({ children }) {
+            return (react_2.default.createElement(react_query_1.QueryClientProvider, { client: queryClient },
+                react_2.default.createElement(tambo_registry_provider_1.TamboRegistryContext.Provider, { value: mockRegistry },
+                    react_2.default.createElement(tambo_v1_stream_context_1.TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+        }
+        const { result } = (0, react_1.renderHook)(() => (0, use_tambo_v1_send_message_1.useTamboV1SendMessage)("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await (0, react_1.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: zod_1.z.object({ a: zod_1.z.number(), b: zod_1.z.number() }),
+            outputSchema: zod_1.z.object({ result: zod_1.z.number() }),
+        };
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map([["chunked_tool", testTool]]),
+        };
+        const initialStream = createAsyncIterator([
+            {
+                type: core_1.EventType.RUN_STARTED,
+                runId: "run_1",
+                threadId: "thread_123",
+            },
+            {
+                type: core_1.EventType.TEXT_MESSAGE_START,
+                messageId: "msg_1",
+                role: "assistant",
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_START,
+                toolCallId: "call_1",
+                toolCallName: "chunked_tool",
+                parentMessageId: "msg_1",
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_1",
+                delta: '{"a":',
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_1",
+                delta: "10,",
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_1",
+                delta: '"b":20}',
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_END,
+                toolCallId: "call_1",
+            },
+            {
+                type: core_1.EventType.CUSTOM,
+                name: "tambo.run.awaiting_input",
+                value: { pendingToolCallIds: ["call_1"] },
+            },
+        ]);
+        const continueStream = createAsyncIterator([
+            {
+                type: core_1.EventType.RUN_STARTED,
+                runId: "run_2",
+                threadId: "thread_123",
+            },
+            { type: core_1.EventType.RUN_FINISHED },
+        ]);
+        mockThreadsRunsApi.run
+            .mockResolvedValueOnce(initialStream)
+            .mockResolvedValueOnce(continueStream);
+        function TestWrapper({ children }) {
+            return (react_2.default.createElement(react_query_1.QueryClientProvider, { client: queryClient },
+                react_2.default.createElement(tambo_registry_provider_1.TamboRegistryContext.Provider, { value: mockRegistry },
+                    react_2.default.createElement(tambo_v1_stream_context_1.TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+        }
+        const { result } = (0, react_1.renderHook)(() => (0, use_tambo_v1_send_message_1.useTamboV1SendMessage)("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await (0, react_1.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: zod_1.z.object({}),
+            outputSchema: zod_1.z.string(),
+        };
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map([["test_tool", testTool]]),
+        };
+        const initialStream = createAsyncIterator([
+            {
+                type: core_1.EventType.RUN_STARTED,
+                runId: "run_1",
+                threadId: "thread_123",
+            },
+            {
+                type: core_1.EventType.TEXT_MESSAGE_START,
+                messageId: "msg_1",
+                role: "assistant",
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_START,
+                toolCallId: "call_1",
+                toolCallName: "test_tool",
+                parentMessageId: "msg_1",
+            },
+            // No TOOL_CALL_ARGS events - args will be empty
+            {
+                type: core_1.EventType.TOOL_CALL_END,
+                toolCallId: "call_1",
+            },
+            {
+                type: core_1.EventType.CUSTOM,
+                name: "tambo.run.awaiting_input",
+                value: { pendingToolCallIds: ["call_1"] },
+            },
+        ]);
+        const continueStream = createAsyncIterator([
+            {
+                type: core_1.EventType.RUN_STARTED,
+                runId: "run_2",
+                threadId: "thread_123",
+            },
+            { type: core_1.EventType.RUN_FINISHED },
+        ]);
+        mockThreadsRunsApi.run
+            .mockResolvedValueOnce(initialStream)
+            .mockResolvedValueOnce(continueStream);
+        function TestWrapper({ children }) {
+            return (react_2.default.createElement(react_query_1.QueryClientProvider, { client: queryClient },
+                react_2.default.createElement(tambo_registry_provider_1.TamboRegistryContext.Provider, { value: mockRegistry },
+                    react_2.default.createElement(tambo_v1_stream_context_1.TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+        }
+        const { result } = (0, react_1.renderHook)(() => (0, use_tambo_v1_send_message_1.useTamboV1SendMessage)("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await (0, react_1.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: core_1.EventType.RUN_STARTED,
+                runId: "run_1",
+                threadId: "thread_123",
+            },
+            {
+                type: core_1.EventType.TEXT_MESSAGE_START,
+                messageId: "msg_1",
+                role: "assistant",
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_START,
+                toolCallId: "call_1",
+                toolCallName: "unknown_tool",
+                parentMessageId: "msg_1",
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_1",
+                delta: "{}",
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_END,
+                toolCallId: "call_1",
+            },
+            {
+                type: core_1.EventType.CUSTOM,
+                name: "tambo.run.awaiting_input",
+                value: { pendingToolCallIds: ["call_1"] },
+            },
+        ]);
+        const continueStream = createAsyncIterator([
+            {
+                type: core_1.EventType.RUN_STARTED,
+                runId: "run_2",
+                threadId: "thread_123",
+            },
+            { type: core_1.EventType.RUN_FINISHED },
+        ]);
+        mockThreadsRunsApi.run
+            .mockResolvedValueOnce(initialStream)
+            .mockResolvedValueOnce(continueStream);
+        function TestWrapper({ children }) {
+            return (react_2.default.createElement(react_query_1.QueryClientProvider, { client: queryClient },
+                react_2.default.createElement(tambo_registry_provider_1.TamboRegistryContext.Provider, { value: mockRegistry },
+                    react_2.default.createElement(tambo_v1_stream_context_1.TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+        }
+        const { result } = (0, react_1.renderHook)(() => (0, use_tambo_v1_send_message_1.useTamboV1SendMessage)("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await (0, react_1.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_2.default.createElement(react_query_1.QueryClientProvider, { client: queryClient },
+                react_2.default.createElement(tambo_v1_stream_context_1.TamboV1StreamProvider, { threadId: "thread_123" }, children)));
+        }
+        // Should not throw - default context is used
+        const { result } = (0, react_1.renderHook)(() => (0, use_tambo_v1_send_message_1.useTamboV1SendMessage)("thread_123"), {
+            wrapper: TestWrapperWithoutRegistry,
+        });
+        expect(result.current.mutate).toBeDefined();
+    });
+    it("invalidates queries on successful mutation", async () => {
+        const mockStream = createAsyncIterator([
+            {
+                type: core_1.EventType.RUN_STARTED,
+                runId: "run_1",
+                threadId: "thread_123",
+            },
+            { type: core_1.EventType.RUN_FINISHED },
+        ]);
+        mockThreadsRunsApi.run.mockResolvedValue(mockStream);
+        const mockRegistry = {
+            componentList: new Map(),
+            toolRegistry: new Map(),
+        };
+        function TestWrapper({ children }) {
+            return (react_2.default.createElement(react_query_1.QueryClientProvider, { client: queryClient },
+                react_2.default.createElement(tambo_registry_provider_1.TamboRegistryContext.Provider, { value: mockRegistry },
+                    react_2.default.createElement(tambo_v1_stream_context_1.TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+        }
+        const invalidateQueriesSpy = jest.spyOn(queryClient, "invalidateQueries");
+        const { result } = (0, react_1.renderHook)(() => (0, use_tambo_v1_send_message_1.useTamboV1SendMessage)("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await (0, react_1.act)(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Hello" }],
+                },
+            });
+        });
+        await (0, react_1.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: zod_1.z.object({ input: zod_1.z.string() }),
+            outputSchema: zod_1.z.string(),
+        };
+        const tool2 = {
+            name: "tool_2",
+            description: "Second tool",
+            tool: tool2Executed,
+            inputSchema: zod_1.z.object({ input: zod_1.z.string() }),
+            outputSchema: zod_1.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: core_1.EventType.RUN_STARTED,
+                runId: "run_1",
+                threadId: "thread_123",
+            },
+            {
+                type: core_1.EventType.TEXT_MESSAGE_START,
+                messageId: "msg_1",
+                role: "assistant",
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_START,
+                toolCallId: "call_1",
+                toolCallName: "tool_1",
+                parentMessageId: "msg_1",
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_1",
+                delta: '{"input":"first"}',
+            },
+            { type: core_1.EventType.TOOL_CALL_END, toolCallId: "call_1" },
+            {
+                type: core_1.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: core_1.EventType.RUN_STARTED,
+                runId: "run_2",
+                threadId: "thread_123",
+            },
+            {
+                type: core_1.EventType.TEXT_MESSAGE_START,
+                messageId: "msg_2",
+                role: "assistant",
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_START,
+                toolCallId: "call_2",
+                toolCallName: "tool_2",
+                parentMessageId: "msg_2",
+            },
+            {
+                type: core_1.EventType.TOOL_CALL_ARGS,
+                toolCallId: "call_2",
+                delta: '{"input":"second"}',
+            },
+            { type: core_1.EventType.TOOL_CALL_END, toolCallId: "call_2" },
+            {
+                type: core_1.EventType.CUSTOM,
+                name: "tambo.run.awaiting_input",
+                value: { pendingToolCallIds: ["call_2"] },
+            },
+        ]);
+        // Third stream: AI receives tool_2 result, finishes
+        const thirdStream = createAsyncIterator([
+            {
+                type: core_1.EventType.RUN_STARTED,
+                runId: "run_3",
+                threadId: "thread_123",
+            },
+            { type: core_1.EventType.RUN_FINISHED },
+        ]);
+        mockThreadsRunsApi.run
+            .mockResolvedValueOnce(initialStream)
+            .mockResolvedValueOnce(secondStream)
+            .mockResolvedValueOnce(thirdStream);
+        function TestWrapper({ children }) {
+            return (react_2.default.createElement(react_query_1.QueryClientProvider, { client: queryClient },
+                react_2.default.createElement(tambo_registry_provider_1.TamboRegistryContext.Provider, { value: mockRegistry },
+                    react_2.default.createElement(tambo_v1_stream_context_1.TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+        }
+        const { result } = (0, react_1.renderHook)(() => (0, use_tambo_v1_send_message_1.useTamboV1SendMessage)("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await (0, react_1.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_2.default.createElement(react_query_1.QueryClientProvider, { client: queryClient },
+                react_2.default.createElement(tambo_registry_provider_1.TamboRegistryContext.Provider, { value: mockRegistry },
+                    react_2.default.createElement(tambo_v1_stream_context_1.TamboV1StreamProvider, { threadId: "thread_123" }, children))));
+        }
+        const { result } = (0, react_1.renderHook)(() => (0, use_tambo_v1_send_message_1.useTamboV1SendMessage)("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        try {
+            await (0, react_1.act)(async () => {
+                await result.current.mutateAsync({
+                    message: {
+                        role: "user",
+                        content: [{ type: "text", text: "Hello" }],
+                    },
+                });
+            });
+        }
+        catch {
+            // Expected to throw
+        }
+        await (0, react_1.waitFor)(() => {
+            expect(consoleSpy).toHaveBeenCalledWith("[useTamboV1SendMessage] Mutation failed:", testError);
+        });
+        consoleSpy.mockRestore();
+    });
+});
+//# sourceMappingURL=use-tambo-v1-send-message.test.js.map