@envive-ai/react-hooks 0.3.21 → 0.3.22

package/dist/services/amplitudeService/amplitudeService.js

@@ -17,6 +17,9 @@ var AmplitudeService = class AmplitudeService {
 		this.config = config;
 		this.initialize();
 	}
+	get isMockApiKey() {
+		return this.config.amplitudeApiKey === "mock-amplitude-key";
+	}
 	get isReady() {
 		return Boolean(this.config.userId && this.config.featureFlagService && this.config.amplitudeApiKey && this.amplitudeClient);
 	}
@@ -126,6 +129,10 @@ var AmplitudeService = class AmplitudeService {
 			});
 			return;
 		}
+		if (this.isMockApiKey) {
+			logger.logWarn("Mock API key detected — running in mock mode, no events will be sent to Amplitude.", this.config.amplitudeApiKey);
+			return;
+		}
 		if (!this.amplitudeClient) {
 			const currentAmplitudeInstance = createInstance();
 			currentAmplitudeInstance.add(this.getEventTrackingEnrichment());
@@ -211,6 +218,7 @@ var AmplitudeService = class AmplitudeService {
 		return `[Spiffy] ${eventName}`;
 	}
 	async trackEvent({ eventName, eventProps, eventGroups, alsoSendToGoogleAnalytics = false }) {
+		if (this.isMockApiKey) return;
 		logger.logDebug("Submitting event", eventName);
 		try {
 			const decoratedEventName = AmplitudeService.decorateEventName(eventName);
@@ -267,4 +275,4 @@ var AmplitudeService = class AmplitudeService {
 
 //#endregion
 export { AmplitudeService };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"amplitudeService.js","names":["Logger","enrichment: EnrichmentPlugin","enrichedEvent: Event","globalProperties: Record<string, string>","currentAmplitudeInstance: BrowserClient"],"sources":["../../../src/services/amplitudeService/amplitudeService.ts"],"sourcesContent":["import { createInstance } from '@amplitude/analytics-browser';\nimport { EventsDispatcher, SpiffyEvent } from 'src/events';\nimport { LocalStorageKeys } from 'src/contexts/localStorageContext';\nimport Logger from 'src/application/logging/logger';\nimport type {\n  BrowserClient,\n  EnrichmentPlugin,\n  Event,\n  ServerZoneType,\n} from '@amplitude/analytics-types';\nimport { FeatureFlagService } from 'src/contexts/featureFlagServiceContext/featureFlagServiceContext';\nimport { WidgetTypeV3 } from 'src/contexts/typesV3';\nimport { ChatElementDisplayLocationV3 } from 'src/application/models/chatElementDisplayLocationV3';\nimport { projectToGA4 } from '../ga4ProjectionService/ga4ProjectionService';\nimport { EnviveMetricsEventName, SpiffyMetricsEventName } from './eventNames';\n\n// Re-export event names for convenience\nexport { EnviveMetricsEventName, SpiffyMetricsEventName };\n\nconst logger = new Logger('amplitudeService');\n\nexport interface TrackEventParams {\n  eventName: SpiffyMetricsEventName | EnviveMetricsEventName;\n  eventProps?: Record<string, unknown>;\n  eventGroups?: Record<string, unknown>;\n  alsoSendToGoogleAnalytics?: boolean;\n}\n\nexport interface AmplitudeServiceConfig {\n  userId: string;\n  amplitudeApiKey: string;\n  dataResidency: string;\n  env: string;\n  contextSource: string;\n  orgShortName: string;\n  orgId: string;\n  featureFlagService: FeatureFlagService;\n  orgGaConfig?: unknown;\n  show: boolean;\n  enviveOn: boolean;\n  enabledFeatures?: Record<string, boolean>;\n  getLocalStorageItem: null | ((key: string) => string | null);\n}\n\nexport class AmplitudeService {\n  private amplitudeClient: BrowserClient | undefined;\n\n  private internalEventTrackingEnrichment: EnrichmentPlugin | undefined;\n\n  private supplementalDefaultProps: Record<string, unknown> = {};\n\n  private config: AmplitudeServiceConfig;\n\n  constructor(config: AmplitudeServiceConfig) {\n    this.config = config;\n    this.initialize();\n  }\n\n  get isReady(): boolean {\n    return Boolean(\n      this.config.userId &&\n      this.config.featureFlagService &&\n      this.config.amplitudeApiKey &&\n      this.amplitudeClient,\n    );\n  }\n\n  private getLocalStorageItem(key: string): string | null {\n    if (this.config.getLocalStorageItem) {\n      return this.config.getLocalStorageItem(key);\n    }\n    if (typeof window !== 'undefined' && window.localStorage) {\n      return window.localStorage.getItem(key);\n    }\n    return null;\n  }\n\n  private getDefaultTrackingProps(\n    eventName: SpiffyMetricsEventName | EnviveMetricsEventName,\n  ): Record<string, unknown> {\n    const featureGates = Object.entries(this.config.featureFlagService.getFeatureFlags());\n    const gatesProps =\n      featureGates.length > 0\n        ? featureGates.reduce<Record<string, boolean>>((acc, [name, value]) => {\n            if (name && value != null) {\n              return { ...acc, [`feature_gate.${name}`]: value };\n            }\n            return acc;\n          }, {})\n        : {};\n    const experimentProps = {}; // No direct equivalent for experiments in EnviveConfig yet\n\n    const environmentProps = {\n      'environment.execution_context': 'bundle',\n      'environment.page_url': window.location.href,\n      'environment.envive_user_id': this.config.userId,\n      'environment.execution_environment': this.config.env || 'unknown',\n      'environment.context_source': this.config.contextSource,\n      'environment.sales_agent_enabled': this.config.enabledFeatures?.salesAgent ?? false,\n      'environment.search_enabled': this.config.enabledFeatures?.searchAgent ?? false,\n      'environment.envive_on_query_param': this.config.enviveOn,\n      'environment.window_show': this.config.show,\n      'environment.envive_enabled': this.config.enabledFeatures?.envive,\n    };\n\n    const orgLevelAmplitudeTrackingProps = AmplitudeService.isV3EnviveEvent(eventName)\n      ? {\n          ...this.config.featureFlagService.getFullFlagValues(),\n          ...experimentProps,\n          ...environmentProps,\n        }\n      : {\n          ...gatesProps,\n          ...experimentProps,\n        };\n    return {\n      ...orgLevelAmplitudeTrackingProps,\n      ...this.supplementalDefaultProps,\n      app_id: 'commerce-chat-react-component',\n      chat_id: this.getLocalStorageItem(LocalStorageKeys.ChatId),\n      env: this.config.env || 'unknown',\n      app_source: this.config.contextSource,\n      org_id: this.config.orgId,\n      'org.short_name': this.config.orgShortName,\n      'user.id': this.config.userId,\n      'cdp.user_id': null,\n      'cdp.provider': null,\n      'event.source': 'web-browser',\n      'event.type': 'user-activity',\n      'event.id': null,\n      'event.channel': 'web',\n      'event.timestamp': null,\n    };\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  private eventPropsToPrefixedEventProps(\n    eventName: SpiffyMetricsEventName | EnviveMetricsEventName,\n    eventProps: Record<string, unknown>,\n  ): Record<string, unknown> {\n    const prefix = eventName.toLowerCase().replace(/\\s+/g, '_');\n    return Object.entries(eventProps).reduce(\n      (acc, [key, value]) => {\n        acc[`${prefix}.${key}`] = value;\n        return acc;\n      },\n      {} as Record<string, unknown>,\n    );\n  }\n\n  private getEventTrackingEnrichment(): EnrichmentPlugin {\n    if (this.internalEventTrackingEnrichment !== undefined) {\n      return this.internalEventTrackingEnrichment;\n    }\n\n    const enrichment: EnrichmentPlugin = {\n      name: 'page-view-tracking-enrichment',\n      type: 'enrichment',\n      setup: async () => undefined,\n      execute: async (event: Event): Promise<Event> => {\n        let enrichedEvent: Event;\n\n        const eventsToEnrich = [\n          '[Amplitude] Page Viewed',\n          `[Spiffy] ${SpiffyMetricsEventName.BundleLoaded}`,\n        ];\n\n        if (eventsToEnrich.includes(event.event_type)) {\n          const globalProperties: Record<string, string> = {};\n\n          if (this.config.show != null) {\n            globalProperties['globalProperties.show'] = String(this.config.show);\n          }\n          globalProperties['globalProperties.env'] = String(this.config.env);\n\n          const enabledFeaturesProperties = Object.entries(\n            this.config?.enabledFeatures ?? ({} as Record<string, boolean>),\n          ).reduce<Record<string, string>>(\n            (acc, [key, value]) => ({\n              ...acc,\n              [`enabledFeatures.${key}`]: `${value}`,\n            }),\n            {},\n          );\n\n          const timingProperties = {\n            'timing.enriched_at_ms':\n              typeof window !== 'undefined' ? window.performance?.now() : undefined,\n          };\n\n          enrichedEvent = {\n            ...event,\n            event_properties: {\n              ...event.event_properties,\n              ...this.getDefaultTrackingProps(\n                event.event_type as SpiffyMetricsEventName | EnviveMetricsEventName,\n              ),\n              ...globalProperties,\n              ...enabledFeaturesProperties,\n              ...timingProperties,\n            },\n          };\n        } else {\n          enrichedEvent = event;\n        }\n\n        EventsDispatcher.dispatch(SpiffyEvent.AMPLITUDE_EVENT, enrichedEvent);\n\n        return enrichedEvent;\n      },\n    };\n    this.internalEventTrackingEnrichment = enrichment;\n    return enrichment;\n  }\n\n  private initialize(): void {\n    const isReady = Boolean(\n      this.config.userId && this.config.featureFlagService && this.config.amplitudeApiKey,\n    );\n\n    if (!isReady) {\n      logger.logDebug('AmplitudeService is not ready', {\n        isReady,\n        userId: this.config.userId,\n        hasFeatureFlagService: !!this.config.featureFlagService,\n        hasAmplitudeApiKey: !!this.config.amplitudeApiKey,\n      });\n      return;\n    }\n\n    if (!this.amplitudeClient) {\n      const currentAmplitudeInstance: BrowserClient = createInstance();\n\n      currentAmplitudeInstance.add(this.getEventTrackingEnrichment());\n      currentAmplitudeInstance.init(this.config.amplitudeApiKey, this.config.userId, {\n        serverZone: this.config.dataResidency as ServerZoneType,\n        trackingOptions: {\n          ipAddress: true,\n        },\n        autocapture: {\n          attribution: true,\n          pageViews: {\n            trackHistoryChanges: 'pathOnly',\n          },\n          sessions: false,\n          formInteractions: false,\n          fileDownloads: false,\n        },\n      });\n      this.amplitudeClient = currentAmplitudeInstance;\n    }\n  }\n\n  static mapWidgetTypeToChatComponent(widgetType: unknown): string {\n    switch (widgetType) {\n      case WidgetTypeV3.FloatingButtonV3:\n        return 'floating_button';\n      case WidgetTypeV3.ChatPreviewV3:\n      case WidgetTypeV3.SocialProofV3:\n        return 'embedded_widget';\n      case WidgetTypeV3.TitledPromptCarouselV3:\n      case WidgetTypeV3.PromptCarouselV3:\n        return 'suggestion_bar';\n      case WidgetTypeV3.ProductCardV3:\n        return 'image_prompt_card';\n      default:\n        return 'unknown';\n    }\n  }\n\n  static mapTriggerLocationToChatComponent(triggerLocation: unknown): string {\n    switch (triggerLocation) {\n      case ChatElementDisplayLocationV3.PRODUCT_CARD_PROMPT_BUTTON:\n      case ChatElementDisplayLocationV3.PRODUCT_CARD_TEXT_FIELD:\n        return 'prompt_card';\n      case ChatElementDisplayLocationV3.PROMPT_CAROUSEL:\n      case ChatElementDisplayLocationV3.TITLED_PROMPT_CAROUSEL:\n        return 'top_reviews_snippet';\n      case ChatElementDisplayLocationV3.TYPING_ANIMATION:\n      case ChatElementDisplayLocationV3.SOCIAL_PROOF_PRIMARY_BUTTON:\n      case ChatElementDisplayLocationV3.SOCIAL_PROOF_SECONDARY_BUTTON:\n      case ChatElementDisplayLocationV3.SOCIAL_PROOF_TEXT_FIELD:\n      case ChatElementDisplayLocationV3.CHAT_PREVIEW_COMPARISON_PROMPT_BUTTON:\n      case ChatElementDisplayLocationV3.CHAT_PREVIEW_COMPARISON_TEXT_FIELD:\n      case ChatElementDisplayLocationV3.CHAT_PREVIEW_PROMPT_BUTTON:\n      case ChatElementDisplayLocationV3.CHAT_PREVIEW_TEXT_FIELD:\n        return 'chat_preview';\n      case ChatElementDisplayLocationV3.FLOATING_CHAT_OVERLAY:\n      case ChatElementDisplayLocationV3.FLOATING_CHAT_CLOSE_BUTTON:\n        return 'in_chat';\n      default:\n        return triggerLocation as string;\n    }\n  }\n\n  // This allows us to map the event props to the correct format for the legacy amplitude events\n  static mapEventProps({ eventName, eventProps }: TrackEventParams): Record<string, unknown> {\n    const messageMetadata = eventProps?.message_metadata ?? {};\n    const triggerLocation =\n      messageMetadata !== null &&\n      typeof messageMetadata === 'object' &&\n      'trigger_location' in messageMetadata\n        ? messageMetadata.trigger_location\n        : undefined;\n\n    if (eventName === SpiffyMetricsEventName.ChatComponentExpanded) {\n      const mappedTriggerLoccation =\n        AmplitudeService.mapTriggerLocationToChatComponent(triggerLocation);\n      return {\n        ...eventProps,\n        message_metadata: {\n          ...messageMetadata,\n          trigger_location: mappedTriggerLoccation,\n          full_trigger_location: triggerLocation,\n        },\n      };\n    }\n\n    if (eventName === SpiffyMetricsEventName.ChatComponentVisible) {\n      const mappedWidgetType = AmplitudeService.mapWidgetTypeToChatComponent(\n        eventProps?.widget_type,\n      );\n      const mappedTriggerLoccation =\n        AmplitudeService.mapTriggerLocationToChatComponent(triggerLocation);\n      return {\n        ...eventProps,\n        message_metadata: {\n          ...messageMetadata,\n          trigger_location: mappedTriggerLoccation,\n          full_trigger_location: triggerLocation,\n        },\n        chat_component: mappedWidgetType,\n        'chat.component_visible': true,\n      };\n    }\n    return eventProps ?? {};\n  }\n\n  static isV3EnviveEvent(eventName: SpiffyMetricsEventName | EnviveMetricsEventName): boolean {\n    return Object.values(EnviveMetricsEventName).includes(eventName as EnviveMetricsEventName);\n  }\n\n  static decorateEventName(eventName: SpiffyMetricsEventName | EnviveMetricsEventName): string {\n    if (AmplitudeService.isV3EnviveEvent(eventName)) {\n      return `[Envive] ${eventName}`;\n    }\n    return `[Spiffy] ${eventName}`;\n  }\n\n  async trackEvent({\n    eventName,\n    eventProps,\n    eventGroups,\n    alsoSendToGoogleAnalytics = false,\n  }: TrackEventParams): Promise<void> {\n    logger.logDebug('Submitting event', eventName);\n    try {\n      const decoratedEventName = AmplitudeService.decorateEventName(eventName);\n\n      if (!this.amplitudeClient) {\n        logger.logWarn('amplitude client undefined', undefined, {\n          event_name: decoratedEventName,\n        });\n        return;\n      }\n\n      const mappedEventProps = AmplitudeService.mapEventProps({ eventName, eventProps });\n\n      const eventData = JSON.stringify({\n        eventName,\n        eventProps: mappedEventProps,\n        created_at: new Date().toISOString(),\n      });\n      const encoder = new TextEncoder();\n      const data = encoder.encode(eventData);\n      // calculate a hash of the event properties to use as the insert_id so that duplicate events\n      // are automatically dropped by Amplitude\n      const hashBuffer = await crypto.subtle.digest('SHA-256', data);\n      const hashArray = Array.from(new Uint8Array(hashBuffer));\n      const currentInsertId = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');\n\n      logger.logDebug(`amplitude tracking ${decoratedEventName}`, null, {\n        event_name: decoratedEventName,\n        props: mappedEventProps,\n      });\n\n      this.amplitudeClient.track(\n        decoratedEventName,\n        {\n          ...this.getDefaultTrackingProps(eventName),\n          ...mappedEventProps,\n          ...(mappedEventProps\n            ? this.eventPropsToPrefixedEventProps(eventName, mappedEventProps)\n            : {}),\n        },\n        {\n          ...eventGroups,\n          insert_id: currentInsertId,\n        },\n      );\n\n      if (AmplitudeService.isV3EnviveEvent(eventName) && this.config.orgGaConfig) {\n        const mergedPropsForGA4 = {\n          ...this.getDefaultTrackingProps(eventName),\n          ...mappedEventProps,\n        };\n        projectToGA4(eventName as EnviveMetricsEventName, mergedPropsForGA4);\n      } else if (alsoSendToGoogleAnalytics && this.config.orgGaConfig) {\n        logger.logDebug('GA tracking', decoratedEventName);\n        if (typeof window !== 'undefined' && window.dataLayer) {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          (window.dataLayer as any[]).push({\n            event: decoratedEventName,\n            eventProps,\n          });\n        }\n      }\n    } catch (err) {\n      logger.logError('Error tracking event', err, {\n        eventName,\n        eventProps,\n      });\n    }\n  }\n\n  // Ensure that supplemental default props are merged with the existing props\n  setSupplementalDefaultProps(props: Record<string, unknown>): void {\n    this.supplementalDefaultProps = props;\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"amplitudeService.js","names":["Logger","enrichment: EnrichmentPlugin","enrichedEvent: Event","globalProperties: Record<string, string>","currentAmplitudeInstance: BrowserClient"],"sources":["../../../src/services/amplitudeService/amplitudeService.ts"],"sourcesContent":["import { createInstance } from '@amplitude/analytics-browser';\nimport { EventsDispatcher, SpiffyEvent } from 'src/events';\nimport { LocalStorageKeys } from 'src/contexts/localStorageContext';\nimport Logger from 'src/application/logging/logger';\nimport type {\n  BrowserClient,\n  EnrichmentPlugin,\n  Event,\n  ServerZoneType,\n} from '@amplitude/analytics-types';\nimport { FeatureFlagService } from 'src/contexts/featureFlagServiceContext/featureFlagServiceContext';\nimport { WidgetTypeV3 } from 'src/contexts/typesV3';\nimport { ChatElementDisplayLocationV3 } from 'src/application/models/chatElementDisplayLocationV3';\nimport { projectToGA4 } from '../ga4ProjectionService/ga4ProjectionService';\nimport { EnviveMetricsEventName, SpiffyMetricsEventName } from './eventNames';\n\n// Re-export event names for convenience\nexport { EnviveMetricsEventName, SpiffyMetricsEventName };\n\nconst logger = new Logger('amplitudeService');\n\nexport interface TrackEventParams {\n  eventName: SpiffyMetricsEventName | EnviveMetricsEventName;\n  eventProps?: Record<string, unknown>;\n  eventGroups?: Record<string, unknown>;\n  alsoSendToGoogleAnalytics?: boolean;\n}\n\nexport interface AmplitudeServiceConfig {\n  userId: string;\n  amplitudeApiKey: string;\n  dataResidency: string;\n  env: string;\n  contextSource: string;\n  orgShortName: string;\n  orgId: string;\n  featureFlagService: FeatureFlagService;\n  orgGaConfig?: unknown;\n  show: boolean;\n  enviveOn: boolean;\n  enabledFeatures?: Record<string, boolean>;\n  getLocalStorageItem: null | ((key: string) => string | null);\n}\n\nexport class AmplitudeService {\n  private amplitudeClient: BrowserClient | undefined;\n\n  private internalEventTrackingEnrichment: EnrichmentPlugin | undefined;\n\n  private supplementalDefaultProps: Record<string, unknown> = {};\n\n  private config: AmplitudeServiceConfig;\n\n  constructor(config: AmplitudeServiceConfig) {\n    this.config = config;\n    this.initialize();\n  }\n\n  get isMockApiKey(): boolean {\n    return this.config.amplitudeApiKey === 'mock-amplitude-key';\n  }\n\n  get isReady(): boolean {\n    return Boolean(\n      this.config.userId &&\n      this.config.featureFlagService &&\n      this.config.amplitudeApiKey &&\n      this.amplitudeClient,\n    );\n  }\n\n  private getLocalStorageItem(key: string): string | null {\n    if (this.config.getLocalStorageItem) {\n      return this.config.getLocalStorageItem(key);\n    }\n    if (typeof window !== 'undefined' && window.localStorage) {\n      return window.localStorage.getItem(key);\n    }\n    return null;\n  }\n\n  private getDefaultTrackingProps(\n    eventName: SpiffyMetricsEventName | EnviveMetricsEventName,\n  ): Record<string, unknown> {\n    const featureGates = Object.entries(this.config.featureFlagService.getFeatureFlags());\n    const gatesProps =\n      featureGates.length > 0\n        ? featureGates.reduce<Record<string, boolean>>((acc, [name, value]) => {\n            if (name && value != null) {\n              return { ...acc, [`feature_gate.${name}`]: value };\n            }\n            return acc;\n          }, {})\n        : {};\n    const experimentProps = {}; // No direct equivalent for experiments in EnviveConfig yet\n\n    const environmentProps = {\n      'environment.execution_context': 'bundle',\n      'environment.page_url': window.location.href,\n      'environment.envive_user_id': this.config.userId,\n      'environment.execution_environment': this.config.env || 'unknown',\n      'environment.context_source': this.config.contextSource,\n      'environment.sales_agent_enabled': this.config.enabledFeatures?.salesAgent ?? false,\n      'environment.search_enabled': this.config.enabledFeatures?.searchAgent ?? false,\n      'environment.envive_on_query_param': this.config.enviveOn,\n      'environment.window_show': this.config.show,\n      'environment.envive_enabled': this.config.enabledFeatures?.envive,\n    };\n\n    const orgLevelAmplitudeTrackingProps = AmplitudeService.isV3EnviveEvent(eventName)\n      ? {\n          ...this.config.featureFlagService.getFullFlagValues(),\n          ...experimentProps,\n          ...environmentProps,\n        }\n      : {\n          ...gatesProps,\n          ...experimentProps,\n        };\n    return {\n      ...orgLevelAmplitudeTrackingProps,\n      ...this.supplementalDefaultProps,\n      app_id: 'commerce-chat-react-component',\n      chat_id: this.getLocalStorageItem(LocalStorageKeys.ChatId),\n      env: this.config.env || 'unknown',\n      app_source: this.config.contextSource,\n      org_id: this.config.orgId,\n      'org.short_name': this.config.orgShortName,\n      'user.id': this.config.userId,\n      'cdp.user_id': null,\n      'cdp.provider': null,\n      'event.source': 'web-browser',\n      'event.type': 'user-activity',\n      'event.id': null,\n      'event.channel': 'web',\n      'event.timestamp': null,\n    };\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  private eventPropsToPrefixedEventProps(\n    eventName: SpiffyMetricsEventName | EnviveMetricsEventName,\n    eventProps: Record<string, unknown>,\n  ): Record<string, unknown> {\n    const prefix = eventName.toLowerCase().replace(/\\s+/g, '_');\n    return Object.entries(eventProps).reduce(\n      (acc, [key, value]) => {\n        acc[`${prefix}.${key}`] = value;\n        return acc;\n      },\n      {} as Record<string, unknown>,\n    );\n  }\n\n  private getEventTrackingEnrichment(): EnrichmentPlugin {\n    if (this.internalEventTrackingEnrichment !== undefined) {\n      return this.internalEventTrackingEnrichment;\n    }\n\n    const enrichment: EnrichmentPlugin = {\n      name: 'page-view-tracking-enrichment',\n      type: 'enrichment',\n      setup: async () => undefined,\n      execute: async (event: Event): Promise<Event> => {\n        let enrichedEvent: Event;\n\n        const eventsToEnrich = [\n          '[Amplitude] Page Viewed',\n          `[Spiffy] ${SpiffyMetricsEventName.BundleLoaded}`,\n        ];\n\n        if (eventsToEnrich.includes(event.event_type)) {\n          const globalProperties: Record<string, string> = {};\n\n          if (this.config.show != null) {\n            globalProperties['globalProperties.show'] = String(this.config.show);\n          }\n          globalProperties['globalProperties.env'] = String(this.config.env);\n\n          const enabledFeaturesProperties = Object.entries(\n            this.config?.enabledFeatures ?? ({} as Record<string, boolean>),\n          ).reduce<Record<string, string>>(\n            (acc, [key, value]) => ({\n              ...acc,\n              [`enabledFeatures.${key}`]: `${value}`,\n            }),\n            {},\n          );\n\n          const timingProperties = {\n            'timing.enriched_at_ms':\n              typeof window !== 'undefined' ? window.performance?.now() : undefined,\n          };\n\n          enrichedEvent = {\n            ...event,\n            event_properties: {\n              ...event.event_properties,\n              ...this.getDefaultTrackingProps(\n                event.event_type as SpiffyMetricsEventName | EnviveMetricsEventName,\n              ),\n              ...globalProperties,\n              ...enabledFeaturesProperties,\n              ...timingProperties,\n            },\n          };\n        } else {\n          enrichedEvent = event;\n        }\n\n        EventsDispatcher.dispatch(SpiffyEvent.AMPLITUDE_EVENT, enrichedEvent);\n\n        return enrichedEvent;\n      },\n    };\n    this.internalEventTrackingEnrichment = enrichment;\n    return enrichment;\n  }\n\n  private initialize(): void {\n    const isReady = Boolean(\n      this.config.userId && this.config.featureFlagService && this.config.amplitudeApiKey,\n    );\n\n    if (!isReady) {\n      logger.logDebug('AmplitudeService is not ready', {\n        isReady,\n        userId: this.config.userId,\n        hasFeatureFlagService: !!this.config.featureFlagService,\n        hasAmplitudeApiKey: !!this.config.amplitudeApiKey,\n      });\n      return;\n    }\n\n    if (this.isMockApiKey) {\n      logger.logWarn(\n        'Mock API key detected — running in mock mode, no events will be sent to Amplitude.',\n        this.config.amplitudeApiKey,\n      );\n      return;\n    }\n\n    if (!this.amplitudeClient) {\n      const currentAmplitudeInstance: BrowserClient = createInstance();\n\n      currentAmplitudeInstance.add(this.getEventTrackingEnrichment());\n      currentAmplitudeInstance.init(this.config.amplitudeApiKey, this.config.userId, {\n        serverZone: this.config.dataResidency as ServerZoneType,\n        trackingOptions: {\n          ipAddress: true,\n        },\n        autocapture: {\n          attribution: true,\n          pageViews: {\n            trackHistoryChanges: 'pathOnly',\n          },\n          sessions: false,\n          formInteractions: false,\n          fileDownloads: false,\n        },\n      });\n      this.amplitudeClient = currentAmplitudeInstance;\n    }\n  }\n\n  static mapWidgetTypeToChatComponent(widgetType: unknown): string {\n    switch (widgetType) {\n      case WidgetTypeV3.FloatingButtonV3:\n        return 'floating_button';\n      case WidgetTypeV3.ChatPreviewV3:\n      case WidgetTypeV3.SocialProofV3:\n        return 'embedded_widget';\n      case WidgetTypeV3.TitledPromptCarouselV3:\n      case WidgetTypeV3.PromptCarouselV3:\n        return 'suggestion_bar';\n      case WidgetTypeV3.ProductCardV3:\n        return 'image_prompt_card';\n      default:\n        return 'unknown';\n    }\n  }\n\n  static mapTriggerLocationToChatComponent(triggerLocation: unknown): string {\n    switch (triggerLocation) {\n      case ChatElementDisplayLocationV3.PRODUCT_CARD_PROMPT_BUTTON:\n      case ChatElementDisplayLocationV3.PRODUCT_CARD_TEXT_FIELD:\n        return 'prompt_card';\n      case ChatElementDisplayLocationV3.PROMPT_CAROUSEL:\n      case ChatElementDisplayLocationV3.TITLED_PROMPT_CAROUSEL:\n        return 'top_reviews_snippet';\n      case ChatElementDisplayLocationV3.TYPING_ANIMATION:\n      case ChatElementDisplayLocationV3.SOCIAL_PROOF_PRIMARY_BUTTON:\n      case ChatElementDisplayLocationV3.SOCIAL_PROOF_SECONDARY_BUTTON:\n      case ChatElementDisplayLocationV3.SOCIAL_PROOF_TEXT_FIELD:\n      case ChatElementDisplayLocationV3.CHAT_PREVIEW_COMPARISON_PROMPT_BUTTON:\n      case ChatElementDisplayLocationV3.CHAT_PREVIEW_COMPARISON_TEXT_FIELD:\n      case ChatElementDisplayLocationV3.CHAT_PREVIEW_PROMPT_BUTTON:\n      case ChatElementDisplayLocationV3.CHAT_PREVIEW_TEXT_FIELD:\n        return 'chat_preview';\n      case ChatElementDisplayLocationV3.FLOATING_CHAT_OVERLAY:\n      case ChatElementDisplayLocationV3.FLOATING_CHAT_CLOSE_BUTTON:\n        return 'in_chat';\n      default:\n        return triggerLocation as string;\n    }\n  }\n\n  // This allows us to map the event props to the correct format for the legacy amplitude events\n  static mapEventProps({ eventName, eventProps }: TrackEventParams): Record<string, unknown> {\n    const messageMetadata = eventProps?.message_metadata ?? {};\n    const triggerLocation =\n      messageMetadata !== null &&\n      typeof messageMetadata === 'object' &&\n      'trigger_location' in messageMetadata\n        ? messageMetadata.trigger_location\n        : undefined;\n\n    if (eventName === SpiffyMetricsEventName.ChatComponentExpanded) {\n      const mappedTriggerLoccation =\n        AmplitudeService.mapTriggerLocationToChatComponent(triggerLocation);\n      return {\n        ...eventProps,\n        message_metadata: {\n          ...messageMetadata,\n          trigger_location: mappedTriggerLoccation,\n          full_trigger_location: triggerLocation,\n        },\n      };\n    }\n\n    if (eventName === SpiffyMetricsEventName.ChatComponentVisible) {\n      const mappedWidgetType = AmplitudeService.mapWidgetTypeToChatComponent(\n        eventProps?.widget_type,\n      );\n      const mappedTriggerLoccation =\n        AmplitudeService.mapTriggerLocationToChatComponent(triggerLocation);\n      return {\n        ...eventProps,\n        message_metadata: {\n          ...messageMetadata,\n          trigger_location: mappedTriggerLoccation,\n          full_trigger_location: triggerLocation,\n        },\n        chat_component: mappedWidgetType,\n        'chat.component_visible': true,\n      };\n    }\n    return eventProps ?? {};\n  }\n\n  static isV3EnviveEvent(eventName: SpiffyMetricsEventName | EnviveMetricsEventName): boolean {\n    return Object.values(EnviveMetricsEventName).includes(eventName as EnviveMetricsEventName);\n  }\n\n  static decorateEventName(eventName: SpiffyMetricsEventName | EnviveMetricsEventName): string {\n    if (AmplitudeService.isV3EnviveEvent(eventName)) {\n      return `[Envive] ${eventName}`;\n    }\n    return `[Spiffy] ${eventName}`;\n  }\n\n  async trackEvent({\n    eventName,\n    eventProps,\n    eventGroups,\n    alsoSendToGoogleAnalytics = false,\n  }: TrackEventParams): Promise<void> {\n    if (this.isMockApiKey) return;\n    logger.logDebug('Submitting event', eventName);\n    try {\n      const decoratedEventName = AmplitudeService.decorateEventName(eventName);\n\n      if (!this.amplitudeClient) {\n        logger.logWarn('amplitude client undefined', undefined, {\n          event_name: decoratedEventName,\n        });\n        return;\n      }\n\n      const mappedEventProps = AmplitudeService.mapEventProps({ eventName, eventProps });\n\n      const eventData = JSON.stringify({\n        eventName,\n        eventProps: mappedEventProps,\n        created_at: new Date().toISOString(),\n      });\n      const encoder = new TextEncoder();\n      const data = encoder.encode(eventData);\n      // calculate a hash of the event properties to use as the insert_id so that duplicate events\n      // are automatically dropped by Amplitude\n      const hashBuffer = await crypto.subtle.digest('SHA-256', data);\n      const hashArray = Array.from(new Uint8Array(hashBuffer));\n      const currentInsertId = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');\n\n      logger.logDebug(`amplitude tracking ${decoratedEventName}`, null, {\n        event_name: decoratedEventName,\n        props: mappedEventProps,\n      });\n\n      this.amplitudeClient.track(\n        decoratedEventName,\n        {\n          ...this.getDefaultTrackingProps(eventName),\n          ...mappedEventProps,\n          ...(mappedEventProps\n            ? this.eventPropsToPrefixedEventProps(eventName, mappedEventProps)\n            : {}),\n        },\n        {\n          ...eventGroups,\n          insert_id: currentInsertId,\n        },\n      );\n\n      if (AmplitudeService.isV3EnviveEvent(eventName) && this.config.orgGaConfig) {\n        const mergedPropsForGA4 = {\n          ...this.getDefaultTrackingProps(eventName),\n          ...mappedEventProps,\n        };\n        projectToGA4(eventName as EnviveMetricsEventName, mergedPropsForGA4);\n      } else if (alsoSendToGoogleAnalytics && this.config.orgGaConfig) {\n        logger.logDebug('GA tracking', decoratedEventName);\n        if (typeof window !== 'undefined' && window.dataLayer) {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          (window.dataLayer as any[]).push({\n            event: decoratedEventName,\n            eventProps,\n          });\n        }\n      }\n    } catch (err) {\n      logger.logError('Error tracking event', err, {\n        eventName,\n        eventProps,\n      });\n    }\n  }\n\n  // Ensure that supplemental default props are merged with the existing props\n  setSupplementalDefaultProps(props: Record<string, unknown>): void {\n    this.supplementalDefaultProps = props;\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@envive-ai/react-hooks",
-  "version": "0.3.21",
+  "version": "0.3.22",
   "description": "React hooks for connecting to Envive AI services.",
   "keywords": [
     "react",

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

@@ -20,6 +20,7 @@ import { AmplitudeProvider, SpiffyMetricsEventName, useAmplitude } from '../ampl
 const mockTrackEvent = vi.fn().mockResolvedValue(undefined);
 const mockSetSupplementalDefaultProps = vi.fn();
 const mockIsReady = vi.fn().mockReturnValue(true);
+const mockIsMockApiKey = vi.fn().mockReturnValue(false);
 
 vi.mock('src/services/amplitudeService/amplitudeService', async () => {
   const actual = await vi.importActual<
@@ -34,6 +35,10 @@ vi.mock('src/services/amplitudeService/amplitudeService', async () => {
     get isReady(): boolean {
       return mockIsReady();
     }
+
+    get isMockApiKey(): boolean {
+      return mockIsMockApiKey();
+    }
   }
 
   function MockAmplitudeServiceConstructor() {
@@ -55,6 +60,7 @@ const MockAmplitudeComponent: React.FC = () => {
   return (
     <div data-testid="amplitude-component">
       <div data-testid="is-ready">{amplitude.isReady.toString()}</div>
+      <div data-testid="is-mock-mode">{amplitude.isMockMode.toString()}</div>
       <button
         data-testid="track-event-button"
         type="button"
@@ -213,6 +219,7 @@ describe('AmplitudeProvider - React Context Integration', () => {
     mockTrackEvent.mockClear();
     mockSetSupplementalDefaultProps.mockClear();
     mockIsReady.mockReturnValue(true);
+    mockIsMockApiKey.mockReturnValue(false);
     if (AmplitudeService && typeof AmplitudeService === 'function') {
       (AmplitudeService as unknown as ReturnType<typeof vi.fn>).mockClear();
     }
@@ -332,38 +339,35 @@ describe('AmplitudeProvider - React Context Integration', () => {
       });
     });
 
-    it('should not render children when not ready', async () => {
-      // Create a provider without required dependencies
-      const IncompleteWrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => {
-        return (
-          <Provider>
-            <EnviveConfigProvider
-              identifyingPrefix="test"
-              orgShortName="test-org"
-              // Missing amplitudeApiKey
-              featureGates={[]}
-            >
-              <LocalStorageProvider>
-                <UserIdentityProvider userIdService={testUserIdService}>
-                  <FeatureFlagServiceProvider featureFlagService={testFeatureFlagService}>
-                    <AmplitudeProvider>{children}</AmplitudeProvider>
-                  </FeatureFlagServiceProvider>
-                </UserIdentityProvider>
-              </LocalStorageProvider>
-            </EnviveConfigProvider>
-          </Provider>
-        );
-      };
+    it('should render children with isReady=false when isMockMode=true', async () => {
+      mockIsReady.mockReturnValue(false);
+      mockIsMockApiKey.mockReturnValue(true);
+
+      render(
+        <TestWrapper amplitudeApiKey="mock-amplitude-key">
+          <MockAmplitudeComponent />
+        </TestWrapper>,
+      );
+
+      await waitFor(() => {
+        expect(screen.getByTestId('amplitude-component')).toBeInTheDocument();
+        expect(screen.getByTestId('is-ready').textContent).toBe('false');
+        expect(screen.getByTestId('is-mock-mode').textContent).toBe('true');
+      });
+    });
+
+    it('should NOT render children when isReady=false and isMockMode=false', async () => {
+      mockIsReady.mockReturnValue(false);
+      mockIsMockApiKey.mockReturnValue(false);
 
       render(
-        <IncompleteWrapper>
-          <div data-testid="should-not-render">Should not render</div>
-        </IncompleteWrapper>,
+        <TestWrapper>
+          <MockAmplitudeComponent />
+        </TestWrapper>,
       );
 
-      // AmplitudeProvider returns null when not ready, so children should not render
       await waitFor(() => {
-        expect(screen.queryByTestId('should-not-render')).not.toBeInTheDocument();
+        expect(screen.queryByTestId('amplitude-component')).not.toBeInTheDocument();
       });
     });
   });

package/src/contexts/amplitudeContext/amplitudeContext.tsx

@@ -23,6 +23,7 @@ export { EnviveMetricsEventName, SpiffyMetricsEventName };
 interface AmplitudeContextType {
   trackEvent: (params: TrackEventParams) => Promise<void>;
   isReady: boolean;
+  isMockMode: boolean;
   setSupplementalDefaultProps: (props: Record<string, unknown>) => void;
 }
 
@@ -55,6 +56,7 @@ export const AmplitudeProvider: React.FC<{
   const [service, setService] = useState<AmplitudeService | null>(null);
 
   const isReady = Boolean(userId && service && service.isReady);
+  const isMockMode = Boolean(service?.isMockApiKey);
 
   // Create service instance when dependencies are ready
   useEffect(() => {
@@ -109,16 +111,17 @@ export const AmplitudeProvider: React.FC<{
         }
       },
       isReady,
+      isMockMode,
       setSupplementalDefaultProps: (props: Record<string, unknown>) => {
         if (service) {
           service.setSupplementalDefaultProps(props);
         }
       },
     }),
-    [service, isReady],
+    [service, isReady, isMockMode],
   );
 
-  if (!isReady) {
+  if (!isReady && !isMockMode) {
     return null;
   }
 

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

@@ -19,6 +19,16 @@ vi.spyOn(Logger.prototype, 'logInfo').mockImplementation(() => {});
 vi.spyOn(Logger.prototype, 'logWarn').mockImplementation(() => {});
 vi.spyOn(Logger.prototype, 'logError').mockImplementation(() => {});
 
+vi.mock('src/contexts/amplitudeContext', () => ({
+  useAmplitude: () => ({
+    trackEvent: vi.fn(),
+    isReady: true,
+  }),
+  EnviveMetricsEventName: {
+    PageViewed: 'Page Viewed',
+  },
+}));
+
 // Mock CommerceApiClient
 const mockResolveUrl = vi.fn();
 vi.mock('src/application/commerce-api', () => ({

package/src/hooks/Search/__tests__/useSearch.test.tsx

@@ -29,10 +29,6 @@ import { UserIdentityService } from 'src/services/userIdentityService';
 import { useSearch } from '../useSearch';
 
 // Mock dependencies
-vi.mock('src/hooks/TrackComponentVisibleEvent/useTrackComponentVisibleEvent', () => ({
-  useTrackComponentVisibleEvent: vi.fn(),
-}));
-
 vi.mock('src/hooks/Intersection/useIntersection', () => ({
   useIntersection: vi.fn(() => false),
 }));

package/src/hooks/Search/useSearch.tsx

@@ -27,8 +27,8 @@ import { SearchResponseProduct } from '@spiffy-ai/commerce-api-client';
 import { SearchFilterDatum, SelectFilterItem } from 'src/types/search-filter-types';
 import { orgShortNameAtom } from 'src/atoms/envive/enviveConfig';
 import { FrontendConfig, SearchResponseProductAttributes } from 'src/application/models';
+import { useIntersection } from 'src/hooks/Intersection/useIntersection';
 import { SearchResultsState, getSearchResultsState } from '../utils';
-import { useTrackComponentVisibleEvent } from '../TrackComponentVisibleEvent';
 import { useSearchInput } from './useSearchInput';
 import { useNewOrgConfig } from '../NewOrgConfig';
 import { useRecommendedProducts } from './useRecommendedProducts';
@@ -292,13 +292,19 @@ export const useSearch = ({
     scrollToTop();
   }, [setProductSorting, clearFilters, scrollToTop]);
 
-  // Side Effects
-  useTrackComponentVisibleEvent(
-    SpiffyWidgets.SearchResults,
-    searchResultsRef as RefObject<HTMLElement>,
-    {},
-    SpiffyMetricsEventName.SearchComponentVisible,
-  );
+  const searchResultsVisible = useIntersection(searchResultsRef as RefObject<HTMLElement>, '0px');
+  const hasTrackedSearchComponentVisible = useRef(false);
+
+  useEffect(() => {
+    if (!searchResultsVisible || hasTrackedSearchComponentVisible.current) {
+      return;
+    }
+    hasTrackedSearchComponentVisible.current = true;
+    trackEvent({
+      eventName: SpiffyMetricsEventName.SearchComponentVisible,
+      eventProps: {},
+    });
+  }, [searchResultsVisible, trackEvent]);
 
   useEffect(() => {
     if (

package/src/hooks/TrackComponentVisibleEvent/useTrackComponentVisibleEvent.ts

@@ -1,54 +1,47 @@
 import { RefObject, useEffect, useRef } from 'react';
-import { SpiffyWidgets } from 'src/application/models/spiffyWidgets';
 import { useIntersection } from 'src/hooks/Intersection/useIntersection';
 import { useAmplitude } from 'src/contexts/amplitudeContext/amplitudeContext';
-import { SpiffyMetricsEventName } from 'src/services/amplitudeService/amplitudeService';
+import {
+  EnviveMetricsEventName,
+  SpiffyMetricsEventName,
+} from 'src/services/amplitudeService/amplitudeService';
 
 /**
- * Tracks a component and logs an event to Amplitude when the component is visible.
+ * Tracks a component and logs `SpiffyMetricsEventName.ChatComponentVisible` when visible.
  *
- * @param component - The component to track.
  * @param element - The element to track visibility of.
- * @param eventProps - Additional properties to include with the event.
- * @param eventName - The Amplitude event name to track (defaults to ChatComponentVisible).
+ * @param eventProps - Properties to include with the event.
+ * @param rootMargin - Root margin for the intersection observer (defaults to 0px).
+ * @param enabled - Whether tracking is enabled (defaults to true).
  */
 export const useTrackComponentVisibleEvent = (
-  component: SpiffyWidgets,
   element: RefObject<HTMLElement>,
   eventProps?: Record<string, unknown>,
-  eventName: SpiffyMetricsEventName = SpiffyMetricsEventName.ChatComponentVisible,
-) => {
-  const isVisible = useIntersection(element, '0px');
+  rootMargin: string = '0px',
+  enabled: boolean = true,
+): { isVisible: boolean } => {
+  const isVisible = useIntersection(element, rootMargin);
   const hasTrackedEvent = useRef(false);
   const { trackEvent } = useAmplitude();
 
-  const componentProps = (() => {
-    if (eventName === SpiffyMetricsEventName.ChatComponentVisible) {
-      return {
-        chat_component: component,
-        ...eventProps,
-      };
-    }
-    if (eventName === SpiffyMetricsEventName.SearchComponentVisible) {
-      return {
-        search_component: component,
-        ...eventProps,
-      };
-    }
-    // Default case for other event types
-    return {
-      component,
-      ...eventProps,
-    };
-  })();
-
   useEffect(() => {
-    if (isVisible && !hasTrackedEvent.current) {
+    if (!enabled || hasTrackedEvent.current) {
+      return;
+    }
+    if (isVisible) {
+      trackEvent({
+        eventName: SpiffyMetricsEventName.ChatComponentVisible,
+        eventProps,
+      });
       trackEvent({
-        eventName,
-        eventProps: componentProps,
+        eventName: EnviveMetricsEventName.WidgetRendered,
+        eventProps: {
+          ...eventProps,
+          'trigger.widget': eventProps?.widget_type,
+        },
       });
       hasTrackedEvent.current = true;
     }
-  }, [isVisible, component, eventProps, eventName, componentProps, trackEvent]);
+  }, [enabled, isVisible, eventProps, trackEvent]);
+  return { isVisible };
 };

package/src/hooks/WidgetInteraction/types.ts

@@ -5,11 +5,12 @@ export interface WidgetInteractionContext {
   page_id: string;
 }
 
-interface WidgetInteractionTrigger {
+export interface WidgetInteractionTrigger {
   interaction_id?: string;
   widget: WidgetInteractionComponent;
   widget_interaction: WidgetInteractionType;
   widget_interaction_data?: WidgetInteractionData | null;
+  interaction_class?: InteractionClass;
 }
 
 export interface InternalWidgetInteraction {
@@ -63,6 +64,29 @@ export enum WidgetInteractionType {
   MANUAL_SCROLL_TO_BOTTOM = 'manual_scroll_to_bottom',
 }
 
+export enum InteractionClass {
+  PASSIVE = 'passive', // No user commitment — hover, scroll, visibility triggers
+  NAVIGATIONAL = 'navigational', // Opens/closes something — often a side effect of intent
+  INTENTIONAL = 'intentional', // Deliberate user action — clicks, submits, typed queries
+}
+
+export const INTERACTION_TYPE_CLASS: Record<WidgetInteractionType, InteractionClass> = {
+  [WidgetInteractionType.QUERY_INPUT_CLICKED]: InteractionClass.INTENTIONAL,
+  [WidgetInteractionType.SUGGESTION_CLICKED]: InteractionClass.INTENTIONAL,
+  [WidgetInteractionType.WIDGET_CLICKED]: InteractionClass.INTENTIONAL,
+  [WidgetInteractionType.WIDGET_HOVERED]: InteractionClass.PASSIVE,
+  [WidgetInteractionType.WIDGET_EXPANDED]: InteractionClass.NAVIGATIONAL,
+  [WidgetInteractionType.WIDGET_COLLAPSED]: InteractionClass.NAVIGATIONAL,
+  [WidgetInteractionType.SUGGESTION_SCROLLED]: InteractionClass.PASSIVE,
+  [WidgetInteractionType.LINK_CLICKED]: InteractionClass.INTENTIONAL,
+  [WidgetInteractionType.PRODUCT_CARD_CLICKED]: InteractionClass.INTENTIONAL,
+  [WidgetInteractionType.TEXT_LINK_CLICKED]: InteractionClass.INTENTIONAL,
+  [WidgetInteractionType.ARTICLE_LINK_CLICKED]: InteractionClass.INTENTIONAL,
+  [WidgetInteractionType.REVIEW_CARD_CLICKED]: InteractionClass.INTENTIONAL,
+  [WidgetInteractionType.MESSAGE_SUBMITTED]: InteractionClass.INTENTIONAL,
+  [WidgetInteractionType.MANUAL_SCROLL_TO_BOTTOM]: InteractionClass.PASSIVE,
+};
+
 export type URL = {
   url: string;
 };

package/src/hooks/WidgetInteraction/useWidgetInteraction.ts

@@ -3,7 +3,7 @@ import { pageVariantInfoAtom } from 'src/atoms/app';
 import { useAmplitude } from 'src/contexts/amplitudeContext';
 import { PageVariantInfo } from 'src/contexts/pageContext/types';
 import { v4 as uuid } from 'uuid';
-import { InternalWidgetInteraction, WidgetInteraction } from './types';
+import { INTERACTION_TYPE_CLASS, InternalWidgetInteraction, WidgetInteraction } from './types';
 import { extractPageContext } from './utils';
 
 const getInteractionId = () => uuid();
@@ -16,6 +16,8 @@ export const useWidgetInteraction = () => {
     if (props.trigger) {
       // eslint-disable-next-line no-param-reassign
       props.trigger.interaction_id = props.trigger.interaction_id || getInteractionId();
+      props.trigger.interaction_class =
+        props.trigger.interaction_class || INTERACTION_TYPE_CLASS[props.trigger.widget_interaction];
     }
 
     const eventProps = {

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

@@ -85,10 +85,12 @@ describe('AmplitudeService', () => {
     });
   });
 
+  const validApiKey = 'abcdef1234567890abcdef1234567890';
+
   const createService = (overrides?: Partial<AmplitudeServiceConfig>) => {
     return new AmplitudeService({
       userId: 'test-user-id',
-      amplitudeApiKey: 'test-api-key',
+      amplitudeApiKey: validApiKey,
       dataResidency: 'US',
       env: 'test',
       orgId: 'test-org-id',
@@ -107,7 +109,7 @@ describe('AmplitudeService', () => {
       createService();
 
       expect(mockInit).toHaveBeenCalledWith(
-        'test-api-key',
+        validApiKey,
         'test-user-id',
         expect.objectContaining({
           serverZone: 'US',
@@ -121,7 +123,7 @@ describe('AmplitudeService', () => {
     it('should not be ready if userId is missing', () => {
       const service = new AmplitudeService({
         userId: '',
-        amplitudeApiKey: 'test-api-key',
+        amplitudeApiKey: validApiKey,
         dataResidency: 'US',
         env: 'test',
         orgId: 'test-org-id',
@@ -157,7 +159,7 @@ describe('AmplitudeService', () => {
     it('should not be ready if featureFlagService is missing', () => {
       const service = new AmplitudeService({
         userId: 'test-user-id',
-        amplitudeApiKey: 'test-api-key',
+        amplitudeApiKey: validApiKey,
         dataResidency: 'US',
         env: 'test',
         orgId: 'test-org-id',
@@ -269,7 +271,7 @@ describe('AmplitudeService', () => {
     it('should not track if client is not initialized', async () => {
       const service = new AmplitudeService({
         userId: '',
-        amplitudeApiKey: 'test-api-key',
+        amplitudeApiKey: validApiKey,
         dataResidency: 'US',
         env: 'test',
         orgId: 'test-org-id',
@@ -419,7 +421,7 @@ describe('AmplitudeService', () => {
     it('should fall back to window.localStorage when getLocalStorageItem is not provided', async () => {
       const service = new AmplitudeService({
         userId: 'test-user-id',
-        amplitudeApiKey: 'test-api-key',
+        amplitudeApiKey: validApiKey,
         dataResidency: 'US',
         env: 'test',
         orgId: 'test-org-id',
@@ -597,6 +599,67 @@ describe('AmplitudeService', () => {
     });
   });
 
+  describe('isMockApiKey', () => {
+    it('should return true when amplitudeApiKey is "mock-amplitude-key"', () => {
+      const service = createService({ amplitudeApiKey: 'mock-amplitude-key' });
+
+      expect(service.isMockApiKey).toBe(true);
+    });
+
+    it('should return false for a real API key', () => {
+      const service = createService();
+
+      expect(service.isMockApiKey).toBe(false);
+    });
+  });
+
+  describe('Mock API key behavior', () => {
+    it('should not initialize the Amplitude client when using mock API key', () => {
+      createService({ amplitudeApiKey: 'mock-amplitude-key' });
+
+      expect(mockInit).not.toHaveBeenCalled();
+      expect(mockAdd).not.toHaveBeenCalled();
+    });
+
+    it('should log a warning when mock API key is detected during initialization', () => {
+      const logWarnSpy = vi.spyOn(Logger.prototype, 'logWarn');
+
+      createService({ amplitudeApiKey: 'mock-amplitude-key' });
+
+      expect(logWarnSpy).toHaveBeenCalledWith(
+        'Mock API key detected — running in mock mode, no events will be sent to Amplitude.',
+        'mock-amplitude-key',
+      );
+    });
+
+    it('should report isReady as false when using mock API key', () => {
+      const service = createService({ amplitudeApiKey: 'mock-amplitude-key' });
+
+      expect(service.isReady).toBe(false);
+    });
+
+    it('should not track events when using mock API key', async () => {
+      const service = createService({ amplitudeApiKey: 'mock-amplitude-key' });
+
+      await service.trackEvent({
+        eventName: SpiffyMetricsEventName.ChatUserMessageInput,
+        eventProps: { message: 'test' },
+      });
+
+      expect(mockTrack).not.toHaveBeenCalled();
+    });
+
+    it('should not call crypto.subtle.digest when using mock API key', async () => {
+      const service = createService({ amplitudeApiKey: 'mock-amplitude-key' });
+
+      await service.trackEvent({
+        eventName: SpiffyMetricsEventName.ChatUserMessageInput,
+      });
+
+      expect(mockDigest).not.toHaveBeenCalled();
+    });
+  });
+
   describe('Session replay initialization', () => {
     it('should disable session replay by default', () => {
       createService();