@tambo-ai/react 0.73.0 → 0.74.0

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

@@ -15,10 +15,16 @@ 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(),
+    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(),
@@ -48,6 +54,7 @@ describe("useTamboV1SendMessage", () => {
             },
         });
         jest.mocked(tambo_client_provider_1.useTamboClient).mockReturnValue(mockTamboAI);
+        jest.mocked(tambo_client_provider_1.useTamboQueryClient).mockReturnValue(queryClient);
         jest.mocked(tambo_v1_provider_1.useTamboV1Config).mockReturnValue({ userKey: undefined });
         mockThreadsRunsApi.run.mockReset();
         mockThreadsRunsApi.create.mockReset();
@@ -91,7 +98,13 @@ describe("createRunStream", () => {
                     name: "TestComponent",
                     description: "A test component",
                     component: () => null,
-                    propsSchema: zod_1.z.object({ title: zod_1.z.string() }),
+                    // RegisteredComponent has props as JSON Schema (already converted from propsSchema)
+                    props: {
+                        type: "object",
+                        properties: { title: { type: "string" } },
+                        required: ["title"],
+                    },
+                    contextTools: [],
                 },
             ],
         ]),
@@ -123,17 +136,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 (0, use_tambo_v1_send_message_1.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 (0, use_tambo_v1_send_message_1.createRunStream)({
@@ -142,6 +177,7 @@ describe("createRunStream", () => {
             message: testMessage,
             registry: mockRegistry,
             userKey: undefined,
+            previousRunId: undefined,
         });
         expect(mockThreadsRunsApi.create).toHaveBeenCalledWith({
             message: testMessage,
@@ -161,6 +197,7 @@ describe("createRunStream", () => {
             message: testMessage,
             registry: mockRegistry,
             userKey: undefined,
+            previousRunId: undefined,
         });
         const callArgs = mockThreadsRunsApi.run.mock.calls[0][1];
         expect(callArgs.availableComponents).toEqual([
@@ -179,6 +216,7 @@ describe("createRunStream", () => {
             message: testMessage,
             registry: mockRegistry,
             userKey: undefined,
+            previousRunId: undefined,
         });
         const callArgs = mockThreadsRunsApi.run.mock.calls[0][1];
         expect(callArgs.tools).toEqual([
@@ -200,6 +238,7 @@ describe("createRunStream", () => {
             message: testMessage,
             registry: emptyRegistry,
             userKey: undefined,
+            previousRunId: undefined,
         });
         const callArgs = mockThreadsRunsApi.run.mock.calls[0][1];
         expect(callArgs.availableComponents).toEqual([]);
@@ -235,6 +274,7 @@ describe("useTamboV1SendMessage mutation", () => {
             },
         });
         jest.mocked(tambo_client_provider_1.useTamboClient).mockReturnValue(mockTamboAI);
+        jest.mocked(tambo_client_provider_1.useTamboQueryClient).mockReturnValue(queryClient);
         jest.mocked(tambo_v1_provider_1.useTamboV1Config).mockReturnValue({ userKey: undefined });
         mockThreadsRunsApi.run.mockReset();
         mockThreadsRunsApi.create.mockReset();
@@ -340,7 +380,11 @@ describe("useTamboV1SendMessage mutation", () => {
             {
                 type: core_1.EventType.CUSTOM,
                 name: "tambo.run.awaiting_input",
-                value: { pendingToolCallIds: ["call_1"] },
+                value: {
+                    pendingToolCalls: [
+                        { toolCallId: "call_1", toolName: "test", arguments: "{}" },
+                    ],
+                },
             },
         ]);
         const continueStream = createAsyncIterator([
@@ -434,7 +478,11 @@ describe("useTamboV1SendMessage mutation", () => {
             {
                 type: core_1.EventType.CUSTOM,
                 name: "tambo.run.awaiting_input",
-                value: { pendingToolCallIds: ["call_1"] },
+                value: {
+                    pendingToolCalls: [
+                        { toolCallId: "call_1", toolName: "test", arguments: "{}" },
+                    ],
+                },
             },
         ]);
         const continueStream = createAsyncIterator([
@@ -506,7 +554,11 @@ describe("useTamboV1SendMessage mutation", () => {
             {
                 type: core_1.EventType.CUSTOM,
                 name: "tambo.run.awaiting_input",
-                value: { pendingToolCallIds: ["call_1"] },
+                value: {
+                    pendingToolCalls: [
+                        { toolCallId: "call_1", toolName: "test", arguments: "{}" },
+                    ],
+                },
             },
         ]);
         const continueStream = createAsyncIterator([
@@ -573,7 +625,11 @@ describe("useTamboV1SendMessage mutation", () => {
             {
                 type: core_1.EventType.CUSTOM,
                 name: "tambo.run.awaiting_input",
-                value: { pendingToolCallIds: ["call_1"] },
+                value: {
+                    pendingToolCalls: [
+                        { toolCallId: "call_1", toolName: "test", arguments: "{}" },
+                    ],
+                },
             },
         ]);
         const continueStream = createAsyncIterator([
@@ -610,6 +666,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' },
             ],
@@ -716,7 +773,11 @@ describe("useTamboV1SendMessage mutation", () => {
             {
                 type: core_1.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
@@ -746,7 +807,11 @@ describe("useTamboV1SendMessage mutation", () => {
             {
                 type: core_1.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
@@ -837,4 +902,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_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))));
+    }
+    function createFinishedStream(threadId) {
+        return createAsyncIterator([
+            {
+                type: core_1.EventType.RUN_STARTED,
+                runId: "run_1",
+                threadId,
+            },
+            {
+                type: core_1.EventType.TEXT_MESSAGE_START,
+                messageId: "msg_assistant_1",
+                role: "assistant",
+            },
+            {
+                type: core_1.EventType.TEXT_MESSAGE_CONTENT,
+                messageId: "msg_assistant_1",
+                delta: "Hello!",
+            },
+            {
+                type: core_1.EventType.TEXT_MESSAGE_END,
+                messageId: "msg_assistant_1",
+            },
+            { type: core_1.EventType.RUN_FINISHED },
+        ]);
+    }
+    beforeEach(() => {
+        queryClient = new react_query_1.QueryClient({
+            defaultOptions: {
+                queries: { retry: false },
+                mutations: { retry: false },
+            },
+        });
+        jest.mocked(tambo_client_provider_1.useTamboClient).mockReturnValue(mockTamboAI);
+        jest.mocked(tambo_client_provider_1.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(tambo_v1_provider_1.useTamboV1Config).mockReturnValue({
+            userKey: undefined,
+            autoGenerateThreadName: true,
+            autoGenerateNameThreshold: 2,
+        });
+        mockGenerateName.mockResolvedValue({ name: "Generated Thread Name" });
+        mockThreadsRunsApi.run.mockResolvedValue(createFinishedStream("thread_123"));
+        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(mockGenerateName).toHaveBeenCalledWith("thread_123");
+        });
+    });
+    it("does not call generateName when autoGenerateThreadName is false", async () => {
+        jest.mocked(tambo_v1_provider_1.useTamboV1Config).mockReturnValue({
+            userKey: undefined,
+            autoGenerateThreadName: false,
+            autoGenerateNameThreshold: 3,
+        });
+        mockThreadsRunsApi.run.mockResolvedValue(createFinishedStream("thread_123"));
+        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" }],
+                },
+            });
+        });
+        // 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(tambo_v1_provider_1.useTamboV1Config).mockReturnValue({
+            userKey: undefined,
+            autoGenerateThreadName: true,
+            autoGenerateNameThreshold: 3,
+        });
+        mockThreadsRunsApi.create.mockResolvedValue(createFinishedStream("new_thread"));
+        const { result } = (0, react_1.renderHook)(() => (0, use_tambo_v1_send_message_1.useTamboV1SendMessage)(), {
+            wrapper: TestWrapper,
+        });
+        await (0, react_1.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(tambo_v1_provider_1.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 } = (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(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(tambo_v1_provider_1.useTamboV1Config).mockReturnValue({
+            userKey: undefined,
+        });
+        mockGenerateName.mockResolvedValue({ name: "Auto Name" });
+        mockThreadsRunsApi.run.mockResolvedValue(createFinishedStream("thread_123"));
+        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" }],
+                },
+            });
+        });
+        // 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