@envive-ai/react-hooks 0.3.45 → 0.3.47

package/src/application/commerce-api.ts

@@ -28,6 +28,10 @@ import {
   UserEvent,
 } from 'src/application/models';
 import { OrgConfig } from 'src/application/models/api/orgConfigResults';
+import {
+  ProductDetails,
+  getProductOptionsQuery,
+} from 'src/application/models/graphql/queries/getProductOptionsQuery';
 import { ProductExperiment } from 'src/application/models/productExperiment';
 import { validateOrgConfigResults } from 'src/application/models/validators/validateOrgConfigResults';
 import { validateResponse } from 'src/application/models/validators/validateResponse';
@@ -35,6 +39,7 @@ import { validateSuggestion } from 'src/application/models/validators/validateSu
 import { validateUserEvent } from 'src/application/models/validators/validateUserEvent';
 import {
   getQueryParam,
+  messageFromAddToCartEvent,
   messageFromQueryEvent,
   messageFromResponse,
   messageFromSuggestionEvent,
@@ -146,7 +151,26 @@ class CommerceApiClient {
     this.productsApi = new ProductsApi(config);
   }
 
+  // Dedupes concurrent resolutions of the same URL: the injection bundle
+  // warms this call before React mounts, and PageProvider may request the
+  // same URL while the warm-up is still in flight.
+  private static inFlightUrlResolutions = new Map<string, Promise<unknown>>();
+
   static resolveUrl = async (url: string) => {
+    const inFlight = CommerceApiClient.inFlightUrlResolutions.get(url);
+    if (inFlight) {
+      return inFlight;
+    }
+    const request = CommerceApiClient.resolveUrlUncached(url);
+    CommerceApiClient.inFlightUrlResolutions.set(url, request);
+    try {
+      return await request;
+    } finally {
+      CommerceApiClient.inFlightUrlResolutions.delete(url);
+    }
+  };
+
+  private static resolveUrlUncached = async (url: string) => {
     const atomStore = getAtomStore();
     const orgShortName = atomStore.get(orgShortNameAtom);
     const orgId = atomStore.get(orgIdAtom);
@@ -405,33 +429,64 @@ class CommerceApiClient {
       )
       .filter(turn => turn.length > 0);
 
-    const userMessages: Message[][] = userEvents
-      .map(event => {
-        if ([UserEventCategory.QueryTyped, UserEventCategory.Search].includes(event.category)) {
-          return [messageFromQueryEvent(event)];
-        }
+    const userMessages: Message[][] = (
+      await Promise.all(
+        userEvents.map(async event => {
+          if ([UserEventCategory.QueryTyped, UserEventCategory.Search].includes(event.category)) {
+            return [messageFromQueryEvent(event)];
+          }
 
-        if (event.category === UserEventCategory.SuggestionClicked) {
-          return [messageFromSuggestionEvent(event, suggestions)];
-        }
+          if (event.category === UserEventCategory.SuggestionClicked) {
+            return [messageFromSuggestionEvent(event, suggestions)];
+          }
 
-        if (event.category === UserEventCategory.FormSubmitted) {
-          const formResponse = responses
-            .flat()
-            .find(
-              response =>
-                response.id === event.attributes.formResponseId &&
-                event.attributes.formType !== FormType.Escalation,
-            );
-
-          if (formResponse && formResponse.category === ResponseCategory.Form) {
-            return [messageFromFormSubmittedEvent(event, formResponse.attributes)];
+          if (event.category === UserEventCategory.AddToCart) {
+            // Historical events never carried a client-local productTitle (it's
+            // dropped before hitting the backend), so resolve it here: first for
+            // free from a matching Product response already fetched above, then
+            // as a fallback via the cached product-details call.
+            const matchedProduct = responses
+              .flat()
+              .find(
+                response =>
+                  response.category === ResponseCategory.Product &&
+                  response.attributes.id === event.attributes.productId,
+              );
+            let productTitle =
+              matchedProduct?.category === ResponseCategory.Product
+                ? matchedProduct.attributes.title
+                : undefined;
+            if (!productTitle) {
+              try {
+                const details = await CommerceApiClient.retrieveProductDetails(
+                  event.attributes.productId,
+                );
+                productTitle = details?.title;
+              } catch {
+                productTitle = undefined;
+              }
+            }
+            return [messageFromAddToCartEvent(event, productTitle)];
+          }
+
+          if (event.category === UserEventCategory.FormSubmitted) {
+            const formResponse = responses
+              .flat()
+              .find(
+                response =>
+                  response.id === event.attributes.formResponseId &&
+                  event.attributes.formType !== FormType.Escalation,
+              );
+
+            if (formResponse && formResponse.category === ResponseCategory.Form) {
+              return [messageFromFormSubmittedEvent(event, formResponse.attributes)];
+            }
           }
-        }
 
-        return [];
-      })
-      .filter((message): message is Message[] => message.length > 0);
+          return [];
+        }),
+      )
+    ).filter((message): message is Message[] => message.length > 0);
 
     // Sort the messages chronologically to reconstruct the chat history
     const sortedMessages = [...assistantMessages, ...userMessages].sort(
@@ -494,6 +549,70 @@ class CommerceApiClient {
     }
   };
 
+  // Caches resolved product details by productId for the lifetime of the
+  // session: variant selection, the display of the add-to-cart chat message,
+  // and useProductDetails all resolve the same product repeatedly. Failed
+  // requests are evicted so a later call can retry.
+  private static productDetailsCache = new Map<string, Promise<ProductDetails | undefined>>();
+
+  static retrieveProductDetails = (productId: string): Promise<ProductDetails | undefined> => {
+    const cached = CommerceApiClient.productDetailsCache.get(productId);
+    if (cached) {
+      return cached;
+    }
+    const request = CommerceApiClient.retrieveProductDetailsUncached(productId).catch(err => {
+      CommerceApiClient.productDetailsCache.delete(productId);
+      throw err;
+    });
+    CommerceApiClient.productDetailsCache.set(productId, request);
+    return request;
+  };
+
+  /**
+   * Retrieves variant-level product details for a single product via the GraphQL
+   * `me.productOptions` query on POST /v1/graphql. Only meaningful for products
+   * that offer variations.
+   *
+   * @param productId - The product ID to retrieve details for
+   * @returns ProductDetails, or undefined when the product has no options data
+   * @throws on network/HTTP failure or GraphQL errors
+   */
+  private static retrieveProductDetailsUncached = async (
+    productId: string,
+  ): Promise<ProductDetails | undefined> => {
+    const atomStore = getAtomStore();
+    const baseUrl = atomStore.get(baseUrlAtom);
+    const apiKey = atomStore.get(orgLevelApiKeyAtom);
+
+    try {
+      const response = await fetch(`${baseUrl}/v1/graphql`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          query: getProductOptionsQuery(),
+          variables: { productId },
+        }),
+      });
+
+      if (!response.ok) {
+        throw new ResponseError(response, `GraphQL request failed: ${response.statusText}`);
+      }
+
+      const result = await response.json();
+      if (result.errors) {
+        throw new Error(`GraphQL errors: ${JSON.stringify(result.errors)}`);
+      }
+
+      return result.data?.me?.productOptions ?? undefined;
+    } catch (err) {
+      await throwSessionRestartRequiredIf('Failed to retrieve product details', err);
+      return undefined;
+    }
+  };
+
   /**
    *
    * @param payload

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

@@ -12,7 +12,14 @@ import {
 import { CamelCasedPropertiesDeep } from 'src/application/models/utilityTypes';
 
 // TODO flatten these out or explore new typescript openapi generator fork
-export interface PDPAttributes extends CamelCasedPropertiesDeep<ApiPDPAttributes> {}
+export interface PDPAttributes extends CamelCasedPropertiesDeep<ApiPDPAttributes> {
+  /**
+   * Client-local only: never serialized to the backend (coreUserEventToApiUserEvent
+   * hand-picks fields and ignores this one). Lets the live add-to-cart chat message
+   * show a resolved product title instead of the raw productId.
+   */
+  productTitle?: string;
+}
 
 export interface PLPAttributes extends CamelCasedPropertiesDeep<ApiPLPAttributes> {}
 

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/featureGates.ts

