@envive-ai/react-hooks 0.1.0

package/src/application/utils/stringUtils.ts

@@ -0,0 +1,55 @@
+
+class StringUtils {
+  static isNullOrEmpty(value: string | undefined): boolean {
+    const valueTrimmed = value?.trim();
+    return value === undefined || valueTrimmed === '';
+  }
+
+  static trimToNull(value: string | undefined): string | undefined {
+    const valueTrimmed = value?.trim();
+    return StringUtils.isNullOrEmpty(valueTrimmed) ? undefined : valueTrimmed;
+  }
+
+  static capitalize(type: string | undefined) {
+    if (type === undefined) {
+      return '';
+    }
+    return type.charAt(0).toUpperCase() + type.substring(1);
+  }
+
+  /**
+   * Finds the first pattern in an array that matches a given URL.
+   * Patterns can include a single wildcard '*' which matches any sequence of characters.
+   *
+   * @param patterns
+   * @param urlToTest
+   * @returns
+   */
+  static findMatchingPattern(patterns: string[], urlToTest: Location): string | undefined {
+    if (!urlToTest) {
+      return undefined;
+    }
+
+    for (const pattern of patterns) {
+      // Test only if a pathname is present.
+      if (urlToTest.pathname !== '/') {
+        // Escape special regex characters in the pattern
+        // This ensures that characters like '.', '+', '?', '(', etc., in the pattern are treated literally.
+        const escapedPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+
+        // Replace the wildcard '*' with its regex equivalent '.*' (matches any character zero or more times)
+        const regexPattern = escapedPattern.replace(/\*/g, '.*');
+
+        const regex = new RegExp(`^${regexPattern}$`);
+        if (regex.test(urlToTest.pathname)) {
+          return pattern;
+        }
+
+      } else if (pattern.startsWith(urlToTest.hostname)) {
+        return pattern;
+      }
+    }
+  }
+}
+
+export { StringUtils };

package/src/application/utils/supportedEventRequestToApiRequest.ts

@@ -0,0 +1,12 @@
+import { SupportedEventRequest as ApiSupportedEventRequest } from '@spiffy-ai/commerce-api-client';
+import { SupportedEventRequest as CoreSupportedEventRequest } from '../models/api/supportedEventRequest';
+import { coreUserEventToApiUserEvent } from './coreUserEventToApiUserEvent';
+import { coreContextToApiContext } from './coreContextToApiContext';
+
+export const coreSupportedEventRequestToApiRequest = (
+  coreSupportedEventRequest: CoreSupportedEventRequest,
+): ApiSupportedEventRequest => ({
+  id: coreSupportedEventRequest.id,
+  user_event: coreUserEventToApiUserEvent(coreSupportedEventRequest.userEvent),
+  context: coreContextToApiContext(coreSupportedEventRequest.context),
+});

package/src/application/utils/urlsParser.ts

@@ -0,0 +1,53 @@
+import { MessageRole, ProductSearchMessageMetadata } from '../models/message';
+
+export const parseHref = (
+  href: string,
+): { url: URL | undefined; urlSearchParams: URLSearchParams | undefined } => {
+  try {
+    const url = new URL(href);
+    const urlSearchParams = new URLSearchParams(url.search);
+    return { url, urlSearchParams };
+  } catch (e) {
+    return { url: undefined, urlSearchParams: undefined };
+  }
+};
+
+export const createUrlWithQueryParams = (
+  url: string,
+  queryParams: Record<string, string>,
+): string => {
+  const urlObj = new URL(url, window.location.href);
+  Object.entries(queryParams).forEach(([value, key]) => urlObj.searchParams.append(value, key));
+
+  return urlObj.href;
+};
+
+export const getQueryParam = (key: string): string | null => {
+  const urlObj = new URL(window.location.href);
+  return urlObj.searchParams.get(key);
+};
+
+type SearchMessage = {
+  id: string;
+  role: MessageRole;
+  createdAt: string;
+} & ProductSearchMessageMetadata;
+
+export const buildSearchHash = (message: SearchMessage): string =>
+  `#evs=true&s=${message.id}&q=${message.metadata.generatedQuery}`;
+
+export const buildSearchStartHash = (query: string): string => `#evs=true&q=${query}`;
+
+// Basic parser for the search hash
+export const parseSearchHash = (hash: string): { id: string | null; query: string | null } => {
+  if (!hash.startsWith('#evs=true')) {
+    return { id: null, query: null };
+  }
+  const params = Object.fromEntries(hash.split('&').map((param) => param.split('=')));
+  return {
+    id: params.s ? decodeURIComponent(params.s) : null,
+    query: params.q ? decodeURIComponent(params.q) : null,
+  };
+};
+
+window.history.pushState(null, '');

package/src/application/utils/validation.ts

@@ -0,0 +1,5 @@
+// This email validates that there are one or more characters before the `@` symbol,
+// one or more characters between the `@` symbol and the `.` symbol,
+// and one or more characters after the `.` symbol
+// It does NOT validate all possible email formats, but it is a decent place to start.
+export const validateEmail = (value: string): boolean => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);

package/src/atoms/app/index.ts

@@ -0,0 +1,57 @@
+import { ContextEnvEnum, ContextSourceEnum } from '@spiffy-ai/commerce-api-client';
+import { atom } from 'jotai';
+import { atomWithStorage } from 'jotai/utils';
+import { VariantInfo } from 'src/application/models';
+import { UserIdentityService } from 'src/application/service/userIdentityService';
+import { variantInfoAtom } from 'src/atoms/app/variant';
+import { orgIdAtom, orgShortNameAtom, sourceAtom } from 'src/atoms/org/org';
+import { v4 as uuid } from 'uuid';
+
+export interface AppDetails {
+  orgId: string;
+  orgShortName: string;
+  chatId: string;
+  userId: string;
+  source: ContextSourceEnum;
+  env: ContextEnvEnum;
+  variantInfo: VariantInfo;
+}
+
+export { variantInfoAtom } from './variant';
+
+const internalUserIdAtom = atom<string | undefined>(undefined);
+
+export const userIdAtom = atom(
+  (get) => {
+    const maybeUserId = get(internalUserIdAtom);
+
+    if (maybeUserId) {
+      return maybeUserId;
+    }
+
+    return UserIdentityService.getUserIdOrDefault();
+  },
+  (_, set, value: string | undefined) => {
+    set(internalUserIdAtom, value);
+  },
+);
+export const appSourceAtom = atom<ContextSourceEnum>(
+  (get): ContextSourceEnum => get(sourceAtom) ?? ContextSourceEnum.App,
+);
+export const envAtom = atom<ContextEnvEnum>(ContextEnvEnum.Dev);
+export const chatIdAtom = atomWithStorage<string>('v1-spiffy-chat-session-id', uuid(), undefined, {
+  getOnInit: true,
+});
+
+export const appDetailsAtom = atom(
+  (get): AppDetails => ({
+    orgId: get(orgIdAtom),
+    // TODO: orgShortName should be available when this atom is created
+    orgShortName: get(orgShortNameAtom) ?? 'spiffy-ai',
+    chatId: get(chatIdAtom),
+    userId: get(userIdAtom),
+    source: get(appSourceAtom),
+    env: get(envAtom),
+    variantInfo: get(variantInfoAtom),
+  }),
+);

package/src/atoms/app/variant.ts

@@ -0,0 +1,261 @@
+import { atomWithStorage } from 'jotai/utils';
+import { atom } from 'jotai';
+import {
+  SupportedEventProductCategory,
+  SupportedEventResponse,
+  PageVisitCategory,
+} from '@spiffy-ai/commerce-api-client';
+import {
+  PageVisitVariantInfo,
+  PDPVariantInfo,
+  PLPVariantInfo,
+  VariantInfo,
+  FeatureGates,
+  OrgShortName,
+} from 'src/application/models';
+import { sessionStorageUtil } from 'src/atoms/atomStore';
+import { featureFlagServiceAtom, orgShortNameAtom } from 'src/atoms/org/org';
+
+export interface SupportedEvent
+  extends Pick<
+    SupportedEventResponse,
+    'supported' | 'ready' | 'category' | 'collections' | 'top_category'
+  > {
+  numberOfReviews: number | undefined;
+  merchant_tags?: string[];
+}
+
+interface PDPAttributes {
+  product_id?: string;
+}
+
+interface PLPAttributes {
+  attributes?: {
+    id?: string;
+  };
+}
+
+export interface UrlResolvingPDPConfig {
+  pdp_attributes: PDPAttributes;
+  number_of_reviews?: number;
+  collections?: string[];
+  merchant_tags?: string[];
+}
+
+export interface UrlResolvingPLPConfig {
+  plp_attributes: PLPAttributes;
+  top_category?: string;
+}
+
+interface UrlResolvingGenericConfig {
+  details?: string;
+}
+
+export type PageVariantCheckConfig = {
+  check_type: string;
+  feature_gate?: string;
+  extractor?: {
+    type: string;
+    map?: Record<string, string[]>;
+    value?: string;
+  };
+  product_id_extractor?: string;
+  product_ids?: string[];
+  plp_id_extractor?: string;
+  plp_ids?: string[];
+  collections?: string[];
+  query_param?: string;
+  category?: string;
+  top_category?: string[];
+  review_minimum?: number;
+  merchant_tags?: string[];
+};
+
+export type BackendWidgetMountingConfig = {
+  mounting_config_id: string;
+  widget_config_id?: string;
+  mounting_point_widgets?: Array<{
+    checks: PageVariantCheckConfig[];
+    widget_config_id: string;
+  }>;
+};
+
+export type BackendPageVariantConfig = {
+  variant_id: string;
+  variant_type: string;
+  variant_checks: PageVariantCheckConfig[];
+  widget_mounting: BackendWidgetMountingConfig[];
+  plp_id_extractor?: string;
+  product_id_extractor?: string;
+  parent_product_id_extractor?: string;
+};
+
+export interface UrlResolverResponse {
+  variant_type: string;
+  specific_details: UrlResolvingPDPConfig | UrlResolvingPLPConfig | UrlResolvingGenericConfig;
+  ready: boolean;
+  user_event?: {
+    event_id?: string;
+    attributes?: PDPAttributes | PLPAttributes;
+    category?: string;
+    created_at?: string;
+  };
+  page_variant?: BackendPageVariantConfig;
+}
+
+// Use a map for per-URL cache
+export type UrlResolverCache = Record<string, UrlResolverResponse | undefined>;
+
+const internalStorageUrlResolverAtom = atomWithStorage<string | undefined>(
+  'spiffy-url-resolver',
+  undefined,
+  sessionStorageUtil,
+  {
+    getOnInit: true,
+  },
+);
+
+export const urlResolverAtom = atom(
+  (get): UrlResolverCache => {
+    const maybeUrlResolver = get(internalStorageUrlResolverAtom);
+    if (maybeUrlResolver == null) {
+      return {};
+    }
+    return JSON.parse(maybeUrlResolver);
+  },
+  (get, set, value: { url: string; response: UrlResolverResponse | undefined }) => {
+    // Get current cache from storage
+    const currentCache = get(urlResolverAtom);
+    const newCache = { ...currentCache, [value.url]: value.response };
+
+    set(internalStorageUrlResolverAtom, JSON.stringify(newCache));
+  },
+);
+
+const internalStorageSupportedEventAtom = atomWithStorage<string | undefined>(
+  'spiffy-supported-event',
+  undefined,
+  sessionStorageUtil,
+  {
+    getOnInit: true,
+  },
+);
+const internalSupportedEventAtom = atom<SupportedEvent | undefined>(undefined);
+
+export const supportedEventAtom = atom(
+  (get): SupportedEvent | undefined => {
+    const maybeSupportedEvent = get(internalStorageSupportedEventAtom);
+    if (maybeSupportedEvent == null) {
+      return undefined;
+    }
+
+    // TODO this is an unvalidated parse. It may be better to implement a custom storage util
+    // and perform the object validation on "get" there.
+    return JSON.parse(maybeSupportedEvent);
+  },
+  (get, set, value: SupportedEvent | undefined) => {
+    if (value == null) {
+      set(internalStorageSupportedEventAtom, undefined);
+      set(internalSupportedEventAtom, undefined);
+      return;
+    }
+
+    const featureFlagService = get(featureFlagServiceAtom);
+    const maybeSupportedEvent = get(internalSupportedEventAtom);
+    const variantCategory = maybeSupportedEvent?.category;
+    const shortName = get(orgShortNameAtom);
+
+    // TODO: clean up this logic & the feature gate when we've fully rolled out
+    if (
+      !featureFlagService.isFeatureGateEnabled(FeatureGates.IsNonShapewearEnabled) &&
+      variantCategory &&
+      variantCategory !== SupportedEventProductCategory.Shapewear &&
+      (shortName === OrgShortName.Spanx || shortName === OrgShortName.SpanxStaging)
+    ) {
+      const modifiedSupportedEvent = {
+        supported: false,
+        ready: value.ready,
+        category: value.category,
+        numberOfReviews: value.numberOfReviews,
+        collections: value.collections,
+        top_category: value.top_category,
+        merchant_tags: value.merchant_tags,
+      };
+      set(internalSupportedEventAtom, modifiedSupportedEvent);
+      set(internalStorageSupportedEventAtom, JSON.stringify(modifiedSupportedEvent));
+
+      return;
+    }
+
+    set(internalSupportedEventAtom, value);
+    set(internalStorageSupportedEventAtom, JSON.stringify(value));
+  },
+);
+
+const internalVariantIdAtom = atom<string>();
+const internalProductIdAtom = atom<string>();
+const internalParentProductIdAtom = atom<string>();
+const internalProductUrlAtom = atom<string>();
+const internalPlpIdAtom = atom<string>();
+const internalUrlAtom = atom<string>();
+const internalPageVisitCategoryAtom = atom<PageVisitCategory>();
+const internalVariantAtom = atom<'pdp' | 'plp' | 'search' | 'page_visit'>('pdp');
+
+export const variantIdAtom = atom((get) => get(internalVariantIdAtom));
+export const productIdAtom = atom((get) => get(internalProductIdAtom));
+export const parentProductIdAtom = atom((get) => get(internalParentProductIdAtom));
+export const productUrlAtom = atom((get) => get(internalProductUrlAtom));
+export const plpIdAtom = atom((get) => get(internalPlpIdAtom));
+export const urlAtom = atom((get) => get(internalUrlAtom));
+export const pageVisitCategoryAtom = atom((get) => get(internalPageVisitCategoryAtom));
+export const variantAtom = atom((get) => get(internalVariantAtom));
+export const hasParsedVariantInfoAtom = atom(false);
+
+export const variantInfoAtom = atom(
+  (get): VariantInfo => {
+    const variant = get(variantAtom);
+    if (variant === 'pdp') {
+      return {
+        variantId: get(variantIdAtom),
+        variant,
+        productId: get(productIdAtom),
+        parentProductId: get(parentProductIdAtom),
+        url: get(urlAtom),
+      } as PDPVariantInfo;
+    }
+    if (variant === 'plp') {
+      return {
+        variantId: get(variantIdAtom),
+        variant,
+        plpId: get(plpIdAtom),
+        url: get(urlAtom),
+      } as PLPVariantInfo;
+    }
+    if (variant === 'page_visit') {
+      return {
+        variantId: get(variantIdAtom),
+        variant,
+        url: get(urlAtom),
+        pageVisitCategory: get(pageVisitCategoryAtom),
+      } as PageVisitVariantInfo;
+    }
+    throw new Error('Invalid variantInfo details');
+  },
+  (_, set, newVariant: VariantInfo) => {
+    set(internalVariantAtom, newVariant.variant);
+    set(internalVariantIdAtom, newVariant.variantId);
+    if (newVariant.variant === 'pdp') {
+      set(internalProductIdAtom, newVariant.productId);
+      set(internalParentProductIdAtom, newVariant.parentProductId);
+      set(internalUrlAtom, newVariant.url);
+    }
+    if (newVariant.variant === 'plp') {
+      set(internalPlpIdAtom, newVariant.plpId);
+      set(internalUrlAtom, newVariant.url);
+    }
+    if (newVariant.variant === 'page_visit') {
+      set(internalUrlAtom, newVariant.url);
+      set(internalPageVisitCategoryAtom, newVariant.pageVisitCategory);
+    }
+  },
+);

package/src/atoms/atomStore.ts

@@ -0,0 +1,34 @@
+import { getDefaultStore } from 'jotai';
+import { createJSONStorage } from 'jotai/utils';
+
+export type AtomStore = ReturnType<typeof getDefaultStore>;
+let atomStore: AtomStore | null = null;
+
+export const getAtomStore = (): AtomStore => {
+  if (!atomStore) {
+    atomStore = getDefaultStore();
+  }
+  return atomStore;
+};
+
+/**
+ * @internal
+ *
+ * Sets the global atom store to be the provided store.
+ *
+ * @param store - The store to set the global atom store to.
+ */
+export const setAtomStoreForTesting = (store: AtomStore) => {
+  atomStore = store;
+};
+
+/**
+ * @internal
+ *
+ * Resets the global atom store to null
+ */
+export const resetAtomStore = () => {
+  atomStore = null;
+};
+
+export const sessionStorageUtil = createJSONStorage<string | undefined>(() => sessionStorage);

package/src/atoms/chat/chatState.ts

@@ -0,0 +1,44 @@
+import { UserEventCategory } from '@spiffy-ai/commerce-api-client/dist/models/UserEventCategory';
+import { atom } from 'jotai';
+import { AmplitudeAdapter, SpiffyMetricsEventName } from 'src/adapters/amplitude';
+import { FormSubmittedAttributes, Message, Suggestion, UserEvent } from 'src/application/models';
+import { ChatElementDisplayLocation } from 'src/application/models/chatElementDisplayLocation';
+import { SpiffyEventName } from 'src/application/models/events';
+
+export const userHasRepliedAtom = atom<boolean>(false);
+export const replyEventCategoryAtom = atom<UserEventCategory>(UserEventCategory.AppLoaded);
+export const userQueryAtom = atom<string>();
+export const suggestionAtom = atom<Suggestion | undefined>(undefined);
+export const askQuestionBtnClickedAtom = atom<boolean>(false);
+export const messagesAtom = atom<Message[][]>([]);
+export const userEventsAtom = atom<UserEvent[]>([]);
+export const suggestionsAtom = atom<Suggestion[]>([]);
+export const suggestionsLoadingAtom = atom<boolean>(false);
+export const responseStreamingAtom = atom<boolean>(false);
+export const chatIsOpenAtom = atom<boolean>(false);
+export const requestFailureAtom = atom<boolean>(false);
+export const formSubmitAtom = atom<FormSubmittedAttributes>();
+export const chatOnToggleAtom = atom(
+  null,
+  (get, set, triggerLocation?: ChatElementDisplayLocation) => {
+    const isOpen = get(chatIsOpenAtom);
+    set(chatIsOpenAtom, !isOpen);
+
+    if (!isOpen) {
+      window.dispatchEvent(new CustomEvent(SpiffyEventName.WidgetOpen));
+      AmplitudeAdapter.trackEvent({
+        eventName: SpiffyMetricsEventName.ChatComponentExpanded,
+        eventProps: {
+          message_metadata: {
+            trigger_location: triggerLocation,
+          },
+        },
+      });
+    } else {
+      window.dispatchEvent(new CustomEvent(SpiffyEventName.WidgetClose));
+      AmplitudeAdapter.trackEvent({
+        eventName: SpiffyMetricsEventName.ChatComponentCollapsed,
+      });
+    }
+  },
+);

package/src/atoms/chat/form.ts

@@ -0,0 +1,19 @@
+import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
+import { atom } from 'jotai';
+import { FormSubmittedAttributes, UserEvent } from 'src/application/models';
+import { v4 as uuid } from 'uuid';
+import { formSubmitAtom, replyEventCategoryAtom } from 'src/atoms/chat';
+import { queueUserEventAtom } from 'src/atoms/chat/messageQueue';
+
+export const handleFormSubmittedAtom = atom(null, (_, set, form: FormSubmittedAttributes) => {
+  set(replyEventCategoryAtom, UserEventCategory.FormSubmitted);
+  set(formSubmitAtom, form);
+
+  const formUserEvent = {
+    eventId: uuid(),
+    category: UserEventCategory.FormSubmitted,
+    createdAt: new Date().toISOString(),
+    attributes: form,
+  } satisfies UserEvent;
+  set(queueUserEventAtom, formUserEvent);
+});

package/src/atoms/chat/index.ts

@@ -0,0 +1,38 @@
+import { atom } from 'jotai';
+import {
+  responseStreamingAtom,
+  suggestionsLoadingAtom,
+  messagesAtom,
+  userQueryAtom,
+  replyEventCategoryAtom,
+  userHasRepliedAtom,
+  askQuestionBtnClickedAtom,
+  suggestionsAtom,
+  chatIsOpenAtom,
+  chatOnToggleAtom,
+  userEventsAtom,
+  suggestionAtom,
+} from './chatState';
+
+export * from './chatState';
+export * from './replies';
+export * from './performanceMetrics';
+export * from './form';
+export * from './suggestions';
+export * from './lastMessage';
+export * from './renderedWidgetRefs';
+
+export const chatAtom = atom((get) => ({
+  userHasReplied: get(userHasRepliedAtom),
+  replyEventCategory: get(replyEventCategoryAtom),
+  userQuery: get(userQueryAtom),
+  suggestion: get(suggestionAtom),
+  askQuestionBtnClicked: get(askQuestionBtnClickedAtom),
+  messages: get(messagesAtom),
+  userEvents: get(userEventsAtom),
+  suggestions: get(suggestionsAtom),
+  suggestionsLoading: get(suggestionsLoadingAtom),
+  responseStreaming: get(responseStreamingAtom),
+  isOpen: get(chatIsOpenAtom),
+  onToggle: get(chatOnToggleAtom),
+}));

package/src/atoms/chat/lastMessage.ts

@@ -0,0 +1,11 @@
+import { atom } from 'jotai';
+import { messagesAtom, userHasRepliedAtom } from 'src/atoms/chat';
+
+export const lastAssistantMessageAtom = atom((get) => {
+  const messages = get(messagesAtom);
+  const userHasReplied = get(userHasRepliedAtom);
+  if (messages.length > 0 && !userHasReplied) {
+    return messages[messages.length - 1];
+  }
+  return null;
+});

package/src/atoms/chat/messageQueue.ts

@@ -0,0 +1,65 @@
+import { atom } from 'jotai';
+import { v4 as uuid } from 'uuid';
+import { GenerationParams, NextMessageRequest, UserEvent } from 'src/application/models';
+import { getAtomStore } from 'src/atoms/atomStore';
+import { appDetailsAtom } from 'src/atoms/app';
+import { featureFlagServiceAtom } from 'src/atoms/org/org';
+
+const internalUserEventQueueAtom = atom<UserEvent[]>([]);
+
+export const userEventQueueAtom = atom((get) => {
+  const queue = get(internalUserEventQueueAtom);
+  return queue === undefined ? [] : queue.filter((v) => v !== undefined);
+});
+
+/**
+ * This atom is used to queue a new message for processing on `next_responses`
+ * It receives a single `userEvent` that is added to the processing queue.
+ * If the event has the same eventId as an existing message in the queue the NEW
+ * event is ignored
+ */
+export const queueUserEventAtom = atom(null, (get, set, userEvent: UserEvent) => {
+  if (userEvent === undefined) {
+    return;
+  }
+  set(internalUserEventQueueAtom, [...get(internalUserEventQueueAtom), userEvent]);
+});
+
+/**
+ * This atom exposes a function to reset the entire queue. All messages in the queue will be purged
+ */
+export const clearUserEventAtom = atom(null, (_, set) => {
+  set(internalUserEventQueueAtom, []);
+});
+
+/**
+ * This atom is used to mark events as processed and remove them from the queue
+ * It accepts a list of eventId values and will remove all events with those eventIds from the queue.
+ */
+export const processUserEventAtom = atom(null, (get, set, eventIds: string[]) => {
+  const curr = get(internalUserEventQueueAtom);
+  const remaining = curr?.filter((event) => !eventIds.includes(event.eventId));
+  set(internalUserEventQueueAtom, remaining);
+});
+
+export const userQueueEventCountAtom = atom((get) => get(userEventQueueAtom).length);
+
+export const createResponsePayload = ({
+  userEvents,
+  generationParams,
+}: {
+  userEvents: UserEvent[];
+  generationParams?: GenerationParams;
+}): NextMessageRequest => {
+  const atomStore = getAtomStore();
+  const context = atomStore.get(appDetailsAtom);
+  const featureFlagService = atomStore.get(featureFlagServiceAtom);
+  const featureFlags = featureFlagService.getFeatureFlags();
+  return {
+    id: uuid(),
+    context,
+    userEvents,
+    featureFlags,
+    generationParams,
+  };
+};