@envive-ai/react-hooks 0.3.4 → 0.3.5

package/src/contexts/pageContext/__tests__/pageContext.test.tsx

@@ -1,11 +1,16 @@
-import { PageVisitCategory, UserEvent } from '@spiffy-ai/commerce-api-client';
+import { PageVisitCategory, UserEventCategory } from '@spiffy-ai/commerce-api-client';
 import { act, render, screen, waitFor } from '@testing-library/react';
 import { Provider, useAtom } from 'jotai';
 import React from 'react';
 import CommerceApiClient from 'src/application/commerce-api';
 import Logger from 'src/application/logging/logger';
 import { VariantTypeEnum } from 'src/application/models';
-import { UrlResolverResponse, urlResolverAtom } from 'src/atoms/app/variant';
+import {
+  UrlResolverResponse,
+  pageUserEventAtom,
+  pageVariantInfoAtom,
+  urlResolverAtom,
+} from 'src/atoms/app/variant';
 import { mapUrlResolverResponseToVariantInfo } from '../mapping';
 import { PageProvider, usePage } from '../pageContext';
 
@@ -35,6 +40,7 @@ const MockComponent: React.FC = () => {
       <div data-testid="user-event">
         {context.userEvent ? JSON.stringify(context.userEvent) : 'undefined'}
       </div>
+      <div data-testid="is-loading">{context.isLoading ? 'true' : 'false'}</div>
     </div>
   );
 };
@@ -69,10 +75,10 @@ describe('PageProvider', () => {
     window.location = originalLocation;
   });
 
