@envive-ai/react-hooks 0.3.44 → 0.3.46

package/dist/services/hardcopyService/hardcopyService.js

@@ -198,7 +198,8 @@ var HardcopyService = class {
 						widget_type: request.widgetType,
 						response_id: response.responseId,
 						widget_text: response.values,
-						request_id: widgetTextRequest.requestId
+						request_id: widgetTextRequest.requestId,
+						...response.aiSuggestionsAttributionBySlot ? { ai_suggestions_attribution_by_slot: response.aiSuggestionsAttributionBySlot } : {}
 					}
 				});
 				return convertedResponse;
@@ -228,4 +229,4 @@ var MockHardcopyService = class {
 
 //#endregion
 export { HardcopyService, MOCK_HARDCOPY_RESPONSE, MockHardcopyService };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"hardcopyService.js","names":["Logger","MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>>","uuid","config: HardcopyServiceConfig","widgetTextRequest: WidgetTextRequest","CommerceApiClient","overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>>"],"sources":["../../../src/services/hardcopyService/hardcopyService.ts"],"sourcesContent":["import { v4 as uuid } from 'uuid';\nimport CommerceApiClient from 'src/application/commerce-api';\nimport { WidgetString, WidgetText } from 'src/application/models/api/widgetText';\nimport { WidgetTextRequest } from 'src/application/models/api/widgetTextRequest';\nimport { toCamelCase } from 'src/application/models/utils/snakeToCamelTransformer';\nimport { getQueryParam } from 'src/application/utils';\nimport { UserEvent } from 'src/application/models';\nimport Logger from 'src/application/logging/logger';\nimport { AppDetails } from 'src/atoms/app';\nimport { getAtomStore } from 'src/atoms/atomStore/atomStore';\nimport { resolvedBaseConfigVersionAtom } from 'src/atoms/envive/resolvedBaseConfigVersion';\nimport { WidgetTypeV3 } from 'src/contexts/typesV3';\nimport { EnviveMetricsEventName, TrackEventParams } from '../amplitudeService';\n\nconst logger = new Logger('hardcopyService');\n\nexport interface HardcopyRequest {\n  widgetType: WidgetTypeV3;\n  userEvent: UserEvent;\n}\n\nexport type HardcopyResponse = {\n  responseId: string;\n  language: string;\n  rawValues?: Record<string, WidgetString | WidgetString[]>;\n  values: Record<string, string | string[]>;\n};\n\nexport interface IHardcopyService {\n  getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse>;\n}\n\nexport interface HardcopyServiceConfig {\n  getAppDetails: () => AppDetails;\n  getFeatureFlags: () => Record<string, boolean>;\n  trackEvent?: (params: TrackEventParams) => Promise<void>;\n}\n\n// Sample responses used both as fallback when the backend fails and by MockHardcopyService.\nexport const MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {\n  [WidgetTypeV3.PromptCarouselV3]: {\n    responseId: uuid(),\n    language: 'en',\n    values: {\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.TitledPromptCarouselV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.SocialProofV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      numberOfCustomersText: '123 customers',\n      customerQueryText: 'found what they were looking for...',\n      primaryButtonText: 'Start shopping',\n      secondaryButtonTitleText: 'Popular searches',\n      secondaryButtonTexts: [\n        'Why should I buy from you?',\n        'How do I return an item?',\n        'New arrivals',\n        'Sale items',\n        'Popular items',\n      ],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.TypingAnimationV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help finding',\n      animatedTextSequence: [\n        'the perfect gift for your loved ones?',\n        'something special for the holidays?',\n        'the ideal present for someone special?',\n      ],\n      hintText: 'Ask me anything',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n      ],\n      textFieldAriaLabel: 'Ask me anything',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewComparisonV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help comparing?',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewLoadingV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.PromptButtonCarouselWithImageV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonsTexts: ['Help me find a product', \"What's on your mind?\", 'Talk to a human'],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ProductCardV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      headline: 'Discover Your Perfect Style',\n      animatedText: [\n        'the perfect outfit for any occasion',\n        'trending fashion that fits your lifestyle',\n        'quality pieces that last',\n      ],\n      prompts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n      placeholder: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.FloatingChatV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n      leftToggleLabel: 'Shop with AI',\n      rightToggleLabel: 'Live support',\n    },\n  },\n  [WidgetTypeV3.FullPageSalesAgentV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n    },\n  },\n};\n\nconst convertToHardcopyResponse = (response: WidgetText): HardcopyResponse => ({\n  responseId: response.responseId,\n  language: response.language,\n  rawValues: response.values,\n  values: Object.fromEntries(\n    Object.entries(response.values).map(([key, value]) => [\n      toCamelCase(key),\n      value.length === 1 ? value[0].value : value.map(v => v.value),\n    ]),\n  ),\n});\n\nexport class HardcopyService implements IHardcopyService {\n  constructor(private config: HardcopyServiceConfig) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const overrideConfigVersion =\n      getQueryParam('spiffy_config_version') ||\n      getQueryParam('envive_config_version') ||\n      getAtomStore().get(resolvedBaseConfigVersionAtom) ||\n      undefined;\n\n    const widgetTextRequest: WidgetTextRequest = {\n      requestId: uuid(),\n      widgetType: request.widgetType,\n      context: this.config.getAppDetails(),\n      featureFlags: this.config.getFeatureFlags(),\n      language: navigator.languages[0] || 'en',\n      overrideConfigVersion,\n      url: window.location.href,\n    };\n\n    this.config.trackEvent?.({\n      eventName: EnviveMetricsEventName.WidgetTextRequest,\n      eventProps: {\n        widget_type: request.widgetType,\n        request_id: widgetTextRequest.requestId,\n      },\n    });\n\n    try {\n      const response = await CommerceApiClient.getHardcopy(widgetTextRequest);\n      if (response) {\n        const convertedResponse = convertToHardcopyResponse(response);\n        logger.logDebug('converted response', convertedResponse);\n        this.config.trackEvent?.({\n          eventName: EnviveMetricsEventName.WidgetTextResponse,\n          eventProps: {\n            widget_type: request.widgetType,\n            response_id: response.responseId,\n            widget_text: response.values,\n            request_id: widgetTextRequest.requestId,\n          },\n        });\n        return convertedResponse;\n      }\n    } catch (error) {\n      logger.logError('error getting hardcopy from backend', error);\n    }\n\n    const mockResponse = MOCK_HARDCOPY_RESPONSE[request.widgetType];\n    if (mockResponse) {\n      logger.logDebug('no real response, using mock', mockResponse);\n      return mockResponse;\n    }\n    throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n  }\n}\n\nexport class MockHardcopyService implements IHardcopyService {\n  constructor(private overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {}) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const fallbackWidgetType =\n      request.widgetType === WidgetTypeV3.ProductCardV3\n        ? WidgetTypeV3.ImagePromptCardV3\n        : request.widgetType;\n\n    const response =\n      this.overrides[request.widgetType] ??\n      this.overrides[fallbackWidgetType] ??\n      MOCK_HARDCOPY_RESPONSE[request.widgetType];\n\n    if (!response) {\n      throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n    }\n    return response;\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"hardcopyService.js","names":["Logger","MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>>","uuid","config: HardcopyServiceConfig","widgetTextRequest: WidgetTextRequest","CommerceApiClient","overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>>"],"sources":["../../../src/services/hardcopyService/hardcopyService.ts"],"sourcesContent":["import { v4 as uuid } from 'uuid';\nimport CommerceApiClient from 'src/application/commerce-api';\nimport { WidgetString, WidgetText } from 'src/application/models/api/widgetText';\nimport { WidgetTextRequest } from 'src/application/models/api/widgetTextRequest';\nimport { toCamelCase } from 'src/application/models/utils/snakeToCamelTransformer';\nimport { getQueryParam } from 'src/application/utils';\nimport { UserEvent } from 'src/application/models';\nimport Logger from 'src/application/logging/logger';\nimport { AppDetails } from 'src/atoms/app';\nimport { getAtomStore } from 'src/atoms/atomStore/atomStore';\nimport { resolvedBaseConfigVersionAtom } from 'src/atoms/envive/resolvedBaseConfigVersion';\nimport { WidgetTypeV3 } from 'src/contexts/typesV3';\nimport { EnviveMetricsEventName, TrackEventParams } from '../amplitudeService';\n\nconst logger = new Logger('hardcopyService');\n\nexport interface HardcopyRequest {\n  widgetType: WidgetTypeV3;\n  userEvent: UserEvent;\n}\n\nexport type HardcopyResponse = {\n  responseId: string;\n  language: string;\n  rawValues?: Record<string, WidgetString | WidgetString[]>;\n  values: Record<string, string | string[]>;\n};\n\nexport interface IHardcopyService {\n  getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse>;\n}\n\nexport interface HardcopyServiceConfig {\n  getAppDetails: () => AppDetails;\n  getFeatureFlags: () => Record<string, boolean>;\n  trackEvent?: (params: TrackEventParams) => Promise<void>;\n}\n\n// Sample responses used both as fallback when the backend fails and by MockHardcopyService.\nexport const MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {\n  [WidgetTypeV3.PromptCarouselV3]: {\n    responseId: uuid(),\n    language: 'en',\n    values: {\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.TitledPromptCarouselV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.SocialProofV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      numberOfCustomersText: '123 customers',\n      customerQueryText: 'found what they were looking for...',\n      primaryButtonText: 'Start shopping',\n      secondaryButtonTitleText: 'Popular searches',\n      secondaryButtonTexts: [\n        'Why should I buy from you?',\n        'How do I return an item?',\n        'New arrivals',\n        'Sale items',\n        'Popular items',\n      ],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.TypingAnimationV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help finding',\n      animatedTextSequence: [\n        'the perfect gift for your loved ones?',\n        'something special for the holidays?',\n        'the ideal present for someone special?',\n      ],\n      hintText: 'Ask me anything',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n      ],\n      textFieldAriaLabel: 'Ask me anything',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewComparisonV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help comparing?',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewLoadingV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.PromptButtonCarouselWithImageV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonsTexts: ['Help me find a product', \"What's on your mind?\", 'Talk to a human'],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ProductCardV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      headline: 'Discover Your Perfect Style',\n      animatedText: [\n        'the perfect outfit for any occasion',\n        'trending fashion that fits your lifestyle',\n        'quality pieces that last',\n      ],\n      prompts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n      placeholder: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.FloatingChatV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n      leftToggleLabel: 'Shop with AI',\n      rightToggleLabel: 'Live support',\n    },\n  },\n  [WidgetTypeV3.FullPageSalesAgentV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n    },\n  },\n};\n\nconst convertToHardcopyResponse = (response: WidgetText): HardcopyResponse => ({\n  responseId: response.responseId,\n  language: response.language,\n  rawValues: response.values,\n  values: Object.fromEntries(\n    Object.entries(response.values).map(([key, value]) => [\n      toCamelCase(key),\n      value.length === 1 ? value[0].value : value.map(v => v.value),\n    ]),\n  ),\n});\n\nexport class HardcopyService implements IHardcopyService {\n  constructor(private config: HardcopyServiceConfig) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const overrideConfigVersion =\n      getQueryParam('spiffy_config_version') ||\n      getQueryParam('envive_config_version') ||\n      getAtomStore().get(resolvedBaseConfigVersionAtom) ||\n      undefined;\n\n    const widgetTextRequest: WidgetTextRequest = {\n      requestId: uuid(),\n      widgetType: request.widgetType,\n      context: this.config.getAppDetails(),\n      featureFlags: this.config.getFeatureFlags(),\n      language: navigator.languages[0] || 'en',\n      overrideConfigVersion,\n      url: window.location.href,\n    };\n\n    this.config.trackEvent?.({\n      eventName: EnviveMetricsEventName.WidgetTextRequest,\n      eventProps: {\n        widget_type: request.widgetType,\n        request_id: widgetTextRequest.requestId,\n      },\n    });\n\n    try {\n      const response = await CommerceApiClient.getHardcopy(widgetTextRequest);\n      if (response) {\n        const convertedResponse = convertToHardcopyResponse(response);\n        logger.logDebug('converted response', convertedResponse);\n        this.config.trackEvent?.({\n          eventName: EnviveMetricsEventName.WidgetTextResponse,\n          eventProps: {\n            widget_type: request.widgetType,\n            response_id: response.responseId,\n            widget_text: response.values,\n            request_id: widgetTextRequest.requestId,\n            // Which method served each overridden slot — training/attribution\n            // reads this from the analytics event; passed through verbatim.\n            ...(response.aiSuggestionsAttributionBySlot\n              ? { ai_suggestions_attribution_by_slot: response.aiSuggestionsAttributionBySlot }\n              : {}),\n          },\n        });\n        return convertedResponse;\n      }\n    } catch (error) {\n      logger.logError('error getting hardcopy from backend', error);\n    }\n\n    const mockResponse = MOCK_HARDCOPY_RESPONSE[request.widgetType];\n    if (mockResponse) {\n      logger.logDebug('no real response, using mock', mockResponse);\n      return mockResponse;\n    }\n    throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n  }\n}\n\nexport class MockHardcopyService implements IHardcopyService {\n  constructor(private overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {}) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const fallbackWidgetType =\n      request.widgetType === WidgetTypeV3.ProductCardV3\n        ? WidgetTypeV3.ImagePromptCardV3\n        : request.widgetType;\n\n    const response =\n      this.overrides[request.widgetType] ??\n      this.overrides[fallbackWidgetType] ??\n      MOCK_HARDCOPY_RESPONSE[request.widgetType];\n\n    if (!response) {\n      throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n    }\n    return response;\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@envive-ai/react-hooks",
-  "version": "0.3.44",
+  "version": "0.3.46",
   "description": "React hooks for connecting to Envive AI services.",
   "keywords": [
     "react",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@amplitude/analytics-browser": "2.23.7",
-    "@spiffy-ai/commerce-api-client": "1.1.0-SNAPSHOT.202603181358",
+    "@spiffy-ai/commerce-api-client": "1.1.0-SNAPSHOT.202607020921",
     "@envive-ai/analytics": "1.0.28",
     "fuse.js": "^7.1.0",
     "jotai": "^2.14.0",

package/src/application/models/api/responseGenerics.ts

@@ -43,11 +43,14 @@ export interface ApiReviewResponseAttributes {
   onClick?: () => void;
 }
 
+export type PageSourceType = 'faq_scrape' | 'product_info_scrape';
+
 export interface ApiPageResponseAttributes {
   id?: string;
   title?: string;
   description?: string;
   url?: string;
+  source_type?: PageSourceType;
 }
 
 export interface ApiFormResponseSchemaAttributes {

package/src/application/models/api/widgetText.ts

@@ -8,4 +8,7 @@ export type WidgetText = {
   requestId: string;
   language: string;
   values: Record<string, WidgetString[]>;
+  // Served-method attribution keyed by overridden slot name. Forwarded verbatim
+  // to the widget-text analytics events; the frontend never interprets it.
+  aiSuggestionsAttributionBySlot?: Record<string, unknown> | null;
 };

package/src/application/models/validators/validateResponse.ts

@@ -103,6 +103,7 @@ export const validateResponse = (data: unknown): Response | undefined => {
         title: data.attributes.title,
         description: data.attributes.description,
         url: data.attributes.url,
+        sourceType: data.attributes.source_type,
       },
     };
   }

package/src/application/utils/widgetTextFromApiWidgetTextResponse.ts

@@ -29,4 +29,5 @@ export const apiWidgetTextResponseToCoreWidgetText = (
       value.map(apiWidgetStringToCoreWidgetString),
     ]),
   ),
+  aiSuggestionsAttributionBySlot: apiWidgetTextResponse.ai_suggestions_attribution_by_slot,
 });

package/src/atoms/app/variant.ts

@@ -255,7 +255,7 @@ const getPageVisitContext = (pageVisitCategory: PageVisitCategory | undefined) =
   }
   if (pageVisitCategory === PageVisitCategory.FullPage) {
     return {
-      page_type: 'full_page',
+      page_type: 'adaptive_storefront',
       page_id: window.location.href,
     };
   }

package/src/contexts/pageContext/pageContext.tsx

@@ -176,7 +176,7 @@ export const PageProvider: React.FC<{
         pageId = variantInfo.url;
         break;
       case VariantTypeEnum.FullPageSalesAgent:
-        pageType = 'full_page_sales_agent';
+        pageType = 'adaptive_storefront';
         pageId = variantInfo.url;
         break;
       default:

package/src/contexts/salesAgentContext/salesAgentContext.tsx

@@ -10,6 +10,7 @@ import {
   pendingResponseAtom,
   responseStreamingAtom,
   suggestionsAtom,
+  suggestionsLoadingAtom,
 } from 'src/atoms/chat/chatState';
 import {
   processUserEventAtom,
@@ -36,6 +37,9 @@ export interface SalesAgent extends SalesAgentChatAPI {
   isResponseStreaming: boolean;
   // True while the response is pending from the backend
   isPendingResponse: boolean;
+  // True while suggestions for the most recent message are being fetched (separate from the
+  // message response itself — suggestions are requested as a follow-up call once it completes)
+  isLoadingSuggestions: boolean;
   // True when the sales agent is initialized
   isInitialized: boolean;
 }
@@ -227,6 +231,7 @@ export const useSalesAgent = (contextWidget?: WidgetInteractionComponent): Sales
   const pendingMessages = useAtomValue(userEventQueueAtom);
   const isResponseStreaming = useAtomValue(responseStreamingAtom);
   const isPendingResponse = useAtomValue(pendingResponseAtom);
+  const isLoadingSuggestions = useAtomValue(suggestionsLoadingAtom);
   const isInitialized = useAtomValue(initializedAtom);
   const {
     logPageVisit,
@@ -244,6 +249,7 @@ export const useSalesAgent = (contextWidget?: WidgetInteractionComponent): Sales
       isInitialized,
       isResponseStreaming,
       isPendingResponse,
+      isLoadingSuggestions,
       logPageVisit,
       logUserEvent,
       onSuggestionClicked,
@@ -257,6 +263,7 @@ export const useSalesAgent = (contextWidget?: WidgetInteractionComponent): Sales
     isInitialized,
     isResponseStreaming,
     isPendingResponse,
+    isLoadingSuggestions,
     logPageVisit,
     logUserEvent,
     onSuggestionClicked,

package/src/contexts/salesAgentContext/salesAgentService.ts

@@ -22,6 +22,7 @@ import {
   requestFailureAtom,
   responseStreamingAtom,
   suggestionsAtom,
+  suggestionsLoadingAtom,
 } from 'src/atoms/chat/chatState';
 import { useAmplitude } from 'src/contexts/amplitudeContext';
 import { useFeatureFlagService } from 'src/contexts/featureFlagServiceContext';
@@ -242,6 +243,7 @@ export const useSalesAgentService: () => SalesAgentService = () => {
   const setSuggestions = useSetAtom(suggestionsAtom);
   const setPendingResponse = useSetAtom(pendingResponseAtom);
   const setResponseStreaming = useSetAtom(responseStreamingAtom);
+  const setSuggestionsLoading = useSetAtom(suggestionsLoadingAtom);
   const analyticsContext = useAtomValue(analyticsContextAtom);
   const messageInterceptor = useMessageInterceptor();
   const { trackEvent } = useAmplitude();
@@ -285,6 +287,7 @@ export const useSalesAgentService: () => SalesAgentService = () => {
       let successfulResponse: boolean | undefined;
       setPendingResponse(true);
       setSuggestions([]);
+      setSuggestionsLoading(true);
       const stream = CommerceApiClient.getNextResponseStreaming(payload);
       let responseAnalytics: Record<string, unknown> | undefined;
       try {
@@ -360,6 +363,7 @@ export const useSalesAgentService: () => SalesAgentService = () => {
       // logPerfMetric,
       setRequestFailure,
       setSuggestions,
+      setSuggestionsLoading,
       messageInterceptor,
       setMessages,
       setPendingResponse,
@@ -368,10 +372,15 @@ export const useSalesAgentService: () => SalesAgentService = () => {
 
   const getSuggestions = useCallback(
     async (payload: NextMessageRequest): Promise<void> => {
-      const newSuggestions = await CommerceApiClient.getNextSuggestions(payload);
-      setSuggestions(newSuggestions);
+      setSuggestionsLoading(true);
+      try {
+        const newSuggestions = await CommerceApiClient.getNextSuggestions(payload);
+        setSuggestions(newSuggestions);
+      } finally {
+        setSuggestionsLoading(false);
+      }
     },
-    [setSuggestions],
+    [setSuggestions, setSuggestionsLoading],
   );
 
   const hydrateMessages = useCallback(async () => {

package/src/hooks/PageViewedEvent/__tests__/usePageViewedEvent.test.ts

@@ -100,13 +100,13 @@ describe('extractPageViewedContext', () => {
     });
   });
 
-  it('should return full_page_sales_agent context', () => {
+  it('should return adaptive_storefront context', () => {
     const variant: FullPageSalesAgentVariantInfo = {
       variantType: VariantTypeEnum.FullPageSalesAgent,
       url: 'https://example.com/agent',
     };
     expect(extractPageViewedContext(variant)).toEqual({
-      page_type: 'full_page_sales_agent',
+      page_type: 'adaptive_storefront',
       page_id: 'https://example.com/agent',
     });
   });
@@ -238,7 +238,7 @@ describe('usePageViewedEvent', () => {
     expect(mockTrackEvent).toHaveBeenCalledTimes(1);
   });
 
-  it('should fire with full_page_sales_agent page type', () => {
+  it('should fire with adaptive_storefront page type', () => {
     mockUsePage.mockReturnValue({
       variantInfo: {
         variantType: VariantTypeEnum.FullPageSalesAgent,
@@ -257,7 +257,7 @@ describe('usePageViewedEvent', () => {
     expect(mockTrackEvent).toHaveBeenCalledWith({
       eventName: EnviveMetricsEventName.PageViewed,
       eventProps: {
-        'context.page_type': 'full_page_sales_agent',
+        'context.page_type': 'adaptive_storefront',
         'context.page_id': 'https://example.com/agent',
         'context.supported': true,
         'context.ready': true,

package/src/hooks/PageViewedEvent/usePageViewedEvent.ts

@@ -50,7 +50,7 @@ export const extractPageViewedContext = (
       };
     case VariantTypeEnum.FullPageSalesAgent:
       return {
-        page_type: 'full_page_sales_agent',
+        page_type: 'adaptive_storefront',
         page_id: (pageVariant as FullPageSalesAgentVariantInfo).url,
       };
     default:

package/src/hooks/WidgetInteraction/types.ts

@@ -30,7 +30,7 @@ export enum WidgetInteractionPageType {
   HOMEPAGE = 'homepage',
   SEARCH = 'search',
   OTHER = 'other',
-  FULL_PAGE = 'full_page',
+  ADAPTIVE_STOREFRONT = 'adaptive_storefront',
 }
 
 export enum WidgetInteractionComponent {

package/src/hooks/WidgetInteraction/utils.ts

@@ -36,7 +36,7 @@ export const extractPageContext = (
     case VariantTypeEnum.FullPageSalesAgent:
       return {
         page_id: (pageVariant as FullPageSalesAgentVariantInfo).url,
-        page_type: WidgetInteractionPageType.FULL_PAGE,
+        page_type: WidgetInteractionPageType.ADAPTIVE_STOREFRONT,
       };
     default:
       return null;

package/src/services/amplitudeService/amplitudeService.ts

@@ -296,6 +296,7 @@ export class AmplitudeService {
     switch (widgetType) {
       case WidgetTypeV3.FloatingButtonV3:
         return 'floating_button';
+      case WidgetTypeV3.TypingAnimationV3:
       case WidgetTypeV3.ChatPreviewV3:
       case WidgetTypeV3.SocialProofV3:
         return 'embedded_widget';

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

@@ -0,0 +1,208 @@
+import { EnviveConfigService } from '../enviveConfigService';
+
+const mockFetch = vi.fn();
+globalThis.fetch = mockFetch;
+
+const ORG_CONFIG_RESPONSE = {
+  org: {
+    org: {
+      id: 'org-1',
+      short_name: 'test-org',
+      display_name: 'Test Org',
+      domain: 'test.com',
+      status: 'active',
+      created_at: '2024-01-01T00:00:00.000Z',
+      updated_at: '2024-01-01T00:00:00.000Z',
+    },
+  },
+  gates: [],
+};
+
+function makeOkOrgConfigFetch(overrides: Record<string, unknown> = {}) {
+  mockFetch.mockResolvedValueOnce({
+    ok: true,
+    json: () => Promise.resolve({ ...ORG_CONFIG_RESPONSE, ...overrides }),
+  });
+}
+
+// productsConfig has no colors, so fetchGraphQLConfig falls back to its mock
+// config (see fetchGraphQLConfig.test.ts "no colors fallback") - fine here
+// since these tests only care about caching/fetch-count behaviour.
+function makeOkGraphqlFetch() {
+  mockFetch.mockResolvedValueOnce({
+    ok: true,
+    json: () => Promise.resolve({ data: { me: { getProductsConfigByVersion: {} } } }),
+  });
+}
+
+function makeService(
+  overrides: Partial<ConstructorParameters<typeof EnviveConfigService>[0]> = {},
+) {
+  return new EnviveConfigService({
+    baseUrl: 'https://api.example.com',
+    apiKey: 'key',
+    userId: 'user-1',
+    namespace: 'spiffy-react-components',
+    source: 'app',
+    ...overrides,
+  });
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  sessionStorage.clear();
+  window.history.replaceState({}, '', '/');
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+});
+
+describe('EnviveConfigService caching', () => {
+  it('fetches org config + GraphQL config on a cold cache', async () => {
+    makeOkOrgConfigFetch();
+    makeOkGraphqlFetch();
+
+    const result = await makeService().getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(result.org.org.id).toBe('org-1');
+  });
+
+  it('serves a warm cache to a new instance with identical params without hitting the network', async () => {
+    makeOkOrgConfigFetch();
+    makeOkGraphqlFetch();
+    await makeService().getEnviveConfig();
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+
+    // A fresh instance (as happens on the next page navigation) should read
+    // from the sessionStorage cache instead of refetching.
+    const result = await makeService().getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(result.org.org.id).toBe('org-1');
+  });
+
+  it('refetches once the cache entry has expired past the 5-minute TTL', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-01-01T00:00:00.000Z'));
+
+    makeOkOrgConfigFetch();
+    makeOkGraphqlFetch();
+    await makeService().getEnviveConfig();
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+
+    vi.setSystemTime(new Date('2026-01-01T00:05:01.000Z'));
+
+    makeOkOrgConfigFetch();
+    makeOkGraphqlFetch();
+    await makeService().getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(4);
+  });
+
+  it.each(['envive_config_version', 'spiffy_config_version'])(
+    'always bypasses the cache (read and write) when %s is present',
+    async param => {
+      window.history.replaceState({}, '', `/?${param}=1.2.3`);
+
+      makeOkOrgConfigFetch();
+      makeOkGraphqlFetch();
+      await makeService().getEnviveConfig();
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+
+      makeOkOrgConfigFetch();
+      makeOkGraphqlFetch();
+      await makeService().getEnviveConfig();
+
+      // No cache read/write happened, so a second instance refetches instead
+      // of reusing anything the first instance stored.
+      expect(mockFetch).toHaveBeenCalledTimes(4);
+    },
+  );
+
+  it('does not read a version-pinned cache entry after the override is removed', async () => {
+    window.history.replaceState({}, '', '/?envive_config_version=1.2.3');
+    makeOkOrgConfigFetch();
+    makeOkGraphqlFetch();
+    await makeService().getEnviveConfig();
+
+    window.history.replaceState({}, '', '/');
+    makeOkOrgConfigFetch();
+    makeOkGraphqlFetch();
+    await makeService().getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(4);
+  });
+
+  it('keeps separate cache entries per userId', async () => {
+    makeOkOrgConfigFetch();
+    makeOkGraphqlFetch();
+    await makeService({ userId: 'user-1' }).getEnviveConfig();
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+
+    makeOkOrgConfigFetch();
+    makeOkGraphqlFetch();
+    await makeService({ userId: 'user-2' }).getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(4);
+  });
+
+  it('keeps separate cache entries per namespace/source/baseUrl/apiKey', async () => {
+    makeOkOrgConfigFetch();
+    makeOkGraphqlFetch();
+    await makeService({ namespace: 'ns-a' }).getEnviveConfig();
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+
+    makeOkOrgConfigFetch();
+    makeOkGraphqlFetch();
+    await makeService({ namespace: 'ns-b' }).getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(4);
+  });
+
+  it('fails open and still returns config when sessionStorage.setItem throws', async () => {
+    vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
+      throw new Error('quota exceeded');
+    });
+
+    makeOkOrgConfigFetch();
+    makeOkGraphqlFetch();
+
+    const result = await makeService().getEnviveConfig();
+
+    expect(result.org.org.id).toBe('org-1');
+  });
+
+  it('fails open and refetches when sessionStorage.getItem throws', async () => {
+    vi.spyOn(Storage.prototype, 'getItem').mockImplementation(() => {
+      throw new Error('storage disabled');
+    });
+
+    makeOkOrgConfigFetch();
+    makeOkGraphqlFetch();
+
+    const result = await makeService().getEnviveConfig();
+
+    expect(result.org.org.id).toBe('org-1');
+  });
+
+  it('fails open and refetches when a cached entry is corrupted JSON', async () => {
+    const service = makeService();
+    // Seed a corrupted entry under whatever key the service reads from by
+    // populating every session storage key with garbage after a real write,
+    // then corrupting it directly.
+    makeOkOrgConfigFetch();
+    makeOkGraphqlFetch();
+    await service.getEnviveConfig();
+    const [key] = Object.keys(sessionStorage);
+    sessionStorage.setItem(key, 'not json');
+
+    makeOkOrgConfigFetch();
+    makeOkGraphqlFetch();
+    const result = await makeService().getEnviveConfig();
+
+    expect(result.org.org.id).toBe('org-1');
+  });
+});

package/src/services/enviveConfigService/enviveConfigService.ts

@@ -2,8 +2,20 @@ import { OrgConfigExperimentAssignment, OrgConfigFeatureGate } from 'src/applica
 import { FeatureGates } from 'src/application/models/featureGates';
 import { FeatureFlagService } from 'src/contexts/featureFlagServiceContext';
 import { GraphQlConfigValues } from 'src/contexts/graphqlContext';
+import { configVersionOverride } from 'src/types/config-versions';
 import { fetchGraphQLConfig, fetchUnifiedGraphQLConfig } from './fetchGraphQLConfig';
 
+// Short-lived so config changes (gates, experiments) still propagate within
+// a session, while sparing every page navigation from re-fetching org
+// config + GraphQL config, both of which sit on the critical path before
+// first paint.
+const CONFIG_CACHE_TTL_MS = 5 * 60 * 1000;
+
+type CachedConfigEntry = {
+  value: EnviveServiceConfig;
+  expiresAt: number;
+};
+
 type EnviveConfigServiceProps = {
   baseUrl: string;
   apiKey: string;
@@ -63,10 +75,57 @@ export class EnviveConfigService implements IEnviveConfigService {
     this.source = source;
   }
 
+  private getCacheKey(): string {
+    return `envive-config-cache:${this.baseUrl}:${this.apiKey}:${this.userId}:${this.namespace}:${this.source}`;
+  }
+
+  // `envive_config_version` / `spiffy_config_version` pin a specific config
+  // version for debugging/rollback. Any use of that override must always
+  // bypass the cache below — both reading a stale entry and writing one
+  // under the shared key would defeat the override's purpose.
+  private readCachedConfig(): EnviveServiceConfig | null {
+    if (configVersionOverride()) {
+      return null;
+    }
+    try {
+      const raw = sessionStorage.getItem(this.getCacheKey());
+      if (!raw) {
+        return null;
+      }
+      const entry = JSON.parse(raw) as CachedConfigEntry;
+      if (Date.now() >= entry.expiresAt) {
+        return null;
+      }
+      return entry.value;
+    } catch {
+      return null;
+    }
+  }
+
+  private writeCachedConfig(value: EnviveServiceConfig): void {
+    if (configVersionOverride()) {
+      return;
+    }
+    try {
+      const entry: CachedConfigEntry = { value, expiresAt: Date.now() + CONFIG_CACHE_TTL_MS };
+      sessionStorage.setItem(this.getCacheKey(), JSON.stringify(entry));
+    } catch {
+      // Storage disabled, full, or unavailable (private browsing, etc.) -
+      // fail open and let the next call re-fetch instead of caching.
+    }
+  }
+
   async getEnviveConfig(): Promise<EnviveServiceConfig> {
     if (this.response !== null) {
       return this.response;
     }
+
+    const cached = this.readCachedConfig();
+    if (cached !== null) {
+      this.response = cached;
+      return this.response;
+    }
+
     const queryParams = new URLSearchParams({
       namespace: this.namespace,
       source: this.source,
@@ -106,6 +165,7 @@ export class EnviveConfigService implements IEnviveConfigService {
       : await fetchGraphQLConfig(this.baseUrl, this.apiKey);
 
     this.response = { ...orgConfigResponse, orgConfig };
+    this.writeCachedConfig(this.response);
     return this.response;
   }
 }