@tambo-ai/react 0.73.0 → 0.74.0

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

@@ -3,17 +3,23 @@ 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 { useTamboV1Config } from "../providers/tambo-v1-provider";
-import { TamboV1StreamProvider } from "../providers/tambo-v1-stream-context";
-import { createRunStream, useTamboV1SendMessage, } from "./use-tambo-v1-send-message";
+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";
 jest.mock("../../providers/tambo-client-provider", () => ({
     useTamboClient: jest.fn(),
+    useTamboQueryClient: jest.fn(),
 }));
 jest.mock("../providers/tambo-v1-provider", () => ({
     useTamboV1Config: jest.fn(),
 }));
+jest.mock("../../providers/tambo-context-helpers-provider", () => ({
+    useTamboContextHelpers: () => ({
+        getAdditionalContext: jest.fn().mockResolvedValue([]),
+    }),
+}));
 describe("useTamboV1SendMessage", () => {
     const mockThreadsRunsApi = {
         run: jest.fn(),
@@ -43,6 +49,7 @@ describe("useTamboV1SendMessage", () => {
             },
         });
         jest.mocked(useTamboClient).mockReturnValue(mockTamboAI);
+        jest.mocked(useTamboQueryClient).mockReturnValue(queryClient);
         jest.mocked(useTamboV1Config).mockReturnValue({ userKey: undefined });
         mockThreadsRunsApi.run.mockReset();
         mockThreadsRunsApi.create.mockReset();
@@ -86,7 +93,13 @@ describe("createRunStream", () => {
                     name: "TestComponent",
                     description: "A test component",
                     component: () => null,
-                    propsSchema: z.object({ title: z.string() }),
+                    // RegisteredComponent has props as JSON Schema (already converted from propsSchema)
+                    props: {
+                        type: "object",
+                        properties: { title: { type: "string" } },
+                        required: ["title"],
+                    },
+                    contextTools: [],
                 },
             ],
         ]),
@@ -118,17 +131,39 @@ describe("createRunStream", () => {
             message: testMessage,
             registry: mockRegistry,
             userKey: undefined,
+            previousRunId: undefined,
         });
         expect(mockThreadsRunsApi.run).toHaveBeenCalledWith("thread_123", {
             message: testMessage,
             availableComponents: expect.any(Array),
             tools: expect.any(Array),
             userKey: undefined,
+            previousRunId: undefined,
         });
         expect(mockThreadsRunsApi.create).not.toHaveBeenCalled();
         expect(result.stream).toBe(mockStream);
         expect(result.initialThreadId).toBe("thread_123");
     });