-  const renderWithProviders = (children: React.ReactNode) => {
+  const renderWithProviders = (children: React.ReactNode, previewMode = false) => {
     return render(
       <Provider>
-        <PageProvider>{children}</PageProvider>
+        <PageProvider previewMode={previewMode}>{children}</PageProvider>
       </Provider>,
     );
   };
@@ -89,9 +95,6 @@ describe('PageProvider', () => {
     });
 
     it('should handle missing window.location gracefully', async () => {
-      // This test verifies that the component handles edge cases
-      // In a real browser environment, window.location is always available
-      // This test ensures the component doesn't crash in unusual test scenarios
       const originalLocation = window.location;
 
       // Temporarily remove location
@@ -108,7 +111,91 @@ describe('PageProvider', () => {
     });
   });
 
-  describe('URL Resolution', () => {
+  describe('Preview Mode', () => {
+    it('should auto-initialize atoms when previewMode is true', async () => {
+      window.location.href = 'https://example.com/preview-page';
+
+      renderWithProviders(<MockComponent />, true);
+
+      await waitFor(() => {
+        const userEvent = screen.getByTestId('user-event').textContent;
+        expect(userEvent).toContain('preview-user-event');
+        expect(userEvent).toContain(UserEventCategory.PageVisit);
+        expect(userEvent).toContain(PageVisitCategory.Other);
+      });
+
+      await waitFor(() => {
+        const variantInfo = screen.getByTestId('variant-info').textContent;
+        expect(variantInfo).toContain(VariantTypeEnum.PageVisit);
+        expect(variantInfo).toContain('https://example.com/preview-page');
+      });
+    });
+
+    it('should skip API call when previewMode is true', async () => {
+      window.location.href = 'https://example.com/preview-test';
+
+      renderWithProviders(<MockComponent />, true);
+
+      // Wait for initialization
+      await waitFor(() => {
+        expect(screen.getByTestId('user-event').textContent).not.toBe('undefined');
+      });
+
+      // Should not call resolveUrl when in preview mode
+      expect(mockResolveUrl).not.toHaveBeenCalled();
+    });
+
+    it('should not overwrite existing atoms in preview mode', async () => {
+      window.location.href = 'https://example.com/existing-atoms';
+      // Set up existing atoms before preview mode
+      const TestWrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+        const [, setUserEvent] = useAtom(pageUserEventAtom);
+        const [, setVariantInfo] = useAtom(pageVariantInfoAtom);
+        React.useEffect(() => {
+          setUserEvent({
+            event_id: 'existing-event',
+            created_at: new Date().toISOString(),
+            category: UserEventCategory.PageVisit,
+            attributes: {
+              page_visit_category: PageVisitCategory.Other,
+              url: 'https://example.com/existing',
+            },
+          } as any);
+          setVariantInfo({
+            variantType: VariantTypeEnum.Pdp,
+            productId: 'existing-product',
+            url: 'https://example.com/existing',
+          } as any);
+        }, [setUserEvent, setVariantInfo]);
+        return <PageProvider previewMode>{children}</PageProvider>;
+      };
+      render(
+        <Provider>
+          <TestWrapper>
+            <MockComponent />
+          </TestWrapper>
+        </Provider>,
+      );
+      // Should keep existing atoms, not overwrite with preview values
+      await waitFor(() => {
+        const userEvent = screen.getByTestId('user-event').textContent;
+        expect(userEvent).toContain('existing-event');
+        expect(userEvent).not.toContain('preview-user-event');
+      });
+    });
+
+    it('should set isLoading to false in preview mode', async () => {
+      window.location.href = 'https://example.com/loading-test';
+
+      renderWithProviders(<MockComponent />, true);
+
+      await waitFor(() => {
+        expect(screen.getByTestId('is-loading').textContent).toBe('false');
+      });
+    });
+  });
+
+  describe('URL Resolution (Non-Preview Mode)', () => {
     it('should call CommerceApiClient.resolveUrl when pageUrl is set', async () => {
       const mockResponse: UrlResolverResponse = {
         variant_type: VariantTypeEnum.PageVisit,
@@ -120,7 +207,7 @@ describe('PageProvider', () => {
 
       window.location.href = 'https://example.com/test';
 
-      renderWithProviders(<MockComponent />);
+      renderWithProviders(<MockComponent />, false);
 
       await waitFor(() => {
         expect(mockResolveUrl).toHaveBeenCalledWith('https://example.com/test');
@@ -138,7 +225,7 @@ describe('PageProvider', () => {
 
       window.location.href = '  HTTPS://EXAMPLE.COM/TEST  ';
 
-      renderWithProviders(<MockComponent />);
+      renderWithProviders(<MockComponent />, false);
 
       await waitFor(() => {
         expect(mockResolveUrl).toHaveBeenCalledWith('https://example.com/test');
@@ -169,7 +256,7 @@ describe('PageProvider', () => {
           });
         }, [setUrlResolver]);
 
-        return <PageProvider>{children}</PageProvider>;
+        return <PageProvider previewMode={false}>{children}</PageProvider>;
       };
 
       render(
@@ -197,7 +284,7 @@ describe('PageProvider', () => {
       // Test with an empty URL string
       window.location.href = '';
 
-      renderWithProviders(<MockComponent />);
+      renderWithProviders(<MockComponent />, false);
 
       // Wait for initial render
       await waitFor(() => {
@@ -205,7 +292,6 @@ describe('PageProvider', () => {
       });
 
       // Empty string is falsy, so resolveUrl should not be called
-      // The component checks `if (!pageUrl)` which treats empty string as falsy
       await act(async () => {
         await new Promise<void>(resolve => {
           setTimeout(resolve, 100);
@@ -231,7 +317,7 @@ describe('PageProvider', () => {
       mockResolveUrl.mockResolvedValue(mockResponse);
       window.location.href = 'https://example.com/product';
 
-      renderWithProviders(<MockComponent />);
+      renderWithProviders(<MockComponent />, false);
 
       await waitFor(() => {
         const variantInfo = screen.getByTestId('variant-info').textContent;
@@ -257,7 +343,7 @@ describe('PageProvider', () => {
       mockResolveUrl.mockResolvedValue(mockResponse);
       window.location.href = 'https://example.com/category';
 
-      renderWithProviders(<MockComponent />);
+      renderWithProviders(<MockComponent />, false);
 
       await waitFor(() => {
         const variantInfo = screen.getByTestId('variant-info').textContent;
@@ -277,7 +363,7 @@ describe('PageProvider', () => {
       mockResolveUrl.mockResolvedValue(mockResponse);
       window.location.href = 'https://example.com/page';
 
-      renderWithProviders(<MockComponent />);
+      renderWithProviders(<MockComponent />, false);
 
       await waitFor(() => {
         const variantInfo = screen.getByTestId('variant-info').textContent;
@@ -298,7 +384,7 @@ describe('PageProvider', () => {
       mockResolveUrl.mockResolvedValue(mockResponse);
       window.location.href = 'https://example.com/product';
 
-      renderWithProviders(<MockComponent />);
+      renderWithProviders(<MockComponent />, false);
 
       await waitFor(() => {
         const variantInfo = screen.getByTestId('variant-info').textContent;
@@ -319,7 +405,7 @@ describe('PageProvider', () => {
       mockResolveUrl.mockResolvedValue(mockResponse);
       window.location.href = 'https://example.com/category';
 
-      renderWithProviders(<MockComponent />);
+      renderWithProviders(<MockComponent />, false);
 
       await waitFor(() => {
         const variantInfo = screen.getByTestId('variant-info').textContent;
@@ -334,7 +420,13 @@ describe('PageProvider', () => {
       const mockUserEvent = {
         event_id: 'event-123',
         event_type: PageVisitCategory.Other,
-      } as unknown as UserEvent;
+        created_at: new Date().toISOString(),
+        category: UserEventCategory.PageVisit,
+        attributes: {
+          url: 'https://example.com/page',
+          page_visit_category: PageVisitCategory.Other,
+        },
+      };
 
       const mockResponse: UrlResolverResponse = {
         variant_type: VariantTypeEnum.PageVisit,
@@ -346,7 +438,7 @@ describe('PageProvider', () => {
       mockResolveUrl.mockResolvedValue(mockResponse);
       window.location.href = 'https://example.com/page';
 
-      renderWithProviders(<MockComponent />);
+      renderWithProviders(<MockComponent />, false);
 
       await waitFor(() => {
         const userEvent = screen.getByTestId('user-event').textContent;
@@ -365,7 +457,7 @@ describe('PageProvider', () => {
       mockResolveUrl.mockResolvedValue(mockResponse);
       window.location.href = 'https://example.com/page';
 
-      renderWithProviders(<MockComponent />);
+      renderWithProviders(<MockComponent />, false);
 
       await waitFor(() => {
         const userEvent = screen.getByTestId('user-event').textContent;
@@ -382,7 +474,7 @@ describe('PageProvider', () => {
 
       window.location.href = 'https://example.com/error-page';
 
-      renderWithProviders(<MockComponent />);
+      renderWithProviders(<MockComponent />, false);
 
       await waitFor(() => {
         expect(errorSpy).toHaveBeenCalledWith('Failed to resolve page URL', error, {
@@ -395,8 +487,6 @@ describe('PageProvider', () => {
     });
 
     it('should handle invalid variant type gracefully', async () => {
-      // This test verifies that the mapping function throws an error for invalid types
-      // The error should be caught and logged
       const errorSpy = vi.spyOn(Logger, 'logError');
 
       const invalidResponse = {
@@ -408,7 +498,7 @@ describe('PageProvider', () => {
       mockResolveUrl.mockResolvedValue(invalidResponse);
       window.location.href = 'https://example.com/invalid';
 
-      renderWithProviders(<MockComponent />);
+      renderWithProviders(<MockComponent />, false);
 
       // The mapping function should throw, which will be caught in the useEffect
       await waitFor(() => {
@@ -443,48 +533,13 @@ describe('PageProvider', () => {
       mockResolveUrl.mockResolvedValue(mockResponse);
       window.location.href = 'https://example.com/test';
 
-      renderWithProviders(<MockComponent />);
+      renderWithProviders(<MockComponent />, false);
 
       await waitFor(() => {
         expect(screen.getByTestId('page-url').textContent).toBe('https://example.com/test');
         expect(screen.getByTestId('variant-info').textContent).not.toBe('undefined');
       });
     });
-
-    it('should update context when pageUrl changes', async () => {
-      const mockResponse1: UrlResolverResponse = {
-        variant_type: VariantTypeEnum.PageVisit,
-        specific_details: {},
-        ready: true,
-      };
-
-      const mockResponse2: UrlResolverResponse = {
-        variant_type: VariantTypeEnum.Pdp,
-        specific_details: {
-          pdp_attributes: {
-            product_id: 'product-789',
-          },
-        },
-        ready: true,
-      };
-
-      mockResolveUrl.mockResolvedValueOnce(mockResponse1).mockResolvedValueOnce(mockResponse2);
-
-      window.location.href = 'https://example.com/page1';
-
-      const { rerender } = renderWithProviders(<MockComponent />);
-
-      await waitFor(() => {
-        expect(screen.getByTestId('page-url').textContent).toBe('https://example.com/page1');
-      });
-
-      // Change the URL
-      window.location.href = 'https://example.com/page2';
-
-      // Note: In a real SPA, the URL change would trigger the useEffect
-      // For testing, we need to manually trigger or test the effect differently
-      // This test demonstrates the expected behavior
-    });
   });
 
   describe('Context Value Memoization', () => {
@@ -505,7 +560,7 @@ describe('PageProvider', () => {
         return <div data-testid="count">{renderCount}</div>;
       };
 
-      renderWithProviders(<CountingComponent />);
+      renderWithProviders(<CountingComponent />, false);
 
       await waitFor(() => {
         expect(screen.getByTestId('count')).toBeInTheDocument();
@@ -521,8 +576,7 @@ describe('PageProvider', () => {
         });
       });
 
-      // The context value should be memoized, so additional renders
-      // should be minimal (only from initial setup)
+      // The context value should be memoized
       expect(renderCount).toBeGreaterThanOrEqual(initialCount);
     });
   });
@@ -544,7 +598,7 @@ describe('PageProvider', () => {
 
       render(
         <Provider>
-          <PageProvider>
+          <PageProvider previewMode={false}>
             <MockComponent />
             <AtomReaderComponent />
           </PageProvider>
@@ -554,10 +608,6 @@ describe('PageProvider', () => {
       await waitFor(() => {
         expect(mockResolveUrl).toHaveBeenCalled();
       });
-
-      // The atom should eventually contain the cached response
-      // Note: The actual caching happens in the atom setter, which may
-      // require additional setup to test directly
     });
   });
 });

package/src/contexts/pageContext/mapping.ts

@@ -1,6 +1,19 @@
 import { UrlResolverResponse } from 'src/atoms/app/variant';
-
-import { VariantTypeEnum } from 'src/application/models';
+import {
+  UserEvent as ApiUserEvent,
+  PageVisitCategory,
+  UserEventCategory,
+} from '@spiffy-ai/commerce-api-client';
+import { UserEvent, VariantTypeEnum } from 'src/application/models';
+import { isApiPDPAttributes } from 'src/application/models/guards/api/isApiPDPEventAttributes';
+import {
+  isApiPLPEventAttributes,
+  isApiPLPIdAttribute,
+} from 'src/application/models/guards/api/isApiPLPEventAttributes';
+import { isApiQueryTypedAttributes } from 'src/application/models/guards/api/isApiQueryTypedEventAttributes';
+import { isApiSearchAttributes } from 'src/application/models/guards/api/isApiSearchEventAttributes';
+import { isApiSuggestionClickedAttributes } from 'src/application/models/guards/api/isApiSuggestionClickedEventAttributes';
+import { isApiFormSubmittedResponseAttributes } from 'src/application/models/guards/api/isApiFormSubmittedResponseAttributes';
 
 import { PageVariantInfo, VisitPageVariantInfo } from './types';
 
@@ -40,3 +53,172 @@ export const mapUrlResolverResponseToVariantInfo = (
   }
   throw new Error('Invalid variant type');
 };
+
+const isApiPageVisitAttributes = (
+  data: unknown,
+): data is { url: string; page_visit_category: PageVisitCategory } => {
+  if (data == null || typeof data !== 'object') {
+    return false;
+  }
+
+  if (!('url' in data) || typeof data.url !== 'string') {
+    return false;
+  }
+
+  if (
+    !('page_visit_category' in data) ||
+    typeof data.page_visit_category !== 'string' ||
+    !Object.values(PageVisitCategory).includes(data.page_visit_category as PageVisitCategory)
+  ) {
+    return false;
+  }
+
+  return true;
+};
+
+export const mapApiUserEventToUserEvent = (
+  userEvent: ApiUserEvent | undefined,
+): UserEvent | undefined => {
+  if (!userEvent) {
+    return undefined;
+  }
+  // Handle PdpVisit and AddToCart (they share the same attributes structure)
+  if (
+    (userEvent.category === UserEventCategory.PdpVisit ||
+      userEvent.category === UserEventCategory.AddToCart) &&
+    isApiPDPAttributes(userEvent.attributes)
+  ) {
+    return {
+      eventId: userEvent.event_id,
+      createdAt: userEvent.created_at,
+      category: userEvent.category,
+      attributes: {
+        productId: userEvent.attributes.product_id,
+        parentProductId:
+          userEvent.attributes.parent_product_id !== null
+            ? userEvent.attributes.parent_product_id
+            : '',
+        url: userEvent.attributes.url,
+      },
+    };
+  }
+
+  // Handle PlpVisit
+  if (
+    userEvent.category === UserEventCategory.PlpVisit &&
+    isApiPLPEventAttributes(userEvent.attributes)
+  ) {
+    if (isApiPLPIdAttribute(userEvent.attributes.attributes)) {
+      return {
+        eventId: userEvent.event_id,
+        createdAt: userEvent.created_at,
+        category: UserEventCategory.PlpVisit,
+        attributes: {
+          category: userEvent.attributes.category,
+          attributes: {
+            id: userEvent.attributes.attributes.id,
+          },
+        },
+      };
+    }
+  }
+
+  // Handle QueryTyped
+  if (
+    userEvent.category === UserEventCategory.QueryTyped &&
+    isApiQueryTypedAttributes(userEvent.attributes)
+  ) {
+    return {
+      eventId: userEvent.event_id,
+      createdAt: userEvent.created_at,
+      category: UserEventCategory.QueryTyped,
+      attributes: {
+        query: userEvent.attributes.query,
+      },
+    };
+  }
+
+  // Handle Search
+  if (
+    userEvent.category === UserEventCategory.Search &&
+    isApiSearchAttributes(userEvent.attributes)
+  ) {
+    return {
+      eventId: userEvent.event_id,
+      createdAt: userEvent.created_at,
+      category: UserEventCategory.Search,
+      attributes: {
+        searchTerm: userEvent.attributes.search_term,
+        selectedFilters: userEvent.attributes.selected_filters,
+      },
+    };
+  }
+
+  // Handle SuggestionClicked
+  if (
+    userEvent.category === UserEventCategory.SuggestionClicked &&
+    isApiSuggestionClickedAttributes(userEvent.attributes)
+  ) {
+    return {
+      eventId: userEvent.event_id,
+      createdAt: userEvent.created_at,
+      category: UserEventCategory.SuggestionClicked,
+      attributes: {
+        suggestionId: userEvent.attributes.suggestion_id,
+      },
+    };
+  }
+
+  // Handle PageVisit
+  if (
+    userEvent.category === UserEventCategory.PageVisit &&
+    isApiPageVisitAttributes(userEvent.attributes)
+  ) {
+    return {
+      eventId: userEvent.event_id,
+      createdAt: userEvent.created_at,
+      category: UserEventCategory.PageVisit,
+      attributes: {
+        url: userEvent.attributes.url,
+        pageVisitCategory: userEvent.attributes.page_visit_category,
+      },
+    };
+  }
+
+  // Handle FormSubmitted
+  if (
+    userEvent.category === UserEventCategory.FormSubmitted &&
+    isApiFormSubmittedResponseAttributes(userEvent.attributes)
+  ) {
+    return {
+      eventId: userEvent.event_id,
+      createdAt: userEvent.created_at,
+      category: UserEventCategory.FormSubmitted,
+      attributes: {
+        filledSchema: { ...userEvent.attributes.filled_schema },
+        formResponseId: userEvent.attributes.form_response_id,
+        formType: userEvent.attributes.form_type,
+      },
+    };
+  }
+
+  // Handle AppLoaded (no attributes)
+  if (userEvent.category === UserEventCategory.AppLoaded) {
+    return {
+      eventId: userEvent.event_id,
+      createdAt: userEvent.created_at,
+      category: UserEventCategory.AppLoaded,
+    };
+  }
+
+  // Handle AppUnloaded (no attributes)
+  if (userEvent.category === UserEventCategory.AppUnloaded) {
+    return {
+      eventId: userEvent.event_id,
+      createdAt: userEvent.created_at,
+      category: UserEventCategory.AppUnloaded,
+    };
+  }
+
+  throw new Error(`Invalid user event category: ${userEvent.category}`);
+};

package/src/contexts/pageContext/pageContext.tsx

@@ -16,7 +16,9 @@ import {
 import { useAtom } from 'jotai';
 import CommerceApiClient from 'src/application/commerce-api';
 import Logger from 'src/application/logging/logger';
-import { mapUrlResolverResponseToVariantInfo } from './mapping';
+import { PageVisitCategory, UserEventCategory } from '@spiffy-ai/commerce-api-client';
+import { VariantTypeEnum } from 'src/application/models';
+import { mapApiUserEventToUserEvent, mapUrlResolverResponseToVariantInfo } from './mapping';
 import { PageDetails } from './types';
 
 const PageContext = createContext<
@@ -25,7 +27,8 @@ const PageContext = createContext<
 
 export const PageProvider: React.FC<{
   children: ReactNode;
-}> = ({ children }) => {
+  previewMode: boolean;
+}> = ({ children, previewMode = false }) => {
   const [pageUrl, setPageUrl] = useState<string | undefined>(undefined);
   const [urlResolverResponse, setUrlResolverResponse] = useAtom(urlResolverAtom);
   const [isLoading, setIsLoading] = useState(false);
@@ -37,10 +40,31 @@ export const PageProvider: React.FC<{
     setPageUrl(window.location.href);
   }, []);
 
+  // Auto-initialize atoms for preview mode
+  useEffect(() => {
+    if (previewMode && !userEvent && !variantInfo) {
+      const url = typeof window !== 'undefined' ? window.location.href : '';
+      setUserEvent({
+        event_id: 'preview-user-event',
+        created_at: new Date().toISOString(),
+        category: UserEventCategory.PageVisit,
+        attributes: {
+          page_visit_category: PageVisitCategory.Other,
+          url,
+        },
+      } as any);
+
+      setVariantInfo({
+        variantType: VariantTypeEnum.PageVisit,
+        url,
+      });
+    }
+  }, [previewMode, userEvent, variantInfo, setUserEvent, setVariantInfo]);
+
   const setVariantFromUrlResolver = useCallback(
     (url: string, response: UrlResolverResponse) => {
       const newVariantInfo = mapUrlResolverResponseToVariantInfo(url, response);
-      const newUserEvent = response.user_event ?? undefined;
+      const newUserEvent = mapApiUserEventToUserEvent(response.user_event ?? undefined);
       setVariantInfo(newVariantInfo);
       setUserEvent(newUserEvent);
     },
@@ -56,8 +80,8 @@ export const PageProvider: React.FC<{
           return;
         }
 
-        // If atoms are already set (e.g., by storybook), skip API call
-        if (userEvent || variantInfo) {
+        // If in preview mode or atoms are already set (e.g., by storybook), skip API call
+        if (previewMode || userEvent || variantInfo) {
           setIsLoading(false);
           return;
         }
@@ -82,6 +106,7 @@ export const PageProvider: React.FC<{
     setVariantFromUrlResolver,
     userEvent,
     variantInfo,
+    previewMode,
   ]);
 
   const value = useMemo(

package/src/contexts/pageContext/types.ts

@@ -1,5 +1,4 @@
-import { UserEvent } from '@spiffy-ai/commerce-api-client';
-import { VariantTypeEnum } from 'src/application/models';
+import { UserEvent, VariantTypeEnum } from 'src/application/models';
 
 export type PDPPageVariantInfo = {
   variantType: VariantTypeEnum.Pdp;

package/src/contexts/salesAgentContext/chatAPI.ts

@@ -9,6 +9,7 @@ import { queueUserEventAtom } from 'src/atoms/chat/messageQueue';
 
 export interface SalesAgentChatAPI {
   logPageVisit: ({ pageVisitCategory }: { pageVisitCategory: PageVisitCategory }) => void;
+  logUserEvent: (event: UserEvent) => void;
   onSuggestionClicked: (suggestion: Suggestion) => void;
   onTypedMessageSubmitted: ({ query }: { query: string }) => void;
   onFormResponseSubmitted: (formResponse: any) => void; // TODO: Figure out the right type
@@ -34,6 +35,13 @@ export const useSalesAgentChatAPI = () => {
     },
     [queueUserEvent],
   );
+
+  const logUserEvent = useCallback(
+    (event: UserEvent) => {
+      queueUserEvent(event);
+    },
+    [queueUserEvent],
+  );
   const onSuggestionClicked = useCallback(
     (suggestion: Suggestion) => {
       const event: UserEvent = {
@@ -69,6 +77,7 @@ export const useSalesAgentChatAPI = () => {
 
   return {
     logPageVisit,
+    logUserEvent,
     onSuggestionClicked,
     onTypedMessageSubmitted,
     onFormResponseSubmitted,