@tambo-ai/react 0.73.0 → 0.74.0

package/esm/v1/hooks/use-tambo-v1-suggestions.test.js

@@ -1,11 +1,12 @@
 import { renderHook, act, waitFor } from "@testing-library/react";
 import React from "react";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { useTamboV1Suggestions } from "./use-tambo-v1-suggestions";
-import { useTamboV1ThreadInput } from "./use-tambo-v1-thread-input";
-import { useTamboV1 } from "./use-tambo-v1";
-import { useTamboClient } from "../../providers/tambo-client-provider";
-import { useTamboRegistry } from "../../providers/tambo-registry-provider";
+import { useTamboV1Suggestions } from "./use-tambo-v1-suggestions.js";
+import { useTamboV1ThreadInput } from "./use-tambo-v1-thread-input.js";
+import { useTamboV1 } from "./use-tambo-v1.js";
+import { useTamboClient, useTamboQueryClient, } from "../../providers/tambo-client-provider.js";
+import { useTamboRegistry } from "../../providers/tambo-registry-provider.js";
+import { useTamboV1Config } from "../providers/tambo-v1-provider.js";
 // Mock dependencies
 jest.mock("./use-tambo-v1-thread-input", () => ({
     useTamboV1ThreadInput: jest.fn(),
@@ -20,11 +21,34 @@ jest.mock("../../providers/tambo-client-provider", () => ({
 jest.mock("../../providers/tambo-registry-provider", () => ({
     useTamboRegistry: jest.fn(),
 }));
+jest.mock("../providers/tambo-v1-provider", () => ({
+    useTamboV1Config: jest.fn(),
+}));
 describe("useTamboV1Suggestions", () => {
     let queryClient;
     const mockSetValue = jest.fn();
     const mockSubmit = jest.fn();
-    const mockGenerateSuggestions = jest.fn();
+    const mockListSuggestions = jest.fn();
+    const mockCreateSuggestions = jest.fn();
+    const mockSuggestions = [
+        {
+            id: "suggestion_1",
+            messageId: "msg_1",
+            title: "What's the weather?",
+            detailedSuggestion: "What's the weather like today?",
+        },
+        {
+            id: "suggestion_2",
+            messageId: "msg_1",
+            title: "Tell me a joke",
+            detailedSuggestion: "Can you tell me a funny joke?",
+        },
+    ];
+    const mockSuggestionsResponse = {
+        suggestions: mockSuggestions,
+        hasMore: false,
+        nextCursor: undefined,
+    };
     function createWrapper() {
         return function Wrapper({ children }) {
             return (React.createElement(QueryClientProvider, { client: queryClient }, children));
@@ -38,21 +62,20 @@ describe("useTamboV1Suggestions", () => {
                 mutations: { retry: false },
             },
         });
+        // Mock useTamboQueryClient to return the test's queryClient
+        jest.mocked(useTamboQueryClient).mockReturnValue(queryClient);
+        // Default mock for v1 config
+        jest.mocked(useTamboV1Config).mockReturnValue({ userKey: "user_123" });
         // Default mock for thread input
         jest.mocked(useTamboV1ThreadInput).mockReturnValue({
             value: "",
             setValue: mockSetValue,
             submit: mockSubmit,
-            threadId: "thread_123",
-            setThreadId: jest.fn(),
-            images: [],
-            addImage: jest.fn(),
-            addImages: jest.fn(),
-            removeImage: jest.fn(),
-            clearImages: jest.fn(),
             isPending: false,
             isError: false,
-            error: undefined,
+            error: null,
+            isSuccess: false,
+            reset: jest.fn(),
         });
         // Default mock for useTamboV1
         jest.mocked(useTamboV1).mockReturnValue({
@@ -60,6 +83,7 @@ describe("useTamboV1Suggestions", () => {
             thread: undefined,
             isIdle: true,
             isStreaming: false,
+            currentThreadId: "thread_123",
             startNewThread: jest.fn(),
             switchThread: jest.fn(),
             initThread: jest.fn(),
@@ -86,30 +110,39 @@ describe("useTamboV1Suggestions", () => {
             unregisterResource: jest.fn(),
             setResourceSource: jest.fn(),
         });
-        // Default mock for client
-        mockGenerateSuggestions.mockResolvedValue([
-            {
-                id: "suggestion_1",
-                suggestion: "What's the weather?",
-                detailedSuggestion: "What's the weather like today?",
-            },
-            {
-                id: "suggestion_2",
-                suggestion: "Tell me a joke",
-                detailedSuggestion: "Can you tell me a funny joke?",
-            },
-        ]);
+        // Default mock for client - using v1 API structure
+        mockListSuggestions.mockResolvedValue({ suggestions: [], hasMore: false });
+        mockCreateSuggestions.mockResolvedValue(mockSuggestionsResponse);
         jest.mocked(useTamboClient).mockReturnValue({
-            beta: {
-                threads: {
-                    suggestions: {
-                        generate: mockGenerateSuggestions,
-                    },
+            threads: {
+                suggestions: {
+                    list: mockListSuggestions,
+                    create: mockCreateSuggestions,
                 },
             },
         });
     });
     describe("Initial State", () => {
+        it("returns empty suggestions when thread has placeholder ID", () => {
+            // Mock useTamboV1 to return placeholder thread ID
+            jest.mocked(useTamboV1).mockReturnValue({
+                messages: [],
+                thread: undefined,
+                isIdle: true,
+                isStreaming: false,
+                currentThreadId: "placeholder",
+                startNewThread: jest.fn(),
+                switchThread: jest.fn(),
+                initThread: jest.fn(),
+                streamingState: { status: "idle" },
+            });
+            const { result } = renderHook(() => useTamboV1Suggestions(), {
+                wrapper: createWrapper(),
+            });
+            expect(result.current.suggestions).toEqual([]);
+            expect(result.current.selectedSuggestionId).toBeNull();
+            expect(result.current.isLoading).toBe(false);
+        });
         it("returns empty suggestions when no messages", () => {
             const { result } = renderHook(() => useTamboV1Suggestions(), {
                 wrapper: createWrapper(),
@@ -130,12 +163,11 @@ describe("useTamboV1Suggestions", () => {
                 thread: undefined,
                 isIdle: true,
                 isStreaming: false,
+                currentThreadId: "thread_123",
                 startNewThread: jest.fn(),
                 switchThread: jest.fn(),
                 initThread: jest.fn(),
-                streamingState: {
-                    status: "idle",
-                },
+                streamingState: { status: "idle" },
             });
             const { result } = renderHook(() => useTamboV1Suggestions(), {
                 wrapper: createWrapper(),
@@ -157,12 +189,11 @@ describe("useTamboV1Suggestions", () => {
                 thread: undefined,
                 isIdle: true,
                 isStreaming: false,
+                currentThreadId: "thread_123",
                 startNewThread: jest.fn(),
                 switchThread: jest.fn(),
                 initThread: jest.fn(),
-                streamingState: {
-                    status: "idle",
-                },
+                streamingState: { status: "idle" },
             });
             const { result } = renderHook(() => useTamboV1Suggestions(), {
                 wrapper: createWrapper(),
@@ -170,11 +201,46 @@ describe("useTamboV1Suggestions", () => {
             await waitFor(() => {
                 expect(result.current.suggestions).toHaveLength(2);
             });
-            expect(mockGenerateSuggestions).toHaveBeenCalledWith("msg_1", expect.objectContaining({
-                id: "thread_123",
+            // Should first call list, then create since list returns empty
+            expect(mockListSuggestions).toHaveBeenCalledWith("msg_1", {
+                threadId: "thread_123",
+                userKey: "user_123",
+            });
+            expect(mockCreateSuggestions).toHaveBeenCalledWith("msg_1", expect.objectContaining({
+                threadId: "thread_123",
                 maxSuggestions: 3,
+                userKey: "user_123",
             }));
         });
+        it("returns existing suggestions from list without calling create", async () => {
+            mockListSuggestions.mockResolvedValue(mockSuggestionsResponse);
+            jest.mocked(useTamboV1).mockReturnValue({
+                messages: [
+                    {
+                        id: "msg_1",
+                        role: "assistant",
+                        content: [],
+                        createdAt: "2024-01-01T00:00:00Z",
+                    },
+                ],
+                thread: undefined,
+                isIdle: true,
+                isStreaming: false,
+                currentThreadId: "thread_123",
+                startNewThread: jest.fn(),
+                switchThread: jest.fn(),
+                initThread: jest.fn(),
+                streamingState: { status: "idle" },
+            });
+            const { result } = renderHook(() => useTamboV1Suggestions(), {
+                wrapper: createWrapper(),
+            });
+            await waitFor(() => {
+                expect(result.current.suggestions).toHaveLength(2);
+            });
+            expect(mockListSuggestions).toHaveBeenCalled();
+            expect(mockCreateSuggestions).not.toHaveBeenCalled();
+        });
         it("does not generate suggestions when thread is streaming", () => {
             jest.mocked(useTamboV1).mockReturnValue({
                 messages: [
@@ -188,35 +254,19 @@ describe("useTamboV1Suggestions", () => {
                 thread: undefined,
                 isIdle: false,
                 isStreaming: true,
+                currentThreadId: "thread_123",
                 startNewThread: jest.fn(),
                 switchThread: jest.fn(),
                 initThread: jest.fn(),
-                streamingState: {
-                    status: "streaming",
-                    runId: "run_1",
-                },
+                streamingState: { status: "streaming", runId: "run_1" },
             });
             renderHook(() => useTamboV1Suggestions(), {
                 wrapper: createWrapper(),
             });
-            expect(mockGenerateSuggestions).not.toHaveBeenCalled();
+            expect(mockListSuggestions).not.toHaveBeenCalled();
+            expect(mockCreateSuggestions).not.toHaveBeenCalled();
         });
-        it("does not generate suggestions when no threadId", () => {
-            jest.mocked(useTamboV1ThreadInput).mockReturnValue({
-                value: "",
-                setValue: mockSetValue,
-                submit: mockSubmit,
-                threadId: undefined,
-                setThreadId: jest.fn(),
-                images: [],
-                addImage: jest.fn(),
-                addImages: jest.fn(),
-                removeImage: jest.fn(),
-                clearImages: jest.fn(),
-                isPending: false,
-                isError: false,
-                error: undefined,
-            });
+        it("does not generate suggestions when autoGenerate is false", () => {
             jest.mocked(useTamboV1).mockReturnValue({
                 messages: [
                     {
@@ -229,17 +279,17 @@ describe("useTamboV1Suggestions", () => {
                 thread: undefined,
                 isIdle: true,
                 isStreaming: false,
+                currentThreadId: "thread_123",
                 startNewThread: jest.fn(),
                 switchThread: jest.fn(),
                 initThread: jest.fn(),
-                streamingState: {
-                    status: "idle",
-                },
+                streamingState: { status: "idle" },
             });
-            renderHook(() => useTamboV1Suggestions(), {
+            renderHook(() => useTamboV1Suggestions({ autoGenerate: false }), {
                 wrapper: createWrapper(),
             });
-            expect(mockGenerateSuggestions).not.toHaveBeenCalled();
+            expect(mockListSuggestions).not.toHaveBeenCalled();
+            expect(mockCreateSuggestions).not.toHaveBeenCalled();
         });
         it("uses custom maxSuggestions option", async () => {
             jest.mocked(useTamboV1).mockReturnValue({
@@ -254,24 +304,21 @@ describe("useTamboV1Suggestions", () => {
                 thread: undefined,
                 isIdle: true,
                 isStreaming: false,
+                currentThreadId: "thread_123",
                 startNewThread: jest.fn(),
                 switchThread: jest.fn(),
                 initThread: jest.fn(),
-                streamingState: {
-                    status: "idle",
-                },
+                streamingState: { status: "idle" },
             });
             const { result } = renderHook(() => useTamboV1Suggestions({ maxSuggestions: 5 }), { wrapper: createWrapper() });
             await waitFor(() => {
                 expect(result.current.suggestions).toHaveLength(2);
             });
-            expect(mockGenerateSuggestions).toHaveBeenCalledWith("msg_1", expect.objectContaining({
-                maxSuggestions: 5,
-            }));
+            expect(mockCreateSuggestions).toHaveBeenCalledWith("msg_1", expect.objectContaining({ maxSuggestions: 5 }));
         });
     });
     describe("Accepting Suggestions", () => {
-        it("updates shared input value when accepting without submit", async () => {
+        it("updates input value when accepting without submit", async () => {
             jest.mocked(useTamboV1).mockReturnValue({
                 messages: [
                     {
@@ -284,12 +331,11 @@ describe("useTamboV1Suggestions", () => {
                 thread: undefined,
                 isIdle: true,
                 isStreaming: false,
+                currentThreadId: "thread_123",
                 startNewThread: jest.fn(),
                 switchThread: jest.fn(),
                 initThread: jest.fn(),
-                streamingState: {
-                    status: "idle",
-                },
+                streamingState: { status: "idle" },
             });
             const { result } = renderHook(() => useTamboV1Suggestions(), {
                 wrapper: createWrapper(),
@@ -319,12 +365,11 @@ describe("useTamboV1Suggestions", () => {
                 thread: undefined,
                 isIdle: true,
                 isStreaming: false,
+                currentThreadId: "thread_123",
                 startNewThread: jest.fn(),
                 switchThread: jest.fn(),
                 initThread: jest.fn(),
-                streamingState: {
-                    status: "idle",
-                },
+                streamingState: { status: "idle" },
             });
             const { result } = renderHook(() => useTamboV1Suggestions(), {
                 wrapper: createWrapper(),
@@ -339,65 +384,40 @@ describe("useTamboV1Suggestions", () => {
             expect(mockSetValue).toHaveBeenCalledWith("What's the weather like today?");
             expect(mockSubmit).toHaveBeenCalled();
         });
-        it("throws error when suggestion has no detailed content", async () => {
-            jest.mocked(useTamboV1).mockReturnValue({
-                messages: [
-                    {
-                        id: "msg_1",
-                        role: "assistant",
-                        content: [],
-                        createdAt: "2024-01-01T00:00:00Z",
-                    },
-                ],
-                thread: undefined,
-                isIdle: true,
-                isStreaming: false,
-                startNewThread: jest.fn(),
-                switchThread: jest.fn(),
-                initThread: jest.fn(),
-                streamingState: {
-                    status: "idle",
-                },
-            });
+        it("throws error when suggestion has no content", async () => {
             const { result } = renderHook(() => useTamboV1Suggestions(), {
                 wrapper: createWrapper(),
             });
             const emptySuggestion = {
                 id: "empty_suggestion",
-                suggestion: "Empty",
+                messageId: "msg_1",
+                title: "Empty",
                 detailedSuggestion: "",
             };
-            await expect(result.current.accept({ suggestion: emptySuggestion })).rejects.toThrow("Suggestion has no detailed content");
+            await expect(result.current.accept({ suggestion: emptySuggestion })).rejects.toThrow("Suggestion has no content");
         });
         it("throws error when detailedSuggestion is only whitespace", async () => {
-            jest.mocked(useTamboV1).mockReturnValue({
-                messages: [
-                    {
-                        id: "msg_1",
-                        role: "assistant",
-                        content: [],
-                        createdAt: "2024-01-01T00:00:00Z",
-                    },
-                ],
-                thread: undefined,
-                isIdle: true,
-                isStreaming: false,
-                startNewThread: jest.fn(),
-                switchThread: jest.fn(),
-                initThread: jest.fn(),
-                streamingState: {
-                    status: "idle",
-                },
-            });
             const { result } = renderHook(() => useTamboV1Suggestions(), {
                 wrapper: createWrapper(),
             });
             const whitespaceSuggestion = {
                 id: "whitespace_suggestion",
-                suggestion: "Whitespace",
+                messageId: "msg_1",
+                title: "Whitespace",
                 detailedSuggestion: "   ",
             };
-            await expect(result.current.accept({ suggestion: whitespaceSuggestion })).rejects.toThrow("Suggestion has no detailed content");
+            await expect(result.current.accept({ suggestion: whitespaceSuggestion })).rejects.toThrow("Suggestion has no content");
+        });
+        it("throws error when detailedSuggestion is undefined", async () => {
+            const { result } = renderHook(() => useTamboV1Suggestions(), {
+                wrapper: createWrapper(),
+            });
+            const undefinedSuggestion = {
+                id: "undefined_suggestion",
+                messageId: "msg_1",
+                title: "Undefined",
+            };
+            await expect(result.current.accept({ suggestion: undefinedSuggestion })).rejects.toThrow("Suggestion has no content");
         });
     });
     describe("State Management", () => {
@@ -415,12 +435,11 @@ describe("useTamboV1Suggestions", () => {
                 thread: undefined,
                 isIdle: true,
                 isStreaming: false,
+                currentThreadId: "thread_123",
                 startNewThread: jest.fn(),
                 switchThread: jest.fn(),
                 initThread: jest.fn(),
-                streamingState: {
-                    status: "idle",
-                },
+                streamingState: { status: "idle" },
             });
             const { result, rerender } = renderHook(() => useTamboV1Suggestions(), {
                 wrapper: createWrapper(),
@@ -454,19 +473,23 @@ describe("useTamboV1Suggestions", () => {
                 thread: undefined,
                 isIdle: true,
                 isStreaming: false,
+                currentThreadId: "thread_123",
                 startNewThread: jest.fn(),
                 switchThread: jest.fn(),
                 initThread: jest.fn(),
-                streamingState: {
-                    status: "idle",
-                },
+                streamingState: { status: "idle" },
             });
             rerender();
             await waitFor(() => {
                 expect(result.current.selectedSuggestionId).toBeNull();
             });
         });
-        it("exposes mutation and query results", async () => {
+        it("includes pagination info on raw data", async () => {
+            mockListSuggestions.mockResolvedValue({
+                suggestions: mockSuggestions,
+                hasMore: true,
+                nextCursor: "cursor_abc",
+            });
             jest.mocked(useTamboV1).mockReturnValue({
                 messages: [
                     {
@@ -479,27 +502,83 @@ describe("useTamboV1Suggestions", () => {
                 thread: undefined,
                 isIdle: true,
                 isStreaming: false,
+                currentThreadId: "thread_123",
                 startNewThread: jest.fn(),
                 switchThread: jest.fn(),
                 initThread: jest.fn(),
-                streamingState: {
-                    status: "idle",
-                },
+                streamingState: { status: "idle" },
+            });
+            const { result } = renderHook(() => useTamboV1Suggestions(), {
+                wrapper: createWrapper(),
+            });
+            await waitFor(() => {
+                expect(result.current.data?.hasMore).toBe(true);
+                expect(result.current.data?.nextCursor).toBe("cursor_abc");
             });
+        });
+        it("exposes loading and error states", () => {
             const { result } = renderHook(() => useTamboV1Suggestions(), {
                 wrapper: createWrapper(),
             });
-            expect(result.current.acceptResult).toBeDefined();
-            expect(result.current.generateResult).toBeDefined();
-            expect(result.current.suggestionsResult).toBeDefined();
+            expect(result.current.isLoading).toBeDefined();
+            expect(result.current.isSuccess).toBeDefined();
+            expect(result.current.isError).toBeDefined();
+            expect(result.current.error).toBeDefined();
+            expect(result.current.isAccepting).toBe(false);
+            expect(result.current.isGenerating).toBe(false);
         });
-        it("exposes combined mutation results (isPending, isError, error)", () => {
+    });
+    describe("Manual Generation", () => {
+        it("allows manual generation via generate function", async () => {
+            jest.mocked(useTamboV1).mockReturnValue({
+                messages: [
+                    {
+                        id: "msg_1",
+                        role: "assistant",
+                        content: [],
+                        createdAt: "2024-01-01T00:00:00Z",
+                    },
+                ],
+                thread: undefined,
+                isIdle: true,
+                isStreaming: false,
+                currentThreadId: "thread_123",
+                startNewThread: jest.fn(),
+                switchThread: jest.fn(),
+                initThread: jest.fn(),
+                streamingState: { status: "idle" },
+            });
+            const { result } = renderHook(() => useTamboV1Suggestions({ autoGenerate: false }), { wrapper: createWrapper() });
+            // No auto-generation
+            expect(mockCreateSuggestions).not.toHaveBeenCalled();
+            // Manual generation
+            await act(async () => {
+                await result.current.generate();
+            });
+            expect(mockCreateSuggestions).toHaveBeenCalledWith("msg_1", expect.objectContaining({
+                threadId: "thread_123",
+            }));
+        });
+        it("returns undefined from generate when no assistant message", async () => {
+            jest.mocked(useTamboV1).mockReturnValue({
+                messages: [],
+                thread: undefined,
+                isIdle: true,
+                isStreaming: false,
+                currentThreadId: "thread_123",
+                startNewThread: jest.fn(),
+                switchThread: jest.fn(),
+                initThread: jest.fn(),
+                streamingState: { status: "idle" },
+            });
             const { result } = renderHook(() => useTamboV1Suggestions(), {
                 wrapper: createWrapper(),
             });
-            expect(result.current.isPending).toBe(false);
-            expect(result.current.isError).toBe(false);
-            expect(result.current.error).toBeNull();
+            let generateResult;
+            await act(async () => {
+                generateResult = await result.current.generate();
+            });
+            expect(generateResult).toBeUndefined();
         });
     });
 });