+    it("calls client.threads.runs.run with previousRunId when provided", async () => {
+        mockThreadsRunsApi.run.mockResolvedValue(mockStream);
+        const result = await createRunStream({
+            client: mockClient,
+            threadId: "thread_123",
+            message: testMessage,
+            registry: mockRegistry,
+            userKey: undefined,
+            previousRunId: "run_456",
+        });
+        expect(mockThreadsRunsApi.run).toHaveBeenCalledWith("thread_123", {
+            message: testMessage,
+            availableComponents: expect.any(Array),
+            tools: expect.any(Array),
+            userKey: undefined,
+            previousRunId: "run_456",
+        });
+        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({
@@ -137,6 +172,7 @@ describe("createRunStream", () => {
             message: testMessage,
             registry: mockRegistry,
             userKey: undefined,
+            previousRunId: undefined,
         });
         expect(mockThreadsRunsApi.create).toHaveBeenCalledWith({
             message: testMessage,
@@ -156,6 +192,7 @@ describe("createRunStream", () => {
             message: testMessage,
             registry: mockRegistry,
             userKey: undefined,
+            previousRunId: undefined,
         });
         const callArgs = mockThreadsRunsApi.run.mock.calls[0][1];
         expect(callArgs.availableComponents).toEqual([
@@ -174,6 +211,7 @@ describe("createRunStream", () => {
             message: testMessage,
             registry: mockRegistry,
             userKey: undefined,
+            previousRunId: undefined,
         });
         const callArgs = mockThreadsRunsApi.run.mock.calls[0][1];
         expect(callArgs.tools).toEqual([
@@ -195,6 +233,7 @@ describe("createRunStream", () => {
             message: testMessage,
             registry: emptyRegistry,
             userKey: undefined,
+            previousRunId: undefined,
         });
         const callArgs = mockThreadsRunsApi.run.mock.calls[0][1];
         expect(callArgs.availableComponents).toEqual([]);
@@ -230,6 +269,7 @@ describe("useTamboV1SendMessage mutation", () => {
             },
         });
         jest.mocked(useTamboClient).mockReturnValue(mockTamboAI);
+        jest.mocked(useTamboQueryClient).mockReturnValue(queryClient);
         jest.mocked(useTamboV1Config).mockReturnValue({ userKey: undefined });
         mockThreadsRunsApi.run.mockReset();
         mockThreadsRunsApi.create.mockReset();
@@ -335,7 +375,11 @@ describe("useTamboV1SendMessage mutation", () => {
             {
                 type: EventType.CUSTOM,
                 name: "tambo.run.awaiting_input",
-                value: { pendingToolCallIds: ["call_1"] },
+                value: {
+                    pendingToolCalls: [
+                        { toolCallId: "call_1", toolName: "test", arguments: "{}" },
+                    ],
+                },
             },
         ]);
         const continueStream = createAsyncIterator([
@@ -429,7 +473,11 @@ describe("useTamboV1SendMessage mutation", () => {
             {
                 type: EventType.CUSTOM,
                 name: "tambo.run.awaiting_input",
-                value: { pendingToolCallIds: ["call_1"] },
+                value: {
+                    pendingToolCalls: [
+                        { toolCallId: "call_1", toolName: "test", arguments: "{}" },
+                    ],
+                },
             },
         ]);
         const continueStream = createAsyncIterator([
@@ -501,7 +549,11 @@ describe("useTamboV1SendMessage mutation", () => {
             {
                 type: EventType.CUSTOM,
                 name: "tambo.run.awaiting_input",
-                value: { pendingToolCallIds: ["call_1"] },
+                value: {
+                    pendingToolCalls: [
+                        { toolCallId: "call_1", toolName: "test", arguments: "{}" },
+                    ],
+                },
             },
         ]);
         const continueStream = createAsyncIterator([
@@ -568,7 +620,11 @@ describe("useTamboV1SendMessage mutation", () => {
             {
                 type: EventType.CUSTOM,
                 name: "tambo.run.awaiting_input",
-                value: { pendingToolCallIds: ["call_1"] },
+                value: {
+                    pendingToolCalls: [
+                        { toolCallId: "call_1", toolName: "test", arguments: "{}" },
+                    ],
+                },
             },
         ]);
         const continueStream = createAsyncIterator([
@@ -605,6 +661,7 @@ describe("useTamboV1SendMessage mutation", () => {
         expect(continueCall[1].message.content[0]).toEqual({
             type: "tool_result",
             toolUseId: "call_1",
+            isError: true,
             content: [
                 { type: "text", text: 'Tool "unknown_tool" not found in registry' },
             ],
@@ -711,7 +768,11 @@ describe("useTamboV1SendMessage mutation", () => {
             {
                 type: EventType.CUSTOM,
                 name: "tambo.run.awaiting_input",
-                value: { pendingToolCallIds: ["call_1"] },
+                value: {
+                    pendingToolCalls: [
+                        { toolCallId: "call_1", toolName: "test", arguments: "{}" },
+                    ],
+                },
             },
         ]);
         // Second stream: AI receives tool_1 result, then calls tool_2
@@ -741,7 +802,11 @@ describe("useTamboV1SendMessage mutation", () => {
             {
                 type: EventType.CUSTOM,
                 name: "tambo.run.awaiting_input",
-                value: { pendingToolCallIds: ["call_2"] },
+                value: {
+                    pendingToolCalls: [
+                        { toolCallId: "call_2", toolName: "test", arguments: "{}" },
+                    ],
+                },
             },
         ]);
         // Third stream: AI receives tool_2 result, finishes
@@ -832,4 +897,193 @@ describe("useTamboV1SendMessage mutation", () => {
         consoleSpy.mockRestore();
     });
 });
+describe("useTamboV1SendMessage auto thread name generation", () => {
+    const mockGenerateName = jest.fn();
+    const mockThreadsRunsApi = {
+        run: jest.fn(),
+        create: jest.fn(),
+    };
+    const mockTamboAI = {
+        apiKey: "",
+        threads: {
+            runs: mockThreadsRunsApi,
+        },
+        beta: {
+            threads: {
+                generateName: mockGenerateName,
+            },
+        },
+    };
+    let queryClient;
+    function createAsyncIterator(events) {
+        return {
+            [Symbol.asyncIterator]: async function* () {
+                for (const event of events) {
+                    yield event;
+                }
+            },
+        };
+    }
+    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))));
+    }
+    function createFinishedStream(threadId) {
+        return createAsyncIterator([
+            {
+                type: EventType.RUN_STARTED,
+                runId: "run_1",
+                threadId,
+            },
+            {
+                type: EventType.TEXT_MESSAGE_START,
+                messageId: "msg_assistant_1",
+                role: "assistant",
+            },
+            {
+                type: EventType.TEXT_MESSAGE_CONTENT,
+                messageId: "msg_assistant_1",
+                delta: "Hello!",
+            },
+            {
+                type: EventType.TEXT_MESSAGE_END,
+                messageId: "msg_assistant_1",
+            },
+            { type: EventType.RUN_FINISHED },
+        ]);
+    }
+    beforeEach(() => {
+        queryClient = new QueryClient({
+            defaultOptions: {
+                queries: { retry: false },
+                mutations: { retry: false },
+            },
+        });
+        jest.mocked(useTamboClient).mockReturnValue(mockTamboAI);
+        jest.mocked(useTamboQueryClient).mockReturnValue(queryClient);
+        mockThreadsRunsApi.run.mockReset();
+        mockThreadsRunsApi.create.mockReset();
+        mockGenerateName.mockReset();
+    });
+    it("calls generateName when message count reaches threshold", async () => {
+        // Threshold=2. Pre-mutation=0, 0 + 2 = 2 >= 2 → fire
+        jest.mocked(useTamboV1Config).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"), {
+            wrapper: TestWrapper,
+        });
+        await act(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Hello" }],
+                },
+            });
+        });
+        await waitFor(() => {
+            expect(mockGenerateName).toHaveBeenCalledWith("thread_123");
+        });
+    });
+    it("does not call generateName when autoGenerateThreadName is false", async () => {
+        jest.mocked(useTamboV1Config).mockReturnValue({
+            userKey: undefined,
+            autoGenerateThreadName: false,
+            autoGenerateNameThreshold: 3,
+        });
+        mockThreadsRunsApi.run.mockResolvedValue(createFinishedStream("thread_123"));
+        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await act(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Hello" }],
+                },
+            });
+        });
+        // mutateAsync resolves after onSuccess, so all async work has settled
+        expect(mockGenerateName).not.toHaveBeenCalled();
+    });
+    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({
+            userKey: undefined,
+            autoGenerateThreadName: true,
+            autoGenerateNameThreshold: 3,
+        });
+        mockThreadsRunsApi.create.mockResolvedValue(createFinishedStream("new_thread"));
+        const { result } = renderHook(() => useTamboV1SendMessage(), {
+            wrapper: TestWrapper,
+        });
+        await act(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Hello" }],
+                },
+            });
+        });
+        expect(mockGenerateName).not.toHaveBeenCalled();
+    });
+    it("logs error when generateName fails (does not throw)", async () => {
+        // Threshold=2. Pre-mutation=0, 0 + 2 = 2 >= 2 → fire
+        jest.mocked(useTamboV1Config).mockReturnValue({
+            userKey: undefined,
+            autoGenerateThreadName: true,
+            autoGenerateNameThreshold: 2,
+        });
+        const consoleSpy = jest
+            .spyOn(console, "error")
+            .mockImplementation(() => { });
+        mockGenerateName.mockRejectedValue(new Error("API error"));
+        mockThreadsRunsApi.run.mockResolvedValue(createFinishedStream("thread_123"));
+        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(consoleSpy).toHaveBeenCalledWith("[useTamboV1SendMessage] 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({
+            userKey: undefined,
+        });
+        mockGenerateName.mockResolvedValue({ name: "Auto Name" });
+        mockThreadsRunsApi.run.mockResolvedValue(createFinishedStream("thread_123"));
+        const { result } = renderHook(() => useTamboV1SendMessage("thread_123"), {
+            wrapper: TestWrapper,
+        });
+        await act(async () => {
+            await result.current.mutateAsync({
+                message: {
+                    role: "user",
+                    content: [{ type: "text", text: "Hello" }],
+                },
+            });
+        });
+        // Default threshold=3, preMutation=0 messages, 0 + 2 = 2 < 3 → should NOT fire
+        expect(mockGenerateName).not.toHaveBeenCalled();
+    });
+});
 //# sourceMappingURL=use-tambo-v1-send-message.test.js.map