@tambo-ai/react 0.75.0 → 1.0.0-rc.4

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

@@ -3,9 +3,9 @@ import { renderHook, act } from "@testing-library/react";
 import React, { useReducer } from "react";
 import { useTamboClient } from "../../providers/tambo-client-provider.js";
 import { TamboRegistryContext, } from "../../providers/tambo-registry-provider.js";
-import { TamboV1StreamProvider } from "../providers/tambo-v1-stream-context.js";
+import { TamboStreamProvider } from "../providers/tambo-v1-stream-context.js";
 import { streamReducer, } from "../utils/event-accumulator.js";
-import { useTamboV1 } from "./use-tambo-v1.js";
+import { useTambo } from "./use-tambo-v1.js";
 jest.mock("../../providers/tambo-client-provider", () => ({
     useTamboClient: jest.fn(),
     useTamboQueryClient: jest.fn(),
@@ -14,17 +14,17 @@ jest.mock("../providers/tambo-v1-provider", () => {
     const actual = jest.requireActual("../providers/tambo-v1-provider");
     return {
         ...actual,
-        useTamboV1Config: () => ({ userKey: undefined }),
+        useTamboConfig: () => ({ userKey: undefined }),
     };
 });
 jest.mock("./use-tambo-v1-auth-state", () => ({
-    useTamboV1AuthState: () => ({
+    useTamboAuthState: () => ({
         status: "identified",
         source: "userKey",
     }),
 }));
 import { useTamboQueryClient } from "../../providers/tambo-client-provider.js";
-describe("useTamboV1", () => {
+describe("useTambo", () => {
     let queryClient;
     const mockTamboClient = {
         apiKey: "",
@@ -57,23 +57,26 @@ describe("useTamboV1", () => {
     function TestWrapper({ children }) {
         return (React.createElement(QueryClientProvider, { client: queryClient },
             React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
-                React.createElement(TamboV1StreamProvider, null, children))));
+                React.createElement(TamboStreamProvider, null, children))));
     }
     function createWrapperWithState(state, registry = mockRegistry) {
         const noopDispatch = () => { };
         return function WrapperWithState({ children, }) {
             return (React.createElement(QueryClientProvider, { client: queryClient },
                 React.createElement(TamboRegistryContext.Provider, { value: registry },
-                    React.createElement(TamboV1StreamProvider, { state: state, dispatch: noopDispatch }, children))));
+                    React.createElement(TamboStreamProvider, { state: state, dispatch: noopDispatch }, children))));
         };
     }
     // Wrapper that uses the real reducer so state updates properly
-    function createWrapperWithRealReducer(initialState) {
+    function createWrapperWithRealReducer(initialState, stateRef) {
         return function WrapperWithRealReducer({ children, }) {
             const [state, dispatch] = useReducer(streamReducer, initialState);
+            if (stateRef) {
+                stateRef.current = state;
+            }
             return (React.createElement(QueryClientProvider, { client: queryClient },
                 React.createElement(TamboRegistryContext.Provider, { value: mockRegistry },
-                    React.createElement(TamboV1StreamProvider, { state: state, dispatch: dispatch }, children))));
+                    React.createElement(TamboStreamProvider, { state: state, dispatch: dispatch }, children))));
         };
     }
     beforeEach(() => {
@@ -85,15 +88,16 @@ describe("useTamboV1", () => {
         jest.mocked(useTamboClient).mockReturnValue(mockTamboClient);
         jest.mocked(useTamboQueryClient).mockReturnValue(queryClient);
         jest.clearAllMocks();
+        delete mockTamboClient.threads.update;
     });
     it("returns client from useTamboClient", () => {
-        const { result } = renderHook(() => useTamboV1(), {
+        const { result } = renderHook(() => useTambo(), {
             wrapper: TestWrapper,
         });
         expect(result.current.client).toBe(mockTamboClient);
     });
     it("returns registry functions", () => {
-        const { result } = renderHook(() => useTamboV1(), {
+        const { result } = renderHook(() => useTambo(), {
             wrapper: TestWrapper,
         });
         expect(result.current.registerComponent).toBe(mockRegistry.registerComponent);
@@ -103,7 +107,7 @@ describe("useTamboV1", () => {
         expect(result.current.toolRegistry).toBe(mockRegistry.toolRegistry);
     });
     it("returns placeholder thread when no threadId provided", () => {
-        const { result } = renderHook(() => useTamboV1(), {
+        const { result } = renderHook(() => useTambo(), {
             wrapper: TestWrapper,
         });
         // Default state has placeholder thread for optimistic UI
@@ -112,7 +116,7 @@ describe("useTamboV1", () => {
         expect(result.current.messages).toEqual([]);
     });
     it("returns thread state when switched to a thread", () => {
-        const { result } = renderHook(() => useTamboV1(), {
+        const { result } = renderHook(() => useTambo(), {
             wrapper: TestWrapper,
         });
         // Initialize and switch to thread
@@ -125,7 +129,7 @@ describe("useTamboV1", () => {
         expect(result.current.messages).toEqual([]);
     });
     it("returns default streaming state when thread not loaded", () => {
-        const { result } = renderHook(() => useTamboV1(), {
+        const { result } = renderHook(() => useTambo(), {
             wrapper: TestWrapper,
         });
         expect(result.current.streamingState).toEqual({ status: "idle" });
@@ -134,7 +138,7 @@ describe("useTamboV1", () => {
         expect(result.current.isWaiting).toBe(false);
     });
     it("returns thread streaming state when thread loaded", () => {
-        const { result } = renderHook(() => useTamboV1(), {
+        const { result } = renderHook(() => useTambo(), {
             wrapper: TestWrapper,
         });
         // Initialize and switch to thread
@@ -148,13 +152,13 @@ describe("useTamboV1", () => {
         expect(result.current.isWaiting).toBe(false);
     });
     it("provides dispatch function for advanced usage", () => {
-        const { result } = renderHook(() => useTamboV1(), {
+        const { result } = renderHook(() => useTambo(), {
             wrapper: TestWrapper,
         });
         expect(typeof result.current.dispatch).toBe("function");
     });
     it("provides thread management functions", () => {
-        const { result } = renderHook(() => useTamboV1(), {
+        const { result } = renderHook(() => useTambo(), {
             wrapper: TestWrapper,
         });
         expect(typeof result.current.initThread).toBe("function");
@@ -162,7 +166,7 @@ describe("useTamboV1", () => {
         expect(typeof result.current.startNewThread).toBe("function");
     });
     it("initializes and switches threads", () => {
-        const { result } = renderHook(() => useTamboV1(), {
+        const { result } = renderHook(() => useTambo(), {
             wrapper: TestWrapper,
         });
         // Initially has placeholder thread for optimistic UI
@@ -180,7 +184,7 @@ describe("useTamboV1", () => {
         expect(result.current.currentThreadId).toBe("new_thread_1");
     });
     it("starts new thread with generated ID", () => {
-        const { result } = renderHook(() => useTamboV1(), {
+        const { result } = renderHook(() => useTambo(), {
             wrapper: TestWrapper,
         });
         let newThreadId;
@@ -192,7 +196,7 @@ describe("useTamboV1", () => {
         expect(result.current.thread).toBeDefined();
     });
     it("uses current thread when no threadId argument provided", () => {
-        const { result } = renderHook(() => useTamboV1(), {
+        const { result } = renderHook(() => useTambo(), {
             wrapper: TestWrapper,
         });
         // Initialize and switch to a thread
@@ -241,7 +245,7 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
             expect(result.current.messages).toHaveLength(1);
@@ -279,7 +283,7 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
             expect(result.current.messages).toHaveLength(1);
@@ -319,7 +323,7 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result, rerender } = renderHook(() => useTamboV1(), {
+            const { result, rerender } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
             const firstRender = result.current.messages[0].content[0].renderedComponent;
@@ -356,7 +360,7 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
             const content = result.current.messages[0].content[0];
@@ -396,7 +400,7 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
             const content = result.current.messages[0].content[0];
@@ -438,7 +442,7 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
             expect(result.current.messages[0].content).toHaveLength(3);
@@ -477,7 +481,7 @@ describe("useTamboV1", () => {
                 currentThreadId: "placeholder",
             };
             // No explicit threadId - uses currentThreadId from state
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
             // Component should render using the placeholder thread
@@ -519,10 +523,11 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
-            const content = result.current.messages[0].content[0];
+            const content = result.current.messages[0]
+                .content[0];
             expect(content.type).toBe("tool_use");
             expect(content.hasCompleted).toBe(false);
             expect(content.statusMessage).toBe("Calling getWeather");
@@ -572,10 +577,11 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
-            const content = result.current.messages[0].content[0];
+            const content = result.current.messages[0]
+                .content[0];
             expect(content.hasCompleted).toBe(true);
             expect(content.statusMessage).toBe("Called getWeather");
         });
@@ -614,10 +620,11 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
-            const content = result.current.messages[0].content[0];
+            const content = result.current.messages[0]
+                .content[0];
             expect(content.statusMessage).toBe("Fetching weather for NYC...");
             expect(content.tamboDisplayProps?._tambo_statusMessage).toBe("Fetching weather for NYC...");
         });
@@ -669,10 +676,11 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
-            const content = result.current.messages[0].content[0];
+            const content = result.current.messages[0]
+                .content[0];
             expect(content.hasCompleted).toBe(true);
             expect(content.statusMessage).toBe("Got weather for NYC");
         });
@@ -696,7 +704,6 @@ describe("useTamboV1", () => {
                                                 units: "celsius",
                                                 _tambo_statusMessage: "Fetching...",
                                                 _tambo_completionStatusMessage: "Done",
-                                                _tambo_displayMessage: "Weather lookup",
                                             },
                                         },
                                     ],
@@ -714,15 +721,15 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
-            const content = result.current.messages[0].content[0];
+            const content = result.current.messages[0]
+                .content[0];
             // Input should only have non-_tambo_ properties
             expect(content.input).toEqual({ location: "NYC", units: "celsius" });
             expect(content.input._tambo_statusMessage).toBeUndefined();
             expect(content.input._tambo_completionStatusMessage).toBeUndefined();
-            expect(content.input._tambo_displayMessage).toBeUndefined();
         });
         it("handles tool_use with empty input", () => {
             const state = {
@@ -756,10 +763,11 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
-            const content = result.current.messages[0].content[0];
+            const content = result.current.messages[0]
+                .content[0];
             expect(content.input).toEqual({});
             expect(content.hasCompleted).toBe(false);
             expect(content.statusMessage).toBe("Calling getCurrentTime");
@@ -796,10 +804,11 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
-            const content = result.current.messages[0].content[0];
+            const content = result.current.messages[0]
+                .content[0];
             expect(content.input).toEqual({});
             expect(content.hasCompleted).toBe(false);
         });
@@ -854,11 +863,13 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithState(state),
             });
-            const tool1 = result.current.messages[0].content[0];
-            const tool2 = result.current.messages[0].content[1];
+            const tool1 = result.current.messages[0]
+                .content[0];
+            const tool2 = result.current.messages[0]
+                .content[1];
             expect(tool1.hasCompleted).toBe(true);
             expect(tool1.statusMessage).toBe("Called getWeather");
             expect(tool2.hasCompleted).toBe(false);
@@ -884,7 +895,7 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithRealReducer(initialState),
             });
             // Before cancel: streaming and lastRunCancelled is false
@@ -919,7 +930,7 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithRealReducer(initialState),
             });
             // Idle before
@@ -952,7 +963,7 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "placeholder",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithRealReducer(initialState),
             });
             // Before: streaming on placeholder
@@ -992,7 +1003,7 @@ describe("useTamboV1", () => {
                 },
                 currentThreadId: "thread_123",
             };
-            const { result } = renderHook(() => useTamboV1(), {
+            const { result } = renderHook(() => useTambo(), {
                 wrapper: createWrapperWithRealReducer(initialState),
             });
             await act(async () => {
@@ -1006,5 +1017,122 @@ describe("useTamboV1", () => {
             consoleWarnSpy.mockRestore();
         });
     });
+    describe("updateThreadName", () => {
+        it("updates local thread name and invalidates caches on success", async () => {
+            const mockUpdate = jest.fn().mockResolvedValue({});
+            // TypeScript SDK will be updated to include this method
+            mockTamboClient.threads.update = mockUpdate;
+            const invalidateQueriesSpy = jest.spyOn(queryClient, "invalidateQueries");
+            const initialState = {
+                threadMap: {
+                    thread_456: {
+                        thread: {
+                            id: "thread_456",
+                            messages: [],
+                            status: "idle",
+                            createdAt: new Date().toISOString(),
+                            updatedAt: new Date().toISOString(),
+                            lastRunCancelled: false,
+                            name: "Old Name",
+                        },
+                        streaming: { status: "idle" },
+                        accumulatingToolArgs: new Map(),
+                    },
+                },
+                currentThreadId: "thread_456",
+            };
+            const { result } = renderHook(() => useTambo(), {
+                wrapper: createWrapperWithRealReducer(initialState),
+            });
+            await act(async () => {
+                await result.current.updateThreadName("thread_456", "My New Thread");
+            });
+            expect(mockUpdate).toHaveBeenCalledWith("thread_456", {
+                name: "My New Thread",
+            });
+            expect(result.current.thread?.thread.name).toBe("My New Thread");
+            const invalidatedKeys = invalidateQueriesSpy.mock.calls
+                .map(([arg]) => arg.queryKey)
+                .filter(Boolean);
+            expect(invalidatedKeys).toContainEqual(["v1-threads", "list"]);
+            expect(invalidatedKeys).toContainEqual(["v1-threads", "thread_456"]);
+        });
+        it("does not create local thread state when thread isn't loaded", async () => {
+            const mockUpdate = jest.fn().mockResolvedValue({});
+            // TypeScript SDK will be updated to include this method
+            mockTamboClient.threads.update = mockUpdate;
+            const invalidateQueriesSpy = jest.spyOn(queryClient, "invalidateQueries");
+            // Track the internal StreamState from the real reducer so we can assert we
+            // don't create a local thread entry for threads that haven't been loaded.
+            const stateRef = {
+                current: undefined,
+            };
+            const initialState = {
+                threadMap: {},
+                currentThreadId: "placeholder",
+            };
+            const { result } = renderHook(() => useTambo(), {
+                wrapper: createWrapperWithRealReducer(initialState, stateRef),
+            });
+            await act(async () => {
+                await result.current.updateThreadName("thread_789", "New Title");
+            });
+            expect(mockUpdate).toHaveBeenCalledWith("thread_789", {
+                name: "New Title",
+            });
+            const invalidatedKeys = invalidateQueriesSpy.mock.calls
+                .map(([arg]) => arg.queryKey)
+                .filter(Boolean);
+            expect(invalidatedKeys).toContainEqual(["v1-threads", "list"]);
+            expect(invalidatedKeys).toContainEqual(["v1-threads", "thread_789"]);
+            expect(stateRef.current?.threadMap.thread_789).toBeUndefined();
+            act(() => {
+                result.current.switchThread("thread_789");
+            });
+            expect(result.current.thread).toBeUndefined();
+        });
+        it("propagates errors and does not update local state", async () => {
+            const mockUpdate = jest
+                .fn()
+                .mockRejectedValue(new Error("Network error"));
+            // TypeScript SDK will be updated to include this method
+            mockTamboClient.threads.update = mockUpdate;
+            const invalidateQueriesSpy = jest.spyOn(queryClient, "invalidateQueries");
+            const initialState = {
+                threadMap: {
+                    thread_456: {
+                        thread: {
+                            id: "thread_456",
+                            messages: [],
+                            status: "idle",
+                            createdAt: new Date().toISOString(),
+                            updatedAt: new Date().toISOString(),
+                            lastRunCancelled: false,
+                            name: "Old Name",
+                        },
+                        streaming: { status: "idle" },
+                        accumulatingToolArgs: new Map(),
+                    },
+                },
+                currentThreadId: "thread_456",
+            };
+            const { result } = renderHook(() => useTambo(), {
+                wrapper: createWrapperWithRealReducer(initialState),
+            });
+            let caughtError;
+            await act(async () => {
+                try {
+                    await result.current.updateThreadName("thread_456", "My New Thread");
+                }
+                catch (error) {
+                    caughtError = error;
+                }
+            });
+            expect(caughtError).toBeInstanceOf(Error);
+            expect(caughtError.message).toBe("Network error");
+            expect(result.current.thread?.thread.name).toBe("Old Name");
+            expect(invalidateQueriesSpy).not.toHaveBeenCalled();
+        });
+    });
 });
 //# sourceMappingURL=use-tambo-v1.test.js.map