@envive-ai/react-hooks 0.3.56 → 0.3.58

package/dist/services/amplitudeService/amplitudeService.js

@@ -10,6 +10,14 @@ import { projectToGA4 } from "../ga4ProjectionService/ga4ProjectionService.js";
 
 //#region src/services/amplitudeService/amplitudeService.ts
 const logger = new logger_default("amplitudeService");
+const UTF8_TRANSPORT_PREFIX = "__spiffy_utf8__:";
+const containsSupplementaryUnicode = (value) => Array.from(value).some((character) => (character.codePointAt(0) ?? 0) > 65535);
+const encodeSupplementaryUnicode = (value) => {
+	if (typeof value === "string") return containsSupplementaryUnicode(value) ? `${UTF8_TRANSPORT_PREFIX}${encodeURIComponent(value)}` : value;
+	if (Array.isArray(value)) return value.map(encodeSupplementaryUnicode);
+	if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [key, encodeSupplementaryUnicode(nestedValue)]));
+	return value;
+};
 const EXPERIMENT_NAMESPACES = ["ml", "merchant"];
 const buildExperimentProps = (assignments) => {
 	const byNamespace = /* @__PURE__ */ new Map();
@@ -257,9 +265,10 @@ var AmplitudeService = class AmplitudeService {
 				eventName,
 				eventProps
 			});
+			const amplitudeEventProps = eventName === EnviveMetricsEventName.WidgetTextResponse || eventName === EnviveMetricsEventName.WidgetTextClicked ? encodeSupplementaryUnicode(mappedEventProps) : mappedEventProps;
 			const eventData = JSON.stringify({
 				eventName,
-				eventProps: mappedEventProps,
+				eventProps: amplitudeEventProps,
 				created_at: (/* @__PURE__ */ new Date()).toISOString()
 			});
 			const data = new TextEncoder().encode(eventData);
@@ -267,12 +276,12 @@ var AmplitudeService = class AmplitudeService {
 			const currentInsertId = Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
 			logger.logDebug(`amplitude tracking ${decoratedEventName}`, null, {
 				event_name: decoratedEventName,
-				props: mappedEventProps
+				props: amplitudeEventProps
 			});
 			this.amplitudeClient.track(decoratedEventName, {
 				...this.getDefaultTrackingProps(eventName),
-				...mappedEventProps,
-				...mappedEventProps ? this.eventPropsToPrefixedEventProps(eventName, mappedEventProps) : {}
+				...amplitudeEventProps,
+				...amplitudeEventProps ? this.eventPropsToPrefixedEventProps(eventName, amplitudeEventProps) : {}
 			}, {
 				...eventGroups,
 				insert_id: currentInsertId
@@ -303,4 +312,4 @@ var AmplitudeService = class AmplitudeService {
 
 //#endregion
 export { AmplitudeService };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"amplitudeService.js","names":["Logger","EXPERIMENT_NAMESPACES: ExperimentNamespace[]","enrichment: EnrichmentPlugin","enrichedEvent: Event","globalProperties: Record<string, string>","currentAmplitudeInstance: BrowserClient"],"sources":["../../../src/services/amplitudeService/amplitudeService.ts"],"sourcesContent":["import { 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/services/featureFlagService';\nimport { WidgetTypeV3 } from 'src/contexts/typesV3';\nimport { ChatElementDisplayLocationV3 } from 'src/application/models/chatElementDisplayLocationV3';\nimport { ExperimentNamespace, OrgConfigExperimentAssignment } from 'src/application/models';\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  show: boolean;\n  enviveOn: boolean;\n  enabledFeatures?: Record<string, boolean>;\n  getLocalStorageItem: null | ((key: string) => string | null);\n  // Captured at construction. Drives `experiment.{ns}.*` event-property\n  // enrichment. Sourced from /v1/org/config when the `use_unified_config`\n  // gate is on; otherwise omitted (props emit as null).\n  experimentAssignments?: OrgConfigExperimentAssignment[];\n}\n\n// Namespaces emitted on every event with constant keys, so the BigQuery\n// schema is stable regardless of which (if any) experiment is running.\n// Currently `ml` + `merchant`; matches `ExperimentNamespace`.\nconst EXPERIMENT_NAMESPACES: ExperimentNamespace[] = ['ml', 'merchant'];\n\nconst buildExperimentProps = (\n  assignments: OrgConfigExperimentAssignment[] | undefined,\n): Record<string, unknown> => {\n  const byNamespace = new Map<ExperimentNamespace, OrgConfigExperimentAssignment>();\n  (assignments ?? []).forEach(a => {\n    if (a.layer_name != null && a.namespace != null) {\n      byNamespace.set(a.namespace, a);\n    }\n  });\n  return EXPERIMENT_NAMESPACES.reduce<Record<string, unknown>>((acc, ns) => {\n    const a = byNamespace.get(ns);\n    acc[`experiment.${ns}.layer_name`] = a?.layer_name ?? null;\n    acc[`experiment.${ns}.experiment_name`] = a?.allocated_experiment_name ?? null;\n    acc[`experiment.${ns}.group_name`] = a?.group_name ?? null;\n    // `rule_id` reserved — backend doesn't currently surface it.\n    acc[`experiment.${ns}.rule_id`] = null;\n    return acc;\n  }, {});\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  private initPromise: Promise<void>;\n\n  constructor(config: AmplitudeServiceConfig) {\n    this.config = config;\n    this.initPromise = this.initialize();\n  }\n\n  get isMockApiKey(): boolean {\n    return this.config.amplitudeApiKey === 'mock-amplitude-key';\n  }\n\n  // Must not depend on `amplitudeClient`: the SDK now loads via dynamic\n  // import, and AmplitudeProvider unmounts its entire subtree while\n  // isReady is false — gating on the client would block widget rendering\n  // on the analytics chunk download. Events awaited in trackEvent queue\n  // behind `initPromise` instead.\n  get isReady(): boolean {\n    return Boolean(\n      this.config.userId &&\n      this.config.featureFlagService &&\n      this.config.amplitudeApiKey &&\n      !this.isMockApiKey,\n    );\n  }\n\n  /** Resolves once SDK initialization has settled (never rejects). */\n  initialized(): Promise<void> {\n    return this.initPromise;\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 = buildExperimentProps(this.config.experimentAssignments);\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          `[Envive] ${EnviveMetricsEventName.PageViewed}`,\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 async initialize(): Promise<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      try {\n        // Dynamic import keeps the Amplitude SDK out of the eager\n        // injection-bundle chunk; trackEvent queues behind initPromise.\n        const { createInstance } = await import('@amplitude/analytics-browser');\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      } catch (err) {\n        logger.logError('Failed to load or initialize the Amplitude SDK', err);\n      }\n    }\n  }\n\n  static mapWidgetTypeToChatComponent(widgetType: unknown): string {\n    switch (widgetType) {\n      case WidgetTypeV3.FloatingButtonV3:\n        return 'floating_button';\n      case WidgetTypeV3.TypingAnimationV3:\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    await this.initPromise;\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      // TODO: Pull gaEnabled from org config when available. Hardcoded to true for now.\n      const gaEnabled = true;\n\n      if (AmplitudeService.isV3EnviveEvent(eventName) && gaEnabled) {\n        const mergedPropsForGA4 = {\n          ...this.getDefaultTrackingProps(eventName),\n          ...mappedEventProps,\n        };\n        projectToGA4(eventName as EnviveMetricsEventName, mergedPropsForGA4);\n      } else if (alsoSendToGoogleAnalytics && gaEnabled) {\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","EXPERIMENT_NAMESPACES: ExperimentNamespace[]","enrichment: EnrichmentPlugin","enrichedEvent: Event","globalProperties: Record<string, string>","currentAmplitudeInstance: BrowserClient"],"sources":["../../../src/services/amplitudeService/amplitudeService.ts"],"sourcesContent":["import { 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/services/featureFlagService';\nimport { WidgetTypeV3 } from 'src/contexts/typesV3';\nimport { ChatElementDisplayLocationV3 } from 'src/application/models/chatElementDisplayLocationV3';\nimport { ExperimentNamespace, OrgConfigExperimentAssignment } from 'src/application/models';\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\n// Amplitude's managed BigQuery data can surface supplementary Unicode as U+FFFD.\n// Keep the widget-training payload ASCII-safe without changing the displayed text.\nconst UTF8_TRANSPORT_PREFIX = '__spiffy_utf8__:';\n\nconst containsSupplementaryUnicode = (value: string): boolean =>\n  Array.from(value).some(character => (character.codePointAt(0) ?? 0) > 0xffff);\n\nconst encodeSupplementaryUnicode = (value: unknown): unknown => {\n  if (typeof value === 'string') {\n    return containsSupplementaryUnicode(value)\n      ? `${UTF8_TRANSPORT_PREFIX}${encodeURIComponent(value)}`\n      : value;\n  }\n  if (Array.isArray(value)) {\n    return value.map(encodeSupplementaryUnicode);\n  }\n  if (value !== null && typeof value === 'object') {\n    return Object.fromEntries(\n      Object.entries(value).map(([key, nestedValue]) => [\n        key,\n        encodeSupplementaryUnicode(nestedValue),\n      ]),\n    );\n  }\n  return value;\n};\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  show: boolean;\n  enviveOn: boolean;\n  enabledFeatures?: Record<string, boolean>;\n  getLocalStorageItem: null | ((key: string) => string | null);\n  // Captured at construction. Drives `experiment.{ns}.*` event-property\n  // enrichment. Sourced from /v1/org/config when the `use_unified_config`\n  // gate is on; otherwise omitted (props emit as null).\n  experimentAssignments?: OrgConfigExperimentAssignment[];\n}\n\n// Namespaces emitted on every event with constant keys, so the BigQuery\n// schema is stable regardless of which (if any) experiment is running.\n// Currently `ml` + `merchant`; matches `ExperimentNamespace`.\nconst EXPERIMENT_NAMESPACES: ExperimentNamespace[] = ['ml', 'merchant'];\n\nconst buildExperimentProps = (\n  assignments: OrgConfigExperimentAssignment[] | undefined,\n): Record<string, unknown> => {\n  const byNamespace = new Map<ExperimentNamespace, OrgConfigExperimentAssignment>();\n  (assignments ?? []).forEach(a => {\n    if (a.layer_name != null && a.namespace != null) {\n      byNamespace.set(a.namespace, a);\n    }\n  });\n  return EXPERIMENT_NAMESPACES.reduce<Record<string, unknown>>((acc, ns) => {\n    const a = byNamespace.get(ns);\n    acc[`experiment.${ns}.layer_name`] = a?.layer_name ?? null;\n    acc[`experiment.${ns}.experiment_name`] = a?.allocated_experiment_name ?? null;\n    acc[`experiment.${ns}.group_name`] = a?.group_name ?? null;\n    // `rule_id` reserved — backend doesn't currently surface it.\n    acc[`experiment.${ns}.rule_id`] = null;\n    return acc;\n  }, {});\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  private initPromise: Promise<void>;\n\n  constructor(config: AmplitudeServiceConfig) {\n    this.config = config;\n    this.initPromise = this.initialize();\n  }\n\n  get isMockApiKey(): boolean {\n    return this.config.amplitudeApiKey === 'mock-amplitude-key';\n  }\n\n  // Must not depend on `amplitudeClient`: the SDK now loads via dynamic\n  // import, and AmplitudeProvider unmounts its entire subtree while\n  // isReady is false — gating on the client would block widget rendering\n  // on the analytics chunk download. Events awaited in trackEvent queue\n  // behind `initPromise` instead.\n  get isReady(): boolean {\n    return Boolean(\n      this.config.userId &&\n      this.config.featureFlagService &&\n      this.config.amplitudeApiKey &&\n      !this.isMockApiKey,\n    );\n  }\n\n  /** Resolves once SDK initialization has settled (never rejects). */\n  initialized(): Promise<void> {\n    return this.initPromise;\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 = buildExperimentProps(this.config.experimentAssignments);\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          `[Envive] ${EnviveMetricsEventName.PageViewed}`,\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 async initialize(): Promise<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      try {\n        // Dynamic import keeps the Amplitude SDK out of the eager\n        // injection-bundle chunk; trackEvent queues behind initPromise.\n        const { createInstance } = await import('@amplitude/analytics-browser');\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      } catch (err) {\n        logger.logError('Failed to load or initialize the Amplitude SDK', err);\n      }\n    }\n  }\n\n  static mapWidgetTypeToChatComponent(widgetType: unknown): string {\n    switch (widgetType) {\n      case WidgetTypeV3.FloatingButtonV3:\n        return 'floating_button';\n      case WidgetTypeV3.TypingAnimationV3:\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    await this.initPromise;\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      const amplitudeEventProps =\n        eventName === EnviveMetricsEventName.WidgetTextResponse ||\n        eventName === EnviveMetricsEventName.WidgetTextClicked\n          ? (encodeSupplementaryUnicode(mappedEventProps) as Record<string, unknown>)\n          : mappedEventProps;\n\n      const eventData = JSON.stringify({\n        eventName,\n        eventProps: amplitudeEventProps,\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: amplitudeEventProps,\n      });\n\n      this.amplitudeClient.track(\n        decoratedEventName,\n        {\n          ...this.getDefaultTrackingProps(eventName),\n          ...amplitudeEventProps,\n          ...(amplitudeEventProps\n            ? this.eventPropsToPrefixedEventProps(eventName, amplitudeEventProps)\n            : {}),\n        },\n        {\n          ...eventGroups,\n          insert_id: currentInsertId,\n        },\n      );\n\n      // TODO: Pull gaEnabled from org config when available. Hardcoded to true for now.\n      const gaEnabled = true;\n\n      if (AmplitudeService.isV3EnviveEvent(eventName) && gaEnabled) {\n        const mergedPropsForGA4 = {\n          ...this.getDefaultTrackingProps(eventName),\n          ...mappedEventProps,\n        };\n        projectToGA4(eventName as EnviveMetricsEventName, mergedPropsForGA4);\n      } else if (alsoSendToGoogleAnalytics && gaEnabled) {\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.56",
+  "version": "0.3.58",
   "description": "React hooks for connecting to Envive AI services.",
   "keywords": [
     "react",
@@ -74,6 +74,10 @@
       "import": "./dist/application/commerce-api.js",
       "require": "./dist/application/commerce-api.cjs"
     },
+    "./application/logging": {
+      "import": "./dist/application/logging/index.js",
+      "require": "./dist/application/logging/index.cjs"
+    },
     "./application/models": {
       "import": "./dist/application/models/index.js",
       "require": "./dist/application/models/index.cjs"

package/src/application/__tests__/commerceApiStreaming.test.ts

@@ -0,0 +1,171 @@
+import {
+  ContextEnvEnum,
+  ContextSourceEnum,
+  ResponseCategory,
+} from '@spiffy-ai/commerce-api-client';
+import { getAtomStore } from 'src/atoms/atomStore/atomStore';
+import { enviveConfigAtom } from 'src/atoms/envive/enviveConfig';
+import { NextMessageRequest, Response } from 'src/application/models';
+import CommerceApiClient from '../commerce-api';
+
+const { mockV1NextResponsesPostRaw } = vi.hoisted(() => ({
+  mockV1NextResponsesPostRaw: vi.fn(),
+}));
+
+vi.mock('@spiffy-ai/commerce-api-client', async (importOriginal: () => Promise<unknown>) => {
+  const actual = (await importOriginal()) as typeof import('@spiffy-ai/commerce-api-client');
+  return {
+    ...actual,
+    InferenceApi: vi.fn().mockImplementation(function InferenceApi() {
+      return { v1NextResponsesPostRaw: mockV1NextResponsesPostRaw };
+    }),
+  };
+});
+
+const payload: NextMessageRequest = {
+  id: 'req-1',
+  context: {
+    chatId: 'chat-1',
+    orgId: 'org-1',
+    orgShortName: 'test-org',
+    userId: 'user-1',
+    source: ContextSourceEnum.App,
+    env: ContextEnvEnum.Dev,
+  },
+};
+
+const productRecord = (id: string, title: string, description = 'A great shoe') =>
+  JSON.stringify({
+    id,
+    category: 'product',
+    created_at: '2026-08-28 14:42:58.529065+00:00',
+    attributes: {
+      id: `sku-${id}`,
+      title,
+      description,
+      url: `https://example.com/${id}`,
+      image_url: `https://example.com/${id}.jpg`,
+    },
+  });
+
+const streamFromByteChunks = (chunks: Uint8Array[]): ReadableStream<Uint8Array> =>
+  new ReadableStream({
+    start(controller) {
+      chunks.forEach(chunk => controller.enqueue(chunk));
+      controller.close();
+    },
+  });
+
+const streamFromStringChunks = (chunks: string[]): ReadableStream<Uint8Array> => {
+  const encoder = new TextEncoder();
+  return streamFromByteChunks(chunks.map(chunk => encoder.encode(chunk)));
+};
+
+const mockStreamedResponse = (body: ReadableStream<Uint8Array>) => {
+  mockV1NextResponsesPostRaw.mockResolvedValueOnce({ raw: { body } });
+};
+
+const collectStream = async (): Promise<Response[]> => {
+  const results: Response[] = [];
+  for await (const response of CommerceApiClient.getNextResponseStreaming(payload)) {
+    results.push(response);
+  }
+  return results;
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  getAtomStore().set(enviveConfigAtom, {
+    baseUrl: 'https://commerce-api.test',
+    orgLevelApiKey: 'test-key',
+    orgId: 'org-1',
+    orgShortName: 'test-org',
+    env: 'dev',
+    contextSource: 'app',
+  });
+});
+
+describe('CommerceApiClient.getNextResponseStreaming — NDJSON chunk handling', () => {
+  it('parses records split mid-line across chunk boundaries', async () => {
+    const record1 = productRecord('rec-1', 'Kelly Mary Jane Flat');
+    const record2 = productRecord('rec-2', '27 Edit Carla Ballet Flat');
+    // Cut each record in the middle of a JSON string, as observed on cellular connections
+    mockStreamedResponse(
+      streamFromStringChunks([
+        record1.slice(0, 120),
+        `${record1.slice(120)}\n${record2.slice(0, 80)}`,
+        `${record2.slice(80)}\n`,
+      ]),
+    );
+
+    const results = await collectStream();
+
+    expect(results.map(r => r.id)).toEqual(['rec-1', 'rec-2']);
+  });
+
+  it('does not re-prepend a consumed partial to later chunks', async () => {
+    const record1 = productRecord('rec-1', 'First');
+    const record2 = productRecord('rec-2', 'Second');
+    const record3 = productRecord('rec-3', 'Third');
+    // record1 completes in chunk 2, which ends cleanly on a newline; the old
+    // implementation kept the stale partial and corrupted record3 in chunk 3
+    mockStreamedResponse(
+      streamFromStringChunks([
+        record1.slice(0, 100),
+        `${record1.slice(100)}\n${record2}\n`,
+        `${record3}\n`,
+      ]),
+    );
+
+    const results = await collectStream();
+
+    expect(results.map(r => r.id)).toEqual(['rec-1', 'rec-2', 'rec-3']);
+  });
+
+  it('flushes a final record that has no trailing newline', async () => {
+    const record1 = productRecord('rec-1', 'First');
+    const record2 = productRecord('rec-2', 'Last, unterminated');
+    mockStreamedResponse(
+      streamFromStringChunks([`${record1}\n${record2.slice(0, 90)}`, record2.slice(90)]),
+    );
+
+    const results = await collectStream();
+
+    expect(results.map(r => r.id)).toEqual(['rec-1', 'rec-2']);
+  });
+
+  it('decodes multi-byte UTF-8 characters split across chunk boundaries', async () => {
+    const record = productRecord('rec-1', 'Café flat', 'Voilà — c’est chic');
+    const bytes = new TextEncoder().encode(`${record}\n`);
+    // Split inside the multi-byte sequence of “é”
+    const splitAt = bytes.findIndex(b => b === 0xc3) + 1;
+    mockStreamedResponse(streamFromByteChunks([bytes.slice(0, splitAt), bytes.slice(splitAt)]));
+
+    const results = await collectStream();
+
+    expect(results).toHaveLength(1);
+    expect(results[0].category).toBe(ResponseCategory.Product);
+    if (results[0].category === ResponseCategory.Product) {
+      expect(results[0].attributes.title).toBe('Café flat');
+      expect(results[0].attributes.description).toBe('Voilà — c’est chic');
+    }
+  });
+
+  it('drops a malformed line without breaking the rest of the stream', async () => {
+    const record = productRecord('rec-1', 'Survivor');
+    mockStreamedResponse(streamFromStringChunks([`{"not": "valid json"\n${record}\n[DONE]\n`]));
+
+    const results = await collectStream();
+
+    expect(results.map(r => r.id)).toEqual(['rec-1']);
+  });
+
+  it('strips SSE "data: " prefixes and skips [DONE] markers', async () => {
+    const record = productRecord('rec-1', 'Prefixed');
+    mockStreamedResponse(streamFromStringChunks([`data: ${record}\ndata: [DONE]\n`]));
+
+    const results = await collectStream();
+
+    expect(results.map(r => r.id)).toEqual(['rec-1']);
+  });
+});

package/src/application/commerce-api.ts

@@ -263,34 +263,24 @@ class CommerceApiClient {
         const reader = response.raw.body.getReader();
         const decoder = new TextDecoder('utf-8');
 
+        // Buffer holding the trailing incomplete line of the previous chunk
         let partial = '';
-        // TODO this function is recreated every time new data comes from the stream - define it outside of the generator
+
         const safeParse = (line: string): unknown => {
           try {
             return JSON.parse(line); // Parse the JSON string
           } catch (err) {
-            logger.logError('Error parsing streamed line', err, {
-              line,
-              partial,
-            });
-            // swallow the error and set the partial to our current chunk
-            partial = line;
-            return partial;
+            logger.logError('Error parsing streamed line', err, { line });
+            return null;
           }
         };
 
-        // TODO this function is recreated every time new data comes from the stream - define it outside of the generator
-        const processChunk = (chunk: string): unknown[] => {
-          // merge the partial with the incoming chunk
-          const lines = `${partial}${chunk}`.split('\n');
-
-          const parsedLines = lines
+        const parseLines = (lines: string[]): unknown[] =>
+          lines
             .map(line => line.replace(/^data: /, '').trim()) // Remove the "data: " prefix
             .filter(line => line !== '' && line !== '[DONE]') // Remove empty lines and "[DONE]"
             .map(safeParse)
-            .filter(v => v); // and filter out the undefined values
-          return parsedLines;
-        };
+            .filter(v => v != null);
 
         while (true) {
           // eslint-disable-next-line no-await-in-loop
@@ -300,11 +290,12 @@ class CommerceApiClient {
             break;
           }
 
-          // Massage and parse the chunk of data
-          const chunk = decoder.decode(value);
-          const parsedLines = processChunk(chunk);
+          // A chunk boundary can fall mid-line, so only parse the lines that
+          // are terminated by a newline and hold the rest until the next chunk
+          const lines = `${partial}${decoder.decode(value, { stream: true })}`.split('\n');
+          partial = lines.pop() ?? '';
 
-          for (const parsedLine of parsedLines) {
+          for (const parsedLine of parseLines(lines)) {
             const validatedResponse = validateResponse(parsedLine);
 
             if (validatedResponse) {
@@ -312,6 +303,15 @@ class CommerceApiClient {
             }
           }
         }
+
+        // Flush the remainder of a stream that didn't end with a newline
+        for (const parsedLine of parseLines([`${partial}${decoder.decode()}`])) {
+          const validatedResponse = validateResponse(parsedLine);
+
+          if (validatedResponse) {
+            yield validatedResponse;
+          }
+        }
       } catch (error: unknown) {
         logger.logError('Failed to get next streaming responses', error, {
           payloadContext: payload?.context,

package/src/application/logging/__tests__/logger.test.ts

@@ -0,0 +1,159 @@
+import Logger from 'src/application/logging/logger';
+import {
+  DEFAULT_LOG_LEVEL,
+  LOG_LEVEL_STORAGE_KEY,
+  getLogLevel,
+  isLevelEnabled,
+  resetLogLevelForTesting,
+  setLogLevel,
+} from 'src/application/logging/logLevel';
+
+const setHref = (href: string) => {
+  Object.defineProperty(window, 'location', {
+    configurable: true,
+    value: { ...window.location, href, search: new URL(href).search },
+  });
+};
+
+describe('logger log level', () => {
+  const originalHref = window.location.href;
+  let spies: ReturnType<typeof vi.spyOn>[] = [];
+  let logger: Logger;
+
+  beforeEach(() => {
+    resetLogLevelForTesting();
+    window.localStorage.clear();
+    setHref('https://merchant.example.com/products/thing');
+    delete (window as { _envive?: unknown })._envive;
+    delete (window as { _spiffy?: unknown })._spiffy;
+    logger = new Logger('testCaller');
+    spies = [
+      vi.spyOn(console, 'debug').mockImplementation(() => {}),
+      vi.spyOn(console, 'info').mockImplementation(() => {}),
+      vi.spyOn(console, 'warn').mockImplementation(() => {}),
+      vi.spyOn(console, 'error').mockImplementation(() => {}),
+    ];
+  });
+
+  afterEach(() => {
+    spies.forEach(spy => spy.mockRestore());
+    resetLogLevelForTesting();
+    setHref(originalHref);
+  });
+
+  const emitAll = () => {
+    logger.logDebug('d');
+    logger.logInfo('i');
+    logger.logWarn('w', undefined);
+    logger.logError('e', undefined);
+  };
+
+  const emitted = () => ({
+    debug: (console.debug as unknown as { mock: { calls: unknown[] } }).mock.calls.length,
+    info: (console.info as unknown as { mock: { calls: unknown[] } }).mock.calls.length,
+    warn: (console.warn as unknown as { mock: { calls: unknown[] } }).mock.calls.length,
+    error: (console.error as unknown as { mock: { calls: unknown[] } }).mock.calls.length,
+  });
+
+  it('mutes debug and info but keeps warn and error by default', () => {
+    expect(DEFAULT_LOG_LEVEL).toBe('warn');
+    expect(getLogLevel()).toBe('warn');
+
+    emitAll();
+
+    expect(emitted()).toEqual({ debug: 0, info: 0, warn: 1, error: 1 });
+  });
+
+  it('silences every level at "silent"', () => {
+    setLogLevel('silent');
+
+    emitAll();
+
+    expect(emitted()).toEqual({ debug: 0, info: 0, warn: 0, error: 0 });
+  });
+
+  it('emits every level at "debug"', () => {
+    setLogLevel('debug');
+
+    emitAll();
+
+    expect(emitted()).toEqual({ debug: 1, info: 1, warn: 1, error: 1 });
+  });
+
+  it('keeps the existing output format when a level is enabled', () => {
+    setLogLevel('debug');
+
+    logger.logDebug('a message', { extra: true });
+
+    expect(console.debug).toHaveBeenCalledWith(
+      expect.stringMatching(/^DEBUG: \[envive-ai\] .+ - testCaller - a message$/),
+      { extra: true },
+    );
+  });
+
+  it('honours the window override without a reload', () => {
+    expect(isLevelEnabled('debug')).toBe(false);
+
+    (window as { _envive?: { logLevel?: string } })._envive = { logLevel: 'debug' };
+
+    expect(isLevelEnabled('debug')).toBe(true);
+    expect(getLogLevel()).toBe('debug');
+  });
+
+  it('accepts the _spiffy window override and is case-insensitive', () => {
+    (window as { _spiffy?: { logLevel?: string } })._spiffy = { logLevel: 'DEBUG' };
+
+    expect(getLogLevel()).toBe('debug');
+  });
+
+  it('ignores an unrecognised level and falls back to the default', () => {
+    (window as { _envive?: { logLevel?: string } })._envive = { logLevel: 'chatty' };
+
+    expect(getLogLevel()).toBe(DEFAULT_LOG_LEVEL);
+  });
+
+  it('reads the level from the query param and persists it for later navigations', () => {
+    setHref('https://merchant.example.com/products/thing?envive_log_level=debug');
+
+    expect(getLogLevel()).toBe('debug');
+    expect(window.localStorage.getItem(LOG_LEVEL_STORAGE_KEY)).toBe('debug');
+  });
+
+  it('applies a persisted level on a page without the query param', () => {
+    window.localStorage.setItem(LOG_LEVEL_STORAGE_KEY, 'info');
+
+    expect(getLogLevel()).toBe('info');
+  });
+
+  it('lets the query param win over a level pinned programmatically', () => {
+    setHref('https://merchant.example.com/products/thing?envive_log_level=debug');
+    setLogLevel('silent');
+
+    expect(getLogLevel()).toBe('debug');
+  });
+
+  it('lets setLogLevel(undefined) fall back to the levers below it', () => {
+    window.localStorage.setItem(LOG_LEVEL_STORAGE_KEY, 'info');
+    setLogLevel('silent');
+    expect(getLogLevel()).toBe('silent');
+
+    setLogLevel(undefined);
+
+    expect(getLogLevel()).toBe('info');
+  });
+
+  it('survives localStorage throwing', () => {
+    const getItem = vi.spyOn(window.localStorage, 'getItem').mockImplementation(() => {
+      throw new Error('blocked');
+    });
+    const setItem = vi.spyOn(window.localStorage, 'setItem').mockImplementation(() => {
+      throw new Error('blocked');
+    });
+    setHref('https://merchant.example.com/products/thing?envive_log_level=debug');
+
+    expect(getLogLevel()).toBe('debug');
+
+    getItem.mockRestore();
+    setItem.mockRestore();
+  });
+});

package/src/application/logging/index.ts

@@ -0,0 +1,12 @@
+export { default } from 'src/application/logging/logger';
+export {
+  DEFAULT_LOG_LEVEL,
+  getLogLevel,
+  isLevelEnabled,
+  LOG_LEVEL_QUERY_PARAM,
+  LOG_LEVEL_STORAGE_KEY,
+  LOG_LEVELS,
+  resetLogLevelForTesting,
+  setLogLevel,
+} from 'src/application/logging/logLevel';
+export type { LogLevel } from 'src/application/logging/logLevel';