@envive-ai/react-hooks 0.3.10 → 0.3.12

package/src/contexts/salesAgentContext/chatAPI.ts

@@ -1,5 +1,5 @@
 // This component will interact with the backend API to get the responses from the sales agent.
-
+import Logger from 'src/application/logging/logger';
 import { PageVisitCategory, UserEventCategory } from '@spiffy-ai/commerce-api-client';
 import {
   ChatElementDisplayLocationV3,
@@ -9,13 +9,21 @@ import {
   Suggestion,
   UserEvent,
 } from 'src/application/models';
-import { useSetAtom } from 'jotai';
+import { useAtomValue, useSetAtom } from 'jotai';
 import { useCallback } from 'react';
 import { v4 as uuid } from 'uuid';
 import { formSubmitAtom, replyEventCategoryAtom } from 'src/atoms/chat';
 import { queueUserEventAtom } from 'src/atoms/chat/messageQueue';
+import { EnviveMetricsEventName } from 'src/services/amplitudeService/amplitudeService';
+import { analyticsContextAtom } from 'src/atoms/app/variant';
+import { hasParsedVariantInfoAtom } from 'src/atoms/app';
 import { SpiffyMetricsEventName, useAmplitude } from '../amplitudeContext';
 
+const TRACKED_USER_EVENTS = [
+  UserEventCategory.PageVisit,
+  UserEventCategory.PdpVisit,
+  UserEventCategory.PlpVisit,
+];
 export interface SalesAgentChatAPI {
   logPageVisit: ({ pageVisitCategory }: { pageVisitCategory: PageVisitCategory }) => void;
   logUserEvent: (event: UserEvent) => void;
@@ -23,13 +31,23 @@ export interface SalesAgentChatAPI {
     suggestion: Suggestion,
     displayLocation: ChatElementDisplayLocationV3,
   ) => void;
-  onTypedMessageSubmitted: ({ query, userTyped }: { query: string; userTyped: boolean }) => void;
-  onFormResponseSubmitted: (formResponse: FormSubmittedAttributes) => void;
+  onTypedMessageSubmitted: ({
+    query,
+    userTyped,
+    displayLocation,
+  }: {
+    query: string;
+    userTyped: boolean;
+    displayLocation: ChatElementDisplayLocationV3;
+  }) => void;
+  onFormResponseSubmitted: (form: FormSubmittedAttributes) => void;
 }
 
 export const useSalesAgentChatAPI = () => {
   // TODO: Each of these functions will trigger both the necessary amplitude events and initiate the
   // necessary actions to trigger the backend API
+  const context = useAtomValue(analyticsContextAtom);
+  const hasParsedVariantInfo = useAtomValue(hasParsedVariantInfoAtom);
   const queueUserEvent = useSetAtom(queueUserEventAtom);
   const setReplyEventCategory = useSetAtom(replyEventCategoryAtom);
   const setFormSubmit = useSetAtom(formSubmitAtom);
@@ -37,8 +55,17 @@ export const useSalesAgentChatAPI = () => {
 
   const logPageVisit = useCallback(
     ({ pageVisitCategory }: { pageVisitCategory: PageVisitCategory }) => {
+      const eventId = uuid();
+      trackEvent({
+        eventName: EnviveMetricsEventName.ChatRequest,
+        eventProps: {
+          ...context,
+          'chat.request_id': eventId,
+          'chat.request_type': 'page_visit',
+        },
+      });
       const event: UserEvent = {
-        eventId: uuid(),
+        eventId,
         category: UserEventCategory.PageVisit,
         createdAt: new Date().toISOString(),
         attributes: {
@@ -48,14 +75,32 @@ export const useSalesAgentChatAPI = () => {
       };
       queueUserEvent(event);
     },
-    [queueUserEvent],
+    [queueUserEvent, context, trackEvent],
   );
 
   const logUserEvent = useCallback(
     (event: UserEvent) => {
+      if (!hasParsedVariantInfo) {
+        Logger.logWarn(
+          '[envive-ai] hasParsedVariantInfo is false, not logging user event',
+          undefined,
+          { event },
+        );
+        return;
+      }
+      if (TRACKED_USER_EVENTS.includes(event.category)) {
+        trackEvent({
+          eventName: EnviveMetricsEventName.ChatRequest,
+          eventProps: {
+            ...context,
+            'chat.request_id': event.eventId,
+            'chat.request_type': 'page_visit',
+          },
+        });
+      }
       queueUserEvent(event);
     },
-    [queueUserEvent],
+    [context, hasParsedVariantInfo, queueUserEvent, trackEvent],
   );
   const onSuggestionClicked = useCallback(
     (suggestion: Suggestion, displayLocation: ChatElementDisplayLocationV3) => {
@@ -74,8 +119,24 @@ export const useSalesAgentChatAPI = () => {
           },
         },
       });
+      const eventId = uuid();
+      trackEvent({
+        eventName: EnviveMetricsEventName.ChatRequest,
+        eventProps: {
+          ...context,
+          'trigger.widget': displayLocation, // This is fairly finegrained, but that may be ok
+          'chat.request_id': eventId,
+          'chat.request_type': 'suggestion',
+          'chat.request_text': suggestion.content,
+          'chat.suggestion_id': suggestion.id,
+          'chat.suggestion_category': suggestion.category,
+          'chat.suggestion_created_at': suggestion.createdAt,
+          'chat.suggestion_is_answer': suggestion.isAnswer,
+          'chat.user_typed': false,
+        },
+      });
       const event: UserEvent = {
-        eventId: uuid(),
+        eventId,
         category: UserEventCategory.SuggestionClicked,
         createdAt: new Date().toISOString(),
         attributes: {
@@ -85,10 +146,18 @@ export const useSalesAgentChatAPI = () => {
       };
       queueUserEvent(event);
     },
-    [queueUserEvent, trackEvent],
+    [queueUserEvent, trackEvent, context],
   );
   const onTypedMessageSubmitted = useCallback(
-    ({ query, userTyped }: { query: string; userTyped: boolean }) => {
+    ({
+      query,
+      userTyped,
+      displayLocation,
+    }: {
+      query: string;
+      userTyped: boolean;
+      displayLocation: ChatElementDisplayLocationV3;
+    }) => {
       const eventId = uuid();
       trackEvent({
         eventName: SpiffyMetricsEventName.ChatUserMessageInput,
@@ -105,6 +174,18 @@ export const useSalesAgentChatAPI = () => {
           },
         },
       });
+      trackEvent({
+        eventName: EnviveMetricsEventName.ChatRequest,
+        eventProps: {
+          ...context,
+          'trigger.widget': displayLocation,
+          'chat.request_type': 'text',
+          'chat.request_text': query,
+          'chat.request_id': eventId,
+          'chat.request_created_at': new Date().toISOString(),
+          'chat.user_typed': userTyped,
+        },
+      });
       const event: UserEvent = {
         eventId,
         category: UserEventCategory.QueryTyped,
@@ -116,21 +197,32 @@ export const useSalesAgentChatAPI = () => {
       };
       queueUserEvent(event);
     },
-    [queueUserEvent, trackEvent],
+    [queueUserEvent, trackEvent, context],
   );
   const onFormResponseSubmitted = useCallback(
     (form: FormSubmittedAttributes) => {
       setReplyEventCategory(UserEventCategory.FormSubmitted);
       setFormSubmit(form);
+      const eventId = uuid();
+      trackEvent({
+        eventName: EnviveMetricsEventName.ChatRequest,
+        eventProps: {
+          ...context,
+          'chat.request_id': eventId,
+          'chat.request_type': 'form',
+          'chat.form_response_id': form.formResponseId,
+          'chat.form_type': form.formType,
+        },
+      });
       const event: UserEvent = {
-        eventId: uuid(),
+        eventId,
         category: UserEventCategory.FormSubmitted,
         createdAt: new Date().toISOString(),
         attributes: form,
       };
       queueUserEvent(event);
     },
-    [queueUserEvent, setReplyEventCategory, setFormSubmit],
+    [setReplyEventCategory, setFormSubmit, trackEvent, context, queueUserEvent],
   );
 
   return {

package/src/contexts/salesAgentContext/salesAgentService.ts

@@ -25,6 +25,8 @@ import { useMessageInterceptor } from 'src/interceptors/useMessageInterceptor';
 import { SpiffyMetricsEventName, useAmplitude } from 'src/contexts/amplitudeContext';
 import { useFeatureFlagService } from 'src/contexts/featureFlagServiceContext';
 import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
+import { EnviveMetricsEventName } from 'src/services/amplitudeService/amplitudeService';
+import { analyticsContextAtom } from 'src/atoms/app/variant';
 
 import { StatusCodeError } from './statusCodeError';
 
@@ -59,6 +61,41 @@ const inputPropsToTrackingProps = (
   return {};
 };
 
+const inputPropsToEnviveTrackingProps = (
+  payload: NextMessageRequest,
+): Record<string, unknown> | undefined => {
+  const [userEvent] = payload.userEvents || [];
+  if (userEvent.category === UserEventCategory.SuggestionClicked) {
+    return {
+      'chat.request_type': 'suggestion',
+      'chat.request_id': userEvent.eventId,
+      'chat.request_text': userEvent.attributes.content,
+      'chat.suggestion_id': userEvent.attributes.suggestionId,
+      'chat.user_typed': false,
+    };
+  }
+  if (userEvent.category === UserEventCategory.QueryTyped) {
+    return {
+      'chat.request_type': 'text',
+      'chat.request_id': userEvent.eventId,
+      'chat.request_text': userEvent.attributes.query,
+      'chat.user_typed': userEvent.attributes.userTyped,
+    };
+  }
+  if (
+    userEvent.category === UserEventCategory.PageVisit ||
+    userEvent.category === UserEventCategory.PdpVisit ||
+    userEvent.category === UserEventCategory.PlpVisit
+  ) {
+    return {
+      'chat.request_id': userEvent.eventId,
+      'chat.request_type': 'page_visit',
+    };
+  }
+
+  return {};
+};
+
 export const getQueryParam = (key: string): string | null => {
   const urlObj = new URL(window.location.href);
   return urlObj.searchParams.get(key);
@@ -137,14 +174,15 @@ const processStreamingResponse = async (
   messageInterceptor: { intercept: (response?: Response) => boolean | undefined },
   setMessages: (updater: (prev: Message[][]) => Message[][]) => void,
   setResponseStreaming: (responseStreaming: boolean) => void,
-): Promise<void> => {
+): Promise<Record<string, number>> => {
   let lastMessage: Message | undefined;
   setResponseStreaming(true);
+  const responseAnalytics: Record<string, number> = {};
 
   for await (const response of stream) {
     try {
       if (messageInterceptor.intercept(response)) {
-        return;
+        return {};
       }
 
       if (!response) {
@@ -155,6 +193,14 @@ const processStreamingResponse = async (
       if (!message) {
         throw new Error('Failed to transform API response to client message');
       }
+      if (message.type === MessageType.Product) {
+        responseAnalytics['chat.product_cards_returned'] =
+          (responseAnalytics['chat.product_cards_returned'] || 0) + 1;
+      }
+      if (message.type === MessageType.Review) {
+        responseAnalytics['chat.review_cards_returned'] =
+          (responseAnalytics['chat.review_cards_returned'] || 0) + 1;
+      }
 
       // No support for ChatSearch messages at the current time.
       // Perhaps we add support back in the future
@@ -173,6 +219,7 @@ const processStreamingResponse = async (
     }
     setResponseStreaming(false);
   }
+  return responseAnalytics;
 };
 
 export const useSalesAgentService: () => SalesAgentService = () => {
@@ -181,6 +228,7 @@ export const useSalesAgentService: () => SalesAgentService = () => {
   const setSuggestions = useSetAtom(suggestionsAtom);
   const setPendingResponse = useSetAtom(pendingResponseAtom);
   const setResponseStreaming = useSetAtom(responseStreamingAtom);
+  const analyticsContext = useAtomValue(analyticsContextAtom);
   const messageInterceptor = useMessageInterceptor();
   const { trackEvent } = useAmplitude();
 
@@ -220,12 +268,13 @@ export const useSalesAgentService: () => SalesAgentService = () => {
       const startTime = Date.now();
       let successfulResponse: boolean | undefined;
       setPendingResponse(true);
+      setSuggestions([]);
       const stream = CommerceApiClient.getNextResponseStreaming(payload);
-
+      let responseAnalytics: Record<string, unknown> | undefined;
       try {
         setRequestFailure(false);
 
-        await processStreamingResponse(
+        responseAnalytics = await processStreamingResponse(
           stream,
           messageInterceptor,
           setMessages,
@@ -274,14 +323,27 @@ export const useSalesAgentService: () => SalesAgentService = () => {
             ...inputPropsToTrackingProps(payload),
           },
         });
+        trackEvent({
+          eventName: EnviveMetricsEventName.ChatResponse,
+          eventProps: {
+            ...analyticsContext,
+            'chat.response_time_ms': responseTime.toString(),
+            ...inputPropsToEnviveTrackingProps(payload),
+            ...responseAnalytics,
+          },
+        });
         setPendingResponse(false);
         setResponseStreaming(false);
         // logPerfMetric(PerfMetricsEvents.FirstResponseCompleted);
       }
     },
     [
+      analyticsContext,
+      trackEvent,
+      setResponseStreaming,
       // logPerfMetric,
       setRequestFailure,
+      setSuggestions,
       messageInterceptor,
       setMessages,
       setPendingResponse,

package/src/contexts/types.ts

@@ -13,7 +13,8 @@ import { ChatState } from 'src/types/custservice-types';
 import { SuggestionBarLocationForMetrics } from 'src/types/suggestionBarV2-types';
 import { TestProps } from 'src/types/test-types';
 import { OrgConfigFeatureGate } from 'src/application/models/api/orgConfigResults';
-import { WidgetConfigV3 } from './typesV3';
+import { WidgetConfigV3, WidgetTypeV3 } from './typesV3';
+import type { HardcopyResponse } from './hardcopyContext/hardcopyContext';
 
 type ShowFloatingButtonOptions =
   | 'always'
@@ -863,6 +864,7 @@ type PageVariantBase = {
   variantId: string;
   widgetMounting: WidgetMounting[];
   variantTests: PageVariantTest[];
+  floatingButtonOverride?: ShowFloatingButtonOptions;
 };
 
 type PLPPageVariant = PageVariantBase & {
@@ -892,13 +894,18 @@ type SearchPageVariant = PageVariantBase & {
   variantType: 'search';
 };
 
+type FullPageSalesAgentVariant = PageVariantBase & {
+  variantType: 'full_page';
+};
+
 export type PageVariantConfig =
   | PLPPageVariant
   | PDPPageVariant
   | VisitPageVariant
   | OtherPageVariant
   | HomePageVariant
-  | SearchPageVariant;
+  | SearchPageVariant
+  | FullPageSalesAgentVariant;
 
 export type OrgPageConfig = {
   // pageVariants is a list of page variants that we support.
@@ -928,8 +935,10 @@ export interface EnviveConfig {
   variantUrlOverride?: string;
   variantInfoOverride?: any;
   show?: boolean;
+  enviveOn?: boolean;
   publicKey?: string;
   featureGates?: OrgConfigFeatureGate[];
+  hardcopyOverride?: Partial<Record<WidgetTypeV3, HardcopyResponse>>;
 }
 
 export type {

package/src/contexts/typesV3.ts

@@ -1,11 +1,11 @@
-import { AnimationSpeed, PromptCarouselRows } from '@envive-ai/react-toolkit-v3/PromptCarousel';
+import { FloatingButtonLocation } from '@envive-ai/react-toolkit-v3/FloatingButton';
 import { ImageGalleryImage, ImageGalleryLayout } from '@envive-ai/react-toolkit-v3/ImageGallery';
 import { PromptButtonVariant } from '@envive-ai/react-toolkit-v3/PromptButton';
-import { WidgetWrapperVariant } from '@envive-ai/react-toolkit-v3/WidgetWrapper';
-import { Theme } from '@envive-ai/react-toolkit-v3/Tokens';
+import { AnimationSpeed, PromptCarouselRows } from '@envive-ai/react-toolkit-v3/PromptCarousel';
 import { DynamicLayout, WidgetKind } from '@envive-ai/react-toolkit-v3/SocialProof';
+import { Theme } from '@envive-ai/react-toolkit-v3/Tokens';
 import { SparkleIconColor } from '@envive-ai/react-toolkit-v3/WelcomeMessage';
-import { FloatingButtonLocation } from '@envive-ai/react-toolkit-v3/FloatingButton';
+import { WidgetWrapperVariant } from '@envive-ai/react-toolkit-v3/WidgetWrapper';
 import { ColorNames } from '../application/models/colorsConfigV3';
 import { CustomerServiceType } from '../types/customerService';
 import type { SearchConfig } from './types';
@@ -184,6 +184,23 @@ type FloatingButtonConfig = {
   style: Style;
 };
 
+export type ReferrerPopupTrigger = {
+  type: 'referrer';
+  referrers: string[];
+};
+
+export type AutomaticPopupTrigger = {
+  type: 'automatic';
+};
+export type PopupTrigger = ReferrerPopupTrigger | AutomaticPopupTrigger;
+export type AutoPopupTrigger = {
+  delay: number;
+  trigger: PopupTrigger;
+};
+export interface AutoPopupConfig {
+  triggers: AutoPopupTrigger[];
+}
+
 type FloatingChatConfig = {
   headerBackgroundColor?: string;
   headerMode: Mode;
@@ -196,6 +213,7 @@ type FloatingChatConfig = {
   welcomeMessageTitle: string;
   welcomeMessageText: string;
   chatFooterTextFieldPlaceholderText: string;
+  autoPopupConfig?: AutoPopupConfig;
 };
 
 type CustomerServiceIntegration = {
@@ -246,6 +264,7 @@ export enum WidgetTypeV3 {
   FloatingChatV3 = 'FloatingChatV3',
   FloatingButtonV3 = 'FloatingButtonV3',
   ProductCardV3 = 'ProductCardV3',
+  FullPageSalesAgentV3 = 'FullPageSalesAgentV3',
 }
 
 interface BaseWidgetConfig<T extends WidgetTypeV3> {
@@ -324,6 +343,11 @@ interface ProductCardWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.Produc
   imageSrc?: string;
 }
 
+interface FullPageSalesAgentWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.FullPageSalesAgentV3> {
+  headerContainer?: string;
+  autoHeight?: boolean;
+}
+
 type WidgetConfigV3 =
   | PromptCarouselWidgetV3Config
   | SocialProofWidgetV3Config
@@ -334,24 +358,26 @@ type WidgetConfigV3 =
   | ChatPreviewWidgetV3Config
   | PromptButtonCarouselWithImageWidgetV3Config
   | FloatingChatWidgetV3Config
-  | ProductCardWidgetV3Config;
+  | ProductCardWidgetV3Config
+  | FullPageSalesAgentWidgetV3Config;
 
 export type {
-  OrgUIConfigV3,
-  WidgetConfigV3,
-  LookAndFeelConfig,
-  SocialProofWidgetV3Config,
-  PromptCarouselWidgetV3Config,
   ChatPreviewComparisonWidgetV3Config,
   ChatPreviewLoadingWidgetV3Config,
   ChatPreviewWidgetV3Config,
-  TitledPromptCarouselWidgetV3Config,
-  TypingAnimationWidgetV3Config,
-  PromptButtonCarouselWithImageWidgetV3Config,
+  CustomerServiceIntegration,
+  FloatingButtonConfig,
+  FloatingChatConfig,
   FloatingChatWidgetV3Config,
+  FullPageSalesAgentWidgetV3Config,
+  LookAndFeelConfig,
+  OrgUIConfigV3,
   ProductCardWidgetV3Config,
-  FloatingChatConfig,
-  FloatingButtonConfig,
-  CustomerServiceIntegration,
+  PromptButtonCarouselWithImageWidgetV3Config,
+  PromptCarouselWidgetV3Config,
+  SocialProofWidgetV3Config,
   SPASettings,
+  TitledPromptCarouselWidgetV3Config,
+  TypingAnimationWidgetV3Config,
+  WidgetConfigV3,
 };

package/src/services/amplitudeService/__tests__/amplitudeService.test.ts

@@ -66,6 +66,23 @@ describe('AmplitudeService', () => {
     mockAdd.mockClear();
     mockDigest.mockResolvedValue(new Uint8Array(32).fill(0));
     mockDispatch.mockClear();
+
+    // Mock window.location for tests that need it
+    Object.defineProperty(global, 'window', {
+      value: {
+        location: {
+          href: 'https://test.example.com',
+        },
+        localStorage: {
+          getItem: vi.fn(),
+        },
+        performance: {
+          now: vi.fn(() => Date.now()),
+        },
+      },
+      writable: true,
+      configurable: true,
+    });
   });
 
   const createService = (overrides?: Partial<AmplitudeServiceConfig>) => {
@@ -76,6 +93,7 @@ describe('AmplitudeService', () => {
       env: 'test',
       orgId: 'test-org-id',
       show: true,
+      enviveOn: true,
       contextSource: 'app',
       orgShortName: 'test-org',
       featureFlagService,
@@ -108,6 +126,7 @@ describe('AmplitudeService', () => {
         env: 'test',
         orgId: 'test-org-id',
         show: true,
+        enviveOn: true,
         getLocalStorageItem: mockGetLocalStorageItem,
         contextSource: 'app',
         orgShortName: 'test-org',
@@ -125,6 +144,7 @@ describe('AmplitudeService', () => {
         env: 'test',
         orgId: 'test-org-id',
         show: true,
+        enviveOn: true,
         getLocalStorageItem: mockGetLocalStorageItem,
         contextSource: 'app',
         orgShortName: 'test-org',
@@ -142,6 +162,7 @@ describe('AmplitudeService', () => {
         env: 'test',
         orgId: 'test-org-id',
         show: true,
+        enviveOn: true,
         getLocalStorageItem: mockGetLocalStorageItem,
         contextSource: 'app',
         orgShortName: 'test-org',
@@ -209,6 +230,7 @@ describe('AmplitudeService', () => {
         eventProps: { message: 'test', count: 5 },
       });
 
+      expect(mockTrack).toHaveBeenCalled();
       const callArgs = mockTrack.mock.calls[0];
       const eventProps = callArgs[1];
 
@@ -238,6 +260,7 @@ describe('AmplitudeService', () => {
         eventGroups: { group1: 'value1', group2: 'value2' },
       });
 
+      expect(mockTrack).toHaveBeenCalled();
       const callArgs = mockTrack.mock.calls[0];
       expect(callArgs[2]).toHaveProperty('group1', 'value1');
       expect(callArgs[2]).toHaveProperty('group2', 'value2');
@@ -251,6 +274,7 @@ describe('AmplitudeService', () => {
         env: 'test',
         orgId: 'test-org-id',
         show: true,
+        enviveOn: true,
         getLocalStorageItem: mockGetLocalStorageItem,
         contextSource: 'app',
         orgShortName: 'test-org',
@@ -304,6 +328,15 @@ describe('AmplitudeService', () => {
       const dataLayer: any[] = [];
       Object.defineProperty(global, 'window', {
         value: {
+          location: {
+            href: 'https://test.example.com',
+          },
+          localStorage: {
+            getItem: vi.fn(),
+          },
+          performance: {
+            now: vi.fn(() => Date.now()),
+          },
           dataLayer,
         },
         writable: true,
@@ -391,6 +424,7 @@ describe('AmplitudeService', () => {
         env: 'test',
         orgId: 'test-org-id',
         show: true,
+        enviveOn: true,
         getLocalStorageItem: null,
         contextSource: 'app',
         orgShortName: 'test-org',
@@ -408,7 +442,13 @@ describe('AmplitudeService', () => {
       };
       Object.defineProperty(global, 'window', {
         value: {
+          location: {
+            href: 'https://test.example.com',
+          },
           localStorage: mockLocalStorage,
+          performance: {
+            now: vi.fn(() => Date.now()),
+          },
         },
         writable: true,
         configurable: true,
@@ -418,7 +458,9 @@ describe('AmplitudeService', () => {
         eventName: SpiffyMetricsEventName.ChatUserMessageInput,
       });
 
+      // Check that getItem was called with ChatId (may be called with other keys too)
       expect(mockLocalStorage.getItem).toHaveBeenCalledWith(LocalStorageKeys.ChatId);
+      expect(mockTrack).toHaveBeenCalled();
       const callArgs = mockTrack.mock.calls[0];
       expect(callArgs[1]).toHaveProperty('chat_id', 'window-chat-id');
     });
@@ -448,6 +490,7 @@ describe('AmplitudeService', () => {
         eventName: SpiffyMetricsEventName.ChatUserMessageInput,
       });
 
+      expect(mockTrack).toHaveBeenCalled();
       const callArgs = mockTrack.mock.calls[0];
       const eventProps = callArgs[1];
       expect(eventProps).toHaveProperty('test', 'value');
@@ -456,6 +499,23 @@ describe('AmplitudeService', () => {
 
   describe('Event enrichment', () => {
     it('should enrich Page Viewed events', async () => {
+      // Ensure window.location is properly mocked
+      Object.defineProperty(global, 'window', {
+        value: {
+          location: {
+            href: 'https://test.example.com',
+          },
+          localStorage: {
+            getItem: vi.fn(),
+          },
+          performance: {
+            now: vi.fn(() => Date.now()),
+          },
+        },
+        writable: true,
+        configurable: true,
+      });
+
       createService({
         show: true,
       });
@@ -487,6 +547,23 @@ describe('AmplitudeService', () => {
     });
 
     it('should enrich Bundle Loaded events', async () => {
+      // Ensure window.location is properly mocked
+      Object.defineProperty(global, 'window', {
+        value: {
+          location: {
+            href: 'https://test.example.com',
+          },
+          localStorage: {
+            getItem: vi.fn(),
+          },
+          performance: {
+            now: vi.fn(() => Date.now()),
+          },
+        },
+        writable: true,
+        configurable: true,
+      });
+
       createService();
 
       const enrichmentCall = mockAdd.mock.calls[0];
@@ -541,6 +618,9 @@ describe('AmplitudeService', () => {
     it('should track multiple events with correct userId', async () => {
       const service = createService();
 
+      // Ensure the service is ready
+      expect(service.isReady).toBe(true);
+
       await service.trackEvent({
         eventName: SpiffyMetricsEventName.ChatUserMessageInput,
         eventProps: { event1: true },