@@ -27,6 +27,11 @@ export enum FeatureGates {
   IsAiSuggestionsVariantEnabled = 'is_ai_suggestions_variant_enabled',
   IsAiSuggestionsVariantAEnabled = 'is_ai_suggestions_variant_a_enabled',
   IsAiSuggestionsVariantBEnabled = 'is_ai_suggestions_variant_b_enabled',
+  // Serves the agentic storefront (FullPageSalesAgentV3 welcome overlay)
+  // independently of the pdp/plp variant_b experiment. The backend serves the
+  // storefront under this gate and falls back to variant_b only until this
+  // ships, so an org can run the storefront without opting pdp/plp into variant_b.
+  IsAiSuggestionsStorefrontEnabled = 'is_ai_suggestions_storefront_enabled',
   IsVoiceInputEnabled = 'is_voice_input_enabled',
   // Statsig experiments / unified getWidgetConfig endpoint migration. When
   // true, EnviveConfigService calls getWidgetConfig (experiment-aware)

package/src/application/models/graphql/queries/getProductOptionsQuery.ts

@@ -0,0 +1,59 @@
+// Fetches variant-level product details (options, availability, pricing,
+// images) for a single product. Only meaningful for products that offer
+// variations — non-variant PDP surfaces should keep using the REST
+// /v1/products/retrieve path (CommerceApiClient.retrieveProducts).
+export const getProductOptionsQuery = () => `
+  query($productId: String!) {
+    me {
+      productOptions(productId: $productId) {
+        productId
+        virtualParentId
+        title
+        options {
+          name
+          values
+        }
+        variants {
+          variantId
+          available
+          originalPrice
+          salePrice
+          imageUrl
+          url
+          options {
+            name
+            value
+          }
+        }
+      }
+    }
+  }
+`;
+
+export interface ProductVariantOption {
+  name: string;
+  value: string;
+}
+
+export interface ProductVariant {
+  variantId: string;
+  available: boolean;
+  originalPrice?: number;
+  salePrice?: number;
+  imageUrl?: string;
+  url?: string;
+  options: ProductVariantOption[];
+}
+
+export interface ProductOption {
+  name: string;
+  values: string[];
+}
+
+export interface ProductDetails {
+  productId: string;
+  virtualParentId?: string;
+  title: string;
+  options: ProductOption[];
+  variants: ProductVariant[];
+}

package/src/application/models/validators/__tests__/validateUserEvent.test.ts

@@ -0,0 +1,41 @@
+import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
+import { validateUserEvent } from 'src/application/models/validators/validateUserEvent';
+
+describe('validateUserEvent', () => {
+  it('preserves productId, parentProductId, and url for an AddToCart event', () => {
+    const result = validateUserEvent({
+      event_id: 'event-1',
+      created_at: '2026-07-20T00:00:00.000Z',
+      category: UserEventCategory.AddToCart,
+      attributes: {
+        product_id: 'product-1',
+        parent_product_id: 'parent-1',
+        url: 'https://example.com/product-1',
+      },
+    });
+
+    expect(result).toEqual({
+      eventId: 'event-1',
+      createdAt: '2026-07-20T00:00:00.000Z',
+      category: UserEventCategory.AddToCart,
+      attributes: {
+        productId: 'product-1',
+        parentProductId: 'parent-1',
+        url: 'https://example.com/product-1',
+      },
+    });
+  });
+
+  it('does not fall through to AppLoaded for an AddToCart event', () => {
+    const result = validateUserEvent({
+      event_id: 'event-1',
+      created_at: '2026-07-20T00:00:00.000Z',
+      category: UserEventCategory.AddToCart,
+      attributes: {
+        product_id: 'product-1',
+      },
+    });
+
+    expect(result?.category).toBe(UserEventCategory.AddToCart);
+  });
+});

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

@@ -48,6 +48,7 @@ export const validateResponse = (data: unknown): Response | undefined => {
       category: ResponseCategory.Product,
       attributes: {
         id: data.attributes.id,
+        itemGroupId: data.attributes.item_group_id,
         description: data.attributes.description,
         imageUrl: data.attributes.image_url,
         imageUrls: data.attributes.image_urls,

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

@@ -16,11 +16,16 @@ export const validateUserEvent = (data: unknown): UserEvent | undefined => {
     return undefined;
   }
 
-  if (data.category === UserEventCategory.PdpVisit && isApiPDPAttributes(data.attributes)) {
+  // PdpVisit and AddToCart share the same attributes structure
+  if (
+    (data.category === UserEventCategory.PdpVisit ||
+      data.category === UserEventCategory.AddToCart) &&
+    isApiPDPAttributes(data.attributes)
+  ) {
     return {
       eventId: data.event_id,
       createdAt: data.created_at,
-      category: UserEventCategory.PdpVisit,
+      category: data.category,
       attributes: {
         productId: data.attributes.product_id,
         parentProductId: data.attributes.parent_product_id,

package/src/application/utils/__tests__/messageFromAddToCartEvent.test.ts

@@ -0,0 +1,109 @@
+import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
+import { MessageRole, MessageType, UserEvent } from 'src/application/models';
+import { messageFromAddToCartEvent } from '../messageFromAddToCartEvent';
+
+describe('messageFromAddToCartEvent', () => {
+  it('builds a user message from an AddToCart event', () => {
+    const event: UserEvent = {
+      eventId: 'event-1',
+      createdAt: '2026-07-20T00:00:00.000Z',
+      category: UserEventCategory.AddToCart,
+      attributes: {
+        productId: 'product-1',
+        parentProductId: '',
+        url: '',
+      },
+    };
+
+    expect(messageFromAddToCartEvent(event)).toEqual({
+      id: 'event-1',
+      role: MessageRole.User,
+      type: MessageType.QueryTyped,
+      createdAt: '2026-07-20T00:00:00.000Z',
+      metadata: {
+        content: 'Add product-1 to my cart',
+      },
+    });
+  });
+
+  it('returns undefined for a non-AddToCart event', () => {
+    const event: UserEvent = {
+      eventId: 'event-1',
+      createdAt: '2026-07-20T00:00:00.000Z',
+      category: UserEventCategory.AppLoaded,
+    };
+
+    expect(messageFromAddToCartEvent(event)).toBeUndefined();
+  });
+
+  it('prefers the explicit productTitle override parameter', () => {
+    const event: UserEvent = {
+      eventId: 'event-1',
+      createdAt: '2026-07-20T00:00:00.000Z',
+      category: UserEventCategory.AddToCart,
+      attributes: {
+        productId: 'product-1',
+        parentProductId: '',
+        url: '',
+        productTitle: 'Attribute Title',
+      },
+    };
+
+    expect(messageFromAddToCartEvent(event, 'Override Title')).toEqual({
+      id: 'event-1',
+      role: MessageRole.User,
+      type: MessageType.QueryTyped,
+      createdAt: '2026-07-20T00:00:00.000Z',
+      metadata: {
+        content: 'Add Override Title to my cart',
+      },
+    });
+  });
+
+  it('falls back to event.attributes.productTitle when no override is passed', () => {
+    const event: UserEvent = {
+      eventId: 'event-1',
+      createdAt: '2026-07-20T00:00:00.000Z',
+      category: UserEventCategory.AddToCart,
+      attributes: {
+        productId: 'product-1',
+        parentProductId: '',
+        url: '',
+        productTitle: 'Attribute Title',
+      },
+    };
+
+    expect(messageFromAddToCartEvent(event)).toEqual({
+      id: 'event-1',
+      role: MessageRole.User,
+      type: MessageType.QueryTyped,
+      createdAt: '2026-07-20T00:00:00.000Z',
+      metadata: {
+        content: 'Add Attribute Title to my cart',
+      },
+    });
+  });
+
+  it('falls back to the raw productId when neither a title override nor an attribute title is present', () => {
+    const event: UserEvent = {
+      eventId: 'event-1',
+      createdAt: '2026-07-20T00:00:00.000Z',
+      category: UserEventCategory.AddToCart,
+      attributes: {
+        productId: 'product-1',
+        parentProductId: '',
+        url: '',
+      },
+    };
+
+    expect(messageFromAddToCartEvent(event)).toEqual({
+      id: 'event-1',
+      role: MessageRole.User,
+      type: MessageType.QueryTyped,
+      createdAt: '2026-07-20T00:00:00.000Z',
+      metadata: {
+        content: 'Add product-1 to my cart',
+      },
+    });
+  });
+});

package/src/application/utils/index.ts

@@ -6,6 +6,7 @@ export * from './divideArray';
 export * from './domObserver';
 export * from './elementObserver';
 export * from './imageFilter';
+export * from './messageFromAddToCartEvent';
 export * from './messageFromFormSubmittedEvent';
 export * from './messageFromQueryEvent';
 export * from './messageFromResponse';

package/src/application/utils/messageFromAddToCartEvent.ts

@@ -0,0 +1,32 @@
+import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
+import { Message, MessageRole, MessageType, UserEvent } from 'src/application/models';
+
+/**
+ * Transforms an AddToCart UserEvent object into a Message object for presentation.
+ *
+ * @param event The user event object received from the server
+ * @param productTitle Resolved product title to display instead of the raw
+ * productId. Falls back to `event.attributes.productTitle` (set on freshly
+ * created, not-yet-serialized events) and finally to the productId itself.
+ *
+ * @returns A Message if the event is an AddToCart event, otherwise undefined
+ */
+export const messageFromAddToCartEvent = (
+  event: UserEvent,
+  productTitle?: string,
+): Message | undefined => {
+  if (event.category === UserEventCategory.AddToCart) {
+    const label = productTitle ?? event.attributes.productTitle ?? event.attributes.productId;
+    return {
+      id: event.eventId,
+      role: MessageRole.User,
+      type: MessageType.QueryTyped,
+      createdAt: event.createdAt,
+      metadata: {
+        content: `Add ${label} to my cart`,
+      },
+    };
+  }
+
+  return undefined;
+};

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/index.ts

@@ -2,7 +2,7 @@ import { ContextEnvEnum, ContextSourceEnum } from '@spiffy-ai/commerce-api-clien
 import { atom } from 'jotai';
 import { atomWithStorage } from 'jotai/utils';
 import { VariantInfo } from 'src/application/models';
-import { UserIdentityContextType } from 'src/contexts/userIdentityContext/userIdentityContext';
+import type { UserIdentityContextType } from 'src/contexts/userIdentityContext/userIdentityContext';
 import { v4 as uuid } from 'uuid';
 import { contextSourceAtom, envAtom, orgIdAtom, orgShortNameAtom } from '../envive/enviveConfig';
 

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/atoms/envive/enviveConfig.ts

@@ -2,7 +2,7 @@ import Logger from 'src/application/logging/logger';
 import { atom } from 'jotai';
 import { EnviveConfig } from 'src/contexts/types';
 import { ContextSourceEnum } from '@spiffy-ai/commerce-api-client';
-import { LocalStorageKeys } from 'src/contexts/localStorageContext';
+import { LocalStorageKeys } from 'src/contexts/localStorageContext/localStorageKeys';
 
 const logger = new Logger('enviveConfig');
 
@@ -49,6 +49,11 @@ export const orgIdAtom = atom(get => {
   return config?.orgId;
 });
 
+export const addToCartCallbackAtom = atom(get => {
+  const config = get(enviveConfigAtom);
+  return config?.addToCart;
+});
+
 export const contextSourceAtom = atom(get => {
   const config = get(enviveConfigAtom);
 

package/src/atoms/org/graphqlConfig.ts

@@ -1,7 +1,7 @@
 import { atom } from 'jotai';
 import { ColorMapping } from 'src/application/models/colorsConfig';
 import { FrontendConfig } from 'src/application/models/frontendConfig';
-import { FeatureFlagContextType } from 'src/contexts/featureFlagServiceContext/featureFlagServiceContext'; // Import FeatureFlagContextType from new context
+import type { FeatureFlagContextType } from 'src/contexts/featureFlagServiceContext/featureFlagServiceContext';
 
 export const internalGraphQLColorsConfigAtom = atom<ColorMapping | undefined>(undefined);
 const internalGraphQLFrontendConfigAtom = atom<FrontendConfig | undefined>(undefined);

package/src/contexts/enviveConfigContext/enviveConfigContext.tsx

@@ -3,6 +3,7 @@ import { useSetAtom } from 'jotai';
 import { enviveConfigAtom } from 'src/atoms/envive/enviveConfig';
 import Logger from 'src/application/logging/logger';
 import { OrgConfigFeatureGate } from 'src/application/models';
+import { AddToCartCallback } from 'src/types/enviveConfig';
 
 const logger = new Logger('enviveConfigContext');
 
@@ -24,6 +25,7 @@ interface EnviveConfigProviderProps {
   publicKey?: string;
   featureOverrides?: Record<string, boolean>;
   featureGates?: OrgConfigFeatureGate[];
+  addToCart?: AddToCartCallback;
 }
 
 export const EnviveConfigProvider: React.FC<EnviveConfigProviderProps> = ({
@@ -44,6 +46,7 @@ export const EnviveConfigProvider: React.FC<EnviveConfigProviderProps> = ({
   publicKey,
   featureOverrides,
   featureGates,
+  addToCart,
 }) => {
   const setEnviveConfig = useSetAtom(enviveConfigAtom);
 
@@ -65,6 +68,7 @@ export const EnviveConfigProvider: React.FC<EnviveConfigProviderProps> = ({
       publicKey,
       featureOverrides,
       featureGates,
+      addToCart,
     }),
     [
       identifyingPrefix,
@@ -83,6 +87,7 @@ export const EnviveConfigProvider: React.FC<EnviveConfigProviderProps> = ({
       publicKey,
       featureOverrides,
       featureGates,
+      addToCart,
     ],
   );
 

package/src/contexts/enviveContext/enviveContext.tsx

@@ -7,6 +7,7 @@ import { resolvedBaseConfigVersionAtom } from 'src/atoms/envive/resolvedBaseConf
 import { IHardcopyService } from 'src/services/hardcopyService';
 import { IUserIdentityService } from 'src/services/userIdentityService';
 import Logger from 'src/application/logging/logger';
+import { AddToCartCallback } from 'src/types/enviveConfig';
 import { AmplitudeProvider } from '../amplitudeContext';
 import { EnviveConfigProvider } from '../enviveConfigContext';
 import { EnviveCssProvider } from '../enviveCssContext';
@@ -51,8 +52,11 @@ interface EnviveProviderProps extends AgentWrapperProps {
   enviveOn?: boolean;
   cdnUrl?: string;
   reactAppName?: string;
+  env?: string;
+  contextSource?: string;
   previewMode?: boolean;
   mockSalesAgentData?: any;
+  addToCart?: AddToCartCallback;
 }
 
 const SearchAgentWrapper: React.FC<AgentWrapperProps> = ({ children, enabledAgents }) => {
@@ -100,7 +104,10 @@ export const EnviveProvider: React.FC<EnviveProviderProps> = ({
   enviveOn,
   cdnUrl,
   reactAppName,
+  env,
+  contextSource,
   identifyingPrefix,
+  addToCart,
 }) => {
   const { extensionService } = services;
   const [enviveServiceConfig, setEnviveServiceConfig] = useState<EnviveServiceConfig | null>(null);
@@ -196,6 +203,9 @@ export const EnviveProvider: React.FC<EnviveProviderProps> = ({
       enviveOn={enviveOn}
       cdnUrl={cdnUrl}
       reactAppName={reactAppName}
+      env={env}
+      contextSource={contextSource}
+      addToCart={addToCart}
     >
       <NewOrgConfigProvider config={enviveServiceConfig.orgConfig ?? {}}>
         <LocalStorageProvider>