@envive-ai/react-hooks 0.3.46 → 0.3.48

package/dist/application/commerce-api.js

@@ -1,10 +1,12 @@
 import logger_default from "./logging/logger.js";
+import { getProductOptionsQuery } from "./models/graphql/queries/getProductOptionsQuery.js";
 import { ProductExperiment } from "./models/productExperiment.js";
 import { validateOrgConfigResults } from "./models/validators/validateOrgConfigResults.js";
 import { validateResponse } from "./models/validators/validateResponse.js";
 import { validateSuggestion } from "./models/validators/validateSuggestion.js";
 import { validateUserEvent } from "./models/validators/validateUserEvent.js";
 import { getQueryParam } from "./utils/urlsParser.js";
+import { messageFromAddToCartEvent } from "./utils/messageFromAddToCartEvent.js";
 import { messageFromFormSubmittedEvent } from "./utils/messageFromFormSubmittedEvent.js";
 import { messageFromQueryEvent } from "./utils/messageFromQueryEvent.js";
 import { messageFromResponse } from "./utils/messageFromResponse.js";
@@ -72,8 +74,24 @@ var CommerceApiClient = class CommerceApiClient {
 		this.customerServiceApi = new CustomerServiceApi(config);
 		this.productsApi = new ProductsApi(config);
 	}
+	static {
+		this.inFlightUrlResolutions = /* @__PURE__ */ new Map();
+	}
 	static {
 		this.resolveUrl = async (url) => {
+			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);
+			}
+		};
+	}
+	static {
+		this.resolveUrlUncached = async (url) => {
 			const atomStore = getAtomStore();
 			const orgShortName = atomStore.get(orgShortNameAtom);
 			const orgId = atomStore.get(orgIdAtom);
@@ -206,15 +224,25 @@ var CommerceApiClient = class CommerceApiClient {
 			const userEvents = data?.user_events.map((event) => validateUserEvent(event)).filter((event) => event != null);
 			const formSubmittedUserEventsFormIds = userEvents.filter((event) => event.category === UserEventCategory.FormSubmitted).map((event) => event.attributes.formResponseId);
 			const assistantMessages = responses.map((turn) => turn.filter((response) => !(response.category === ResponseCategory.Form && formSubmittedUserEventsFormIds.includes(response.id))).map((response) => messageFromResponse(response)).filter((message) => message != null)).filter((turn) => turn.length > 0);
-			const userMessages = userEvents.map((event) => {
+			const userMessages = (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.AddToCart) {
+					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 : void 0;
+					if (!productTitle) try {
+						productTitle = (await CommerceApiClient.retrieveProductDetails(event.attributes.productId))?.title;
+					} catch {
+						productTitle = void 0;
+					}
+					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.length > 0);
+			}))).filter((message) => message.length > 0);
 			return {
 				responses,
 				userEvents,
@@ -264,6 +292,48 @@ var CommerceApiClient = class CommerceApiClient {
 			}
 		};
 	}
+	static {
+		this.productDetailsCache = /* @__PURE__ */ new Map();
+	}
+	static {
+		this.retrieveProductDetails = (productId) => {
+			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;
+		};
+	}
+	static {
+		this.retrieveProductDetailsUncached = async (productId) => {
+			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 ?? void 0;
+			} catch (err) {
+				await throwSessionRestartRequiredIf("Failed to retrieve product details", err);
+				return;
+			}
+		};
+	}
 	static {
 		this.isSupportedEvent = async (payload) => {
 			try {
@@ -344,4 +414,4 @@ var commerce_api_default = CommerceApiClient;
 
 //#endregion
 export { commerce_api_default as default };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"commerce-api.js","names":["Logger","config: Configuration","context: Context","err: unknown","error: unknown","data: V1GetSessionMessages200Response","responses: Response[][]","suggestions: Suggestion[]","userEvents: UserEvent[]","assistantMessages: Message[][]","userMessages: Message[][]","request: V1OrgConfigGetRequest"],"sources":["../../src/application/commerce-api.ts"],"sourcesContent":["import {\n  Configuration,\n  ContextEnvEnum,\n  ContextSourceEnum,\n  CustomerServiceApi,\n  CustomerServiceProvider,\n  DefaultApi,\n  FormType,\n  InferenceApi,\n  ProductsApi,\n  ReportSessionRequest,\n  ResponseCategory,\n  ResponseError,\n  UserEventCategory,\n  V1GetSessionMessages200Response,\n  V1OrgConfigGetRequest,\n  V1OrgConfigGetSourceEnum,\n} from '@spiffy-ai/commerce-api-client';\nimport type { Context } from '@spiffy-ai/commerce-api-client/dist/models/Context';\nimport type { ProductRetrievalResult } from 'src/atoms/search/types';\nimport Logger from 'src/application/logging/logger';\nimport {\n  Message,\n  NextMessageRequest,\n  Response,\n  Suggestion,\n  SupportedEventRequest,\n  UserEvent,\n} from 'src/application/models';\nimport { OrgConfig } from 'src/application/models/api/orgConfigResults';\nimport { ProductExperiment } from 'src/application/models/productExperiment';\nimport { validateOrgConfigResults } from 'src/application/models/validators/validateOrgConfigResults';\nimport { validateResponse } from 'src/application/models/validators/validateResponse';\nimport { validateSuggestion } from 'src/application/models/validators/validateSuggestion';\nimport { validateUserEvent } from 'src/application/models/validators/validateUserEvent';\nimport {\n  getQueryParam,\n  messageFromQueryEvent,\n  messageFromResponse,\n  messageFromSuggestionEvent,\n} from 'src/application/utils';\nimport { messageFromFormSubmittedEvent } from 'src/application/utils/messageFromFormSubmittedEvent';\nimport { messageRequestToCommerceMessageRequest } from 'src/application/utils/nextMessageRequestToApiRequest';\nimport { coreSupportedEventRequestToApiRequest } from 'src/application/utils/supportedEventRequestToApiRequest';\nimport { chatIdAtom, userIdAtom } from 'src/atoms/app'; // Import userIdAtom and chatIdAtom\nimport { SupportedEvent } from 'src/atoms/app/variant';\nimport { getAtomStore } from 'src/atoms/atomStore/atomStore';\nimport { resolvedBaseConfigVersionAtom } from 'src/atoms/envive/resolvedBaseConfigVersion';\nimport {\n  baseUrlAtom,\n  contextSourceAtom,\n  envAtom,\n  orgIdAtom,\n  orgLevelApiKeyAtom,\n  orgShortNameAtom,\n  reactAppNameAtom, // Import envAtom\n} from 'src/atoms/envive/enviveConfig';\nimport { featureFlagServiceAtom } from 'src/atoms/org/graphqlConfig'; // Import new orgIdAtom and featureFlagServiceAtom\nimport { SessionRestartRequired } from 'src/types/exceptions/sessionExceptions';\nimport { UnsupportedProductException } from 'src/types/exceptions/unsupportedProductExceptions';\nimport { WidgetText } from './models/api/widgetText';\nimport { WidgetTextRequest } from './models/api/widgetTextRequest';\nimport { productRetrievalResponseToProductRetrievalResult } from './utils/productRetrievalResponseToProductRetrievalResult';\nimport { apiWidgetTextResponseToCoreWidgetText } from './utils/widgetTextFromApiWidgetTextResponse';\nimport { coreWidgetTextRequestToApiRequest } from './utils/widgetTextRequestToApiRequest';\n\nconst logger = new Logger('commerce-api');\n\nasync function errorResponseBody(error: ResponseError) {\n  try {\n    return await error.response.json();\n  } catch {\n    return {};\n  }\n}\n\nasync function throwSessionRestartRequiredIf(errorMsg: string, error: unknown) {\n  if (!(error instanceof ResponseError)) {\n    logger.logInfo(errorMsg, error);\n    throw error;\n  }\n\n  const errorResponse = await errorResponseBody(error);\n  if (\n    errorResponse?.message?.toLowerCase() === 'unsupported product' || // for backward compatibility. newer versions of the API return sub_code instead of message\n    errorResponse?.app_code?.toUpperCase() === 'PRODUCT_NOT_FOUND'\n  ) {\n    throw new UnsupportedProductException();\n  } else if (\n    errorResponse?.app_code?.toUpperCase() === 'RESTART_SESSION' ||\n    errorResponse?.sub_code?.toUpperCase() === 'NOT_FOUND' // for backward compatibility. new API responses will contain \"app_code\"\n  ) {\n    logger.logInfo(\n      'Session does not exist. Re-start session',\n      error,\n      error.response,\n      errorResponse,\n    );\n    throw new SessionRestartRequired();\n  }\n\n  logger.logInfo(errorMsg, error);\n  throw error;\n}\n\nclass CommerceApiClient {\n  private readonly defaultApi: DefaultApi;\n\n  private readonly customerServiceApi: CustomerServiceApi;\n\n  private readonly inferenceApi: InferenceApi;\n\n  private readonly productsApi: ProductsApi;\n\n  private static instance: CommerceApiClient | undefined;\n\n  private suggestionsAbortController = new AbortController();\n\n  private responsesAbortController = new AbortController();\n\n  private static getInstance = (): CommerceApiClient => {\n    if (!CommerceApiClient.instance) {\n      CommerceApiClient.instance = new CommerceApiClient();\n    }\n\n    return CommerceApiClient.instance;\n  };\n\n  private constructor(basePath?: string) {\n    const atomStore = getAtomStore();\n    const baseUrl = atomStore.get(baseUrlAtom);\n    const apiKey = atomStore.get(orgLevelApiKeyAtom);\n    const path = basePath || baseUrl;\n    // API Key is now handled at the EnviveConfigProvider level\n    const config: Configuration = new Configuration({\n      accessToken: apiKey,\n      basePath: path,\n      headers: {\n        'Content-Type': 'application/json',\n        Accept: 'application/json',\n      },\n    });\n    this.defaultApi = new DefaultApi(config);\n    this.inferenceApi = new InferenceApi(config);\n    this.customerServiceApi = new CustomerServiceApi(config);\n    this.productsApi = new ProductsApi(config);\n  }\n\n  static resolveUrl = async (url: string) => {\n    const atomStore = getAtomStore();\n    const orgShortName = atomStore.get(orgShortNameAtom);\n    const orgId = atomStore.get(orgIdAtom);\n    const userId = atomStore.get(userIdAtom);\n    const chatId = atomStore.get(chatIdAtom);\n    const source = atomStore.get(contextSourceAtom);\n    const env = atomStore.get(envAtom);\n\n    const featureFlagService = atomStore.get(featureFlagServiceAtom);\n\n    const context: Context = {\n      user_id: userId ?? '',\n      org_id: orgId ?? '',\n      org_short_name: orgShortName ?? '',\n      chat_id: chatId ?? '',\n      source: source ?? ContextSourceEnum.App,\n      env: (env as ContextEnvEnum) ?? ContextEnvEnum.Dev, // Cast env to ContextEnvEnum\n    };\n\n    const overrideConfigVersion =\n      getQueryParam('spiffy_config_version') ||\n      getQueryParam('envive_config_version') ||\n      getAtomStore().get(resolvedBaseConfigVersionAtom) ||\n      undefined;\n\n    const featureGates = featureFlagService?.featureFlagService?.getFeatureFlags() || {};\n    const urlResolvingRequest = {\n      url,\n      context,\n      feature_gates: featureGates,\n      override_config_version: overrideConfigVersion,\n    };\n\n    const rawResponse = await CommerceApiClient.getInstance().inferenceApi.v1UrlResolvingPostRaw({\n      UrlResolvingRequest: urlResolvingRequest,\n    });\n\n    const responseBody = await rawResponse.raw.json();\n\n    return responseBody;\n  };\n\n  static reportSession = async (reportRequest: ReportSessionRequest): Promise<void> => {\n    await CommerceApiClient.getInstance().defaultApi.v1ChatsReportSessionIdPost({\n      ReportSessionRequest: reportRequest,\n    });\n  };\n\n  static getNextResponses = async (payload: NextMessageRequest): Promise<Message[]> => {\n    try {\n      const response = await CommerceApiClient.getInstance().inferenceApi.v1NextResponsesPost({\n        NextMessageRequest: messageRequestToCommerceMessageRequest(payload),\n      });\n      const messages = response\n        .map(resp => validateResponse(resp))\n        .map(resp => messageFromResponse(resp));\n\n      return messages.filter((m): m is Message => m != null);\n    } catch (err: unknown) {\n      logger.logInfo('Failed to get next responses', err, {\n        payloadContext: payload?.context,\n        userEvents: payload?.userEvents,\n      });\n      await throwSessionRestartRequiredIf('Failed to get next responses', err);\n      return [];\n    }\n  };\n\n  static getNextResponseStreaming = (\n    payload: NextMessageRequest,\n  ): AsyncGenerator<Response, void, unknown> => {\n    async function* generate(inferenceApi: InferenceApi, abortController: AbortController) {\n      // make sure streaming is enabled\n      try {\n        const response = await inferenceApi.v1NextResponsesPostRaw(\n          {\n            NextMessageRequest: messageRequestToCommerceMessageRequest(payload),\n          },\n          { signal: abortController.signal },\n        );\n\n        // Read the response as a stream of data\n        if (!response.raw.body) {\n          logger.logError('No body in the streamed response', undefined, {\n            response: response.raw,\n          });\n          return;\n        }\n\n        const reader = response.raw.body.getReader();\n        const decoder = new TextDecoder('utf-8');\n\n        let partial = '';\n        // TODO this function is recreated every time new data comes from the stream - define it outside of the generator\n        const safeParse = (line: string): unknown => {\n          try {\n            return JSON.parse(line); // Parse the JSON string\n          } catch (err) {\n            logger.logError('Error parsing streamed line', err, {\n              line,\n              partial,\n            });\n            // swallow the error and set the partial to our current chunk\n            partial = line;\n            return partial;\n          }\n        };\n\n        // TODO this function is recreated every time new data comes from the stream - define it outside of the generator\n        const processChunk = (chunk: string): unknown[] => {\n          // merge the partial with the incoming chunk\n          const lines = `${partial}${chunk}`.split('\\n');\n\n          const parsedLines = lines\n            .map(line => line.replace(/^data: /, '').trim()) // Remove the \"data: \" prefix\n            .filter(line => line !== '' && line !== '[DONE]') // Remove empty lines and \"[DONE]\"\n            .map(safeParse)\n            .filter(v => v); // and filter out the undefined values\n          return parsedLines;\n        };\n\n        while (true) {\n          // eslint-disable-next-line no-await-in-loop\n          const { done, value } = await reader.read();\n\n          if (done) {\n            break;\n          }\n\n          // Massage and parse the chunk of data\n          const chunk = decoder.decode(value);\n          const parsedLines = processChunk(chunk);\n\n          for (const parsedLine of parsedLines) {\n            const validatedResponse = validateResponse(parsedLine);\n\n            if (validatedResponse) {\n              yield validatedResponse;\n            }\n          }\n        }\n      } catch (error: unknown) {\n        logger.logError('Failed to get next streaming responses', error, {\n          payloadContext: payload?.context,\n          userEvents: payload?.userEvents,\n        });\n        await throwSessionRestartRequiredIf('Failed to get next streaming responses', error);\n      }\n    }\n\n    CommerceApiClient.getInstance().responsesAbortController.abort();\n    CommerceApiClient.getInstance().responsesAbortController = new AbortController();\n\n    return generate(\n      CommerceApiClient.getInstance().inferenceApi,\n      CommerceApiClient.getInstance().responsesAbortController,\n    );\n  };\n\n  static getNextSuggestions = async (payload: NextMessageRequest): Promise<Suggestion[]> => {\n    try {\n      CommerceApiClient.getInstance().suggestionsAbortController.abort();\n      CommerceApiClient.getInstance().suggestionsAbortController = new AbortController();\n\n      const response = await CommerceApiClient.getInstance().inferenceApi.v1NextSuggestionsPost(\n        {\n          NextMessageRequest: messageRequestToCommerceMessageRequest(payload),\n        },\n        {\n          signal: CommerceApiClient.getInstance().suggestionsAbortController.signal,\n        },\n      );\n\n      const suggestions = response\n        .map(resp => validateSuggestion(resp))\n        .filter((suggestion): suggestion is Suggestion => suggestion != null);\n\n      return suggestions;\n    } catch (error: unknown) {\n      logger.logInfo('Failed to get suggestions', error, {\n        payloadContext: payload?.context,\n        userEvents: payload?.userEvents,\n      });\n\n      await throwSessionRestartRequiredIf('Failed to get suggestions', error);\n      return [];\n    }\n  };\n\n  /**\n   * Fetches the existing chat data for a given session and transforms them to reconstruct the chat history.\n   *\n   * @param orgId The organization Id\n   * @param chatId The existing chat Id\n   * @param userId The user Id\n   *\n   * @returns A list of messages that were exchanged in the chat, throws an error if the chat session has expired.\n   */\n  static getResponses = async (\n    orgId: string,\n    chatId: string,\n    userId: string,\n  ): Promise<{\n    responses: Response[][];\n    userEvents: UserEvent[];\n    suggestions: Suggestion[];\n    messages: Message[][];\n  }> => {\n    let data: V1GetSessionMessages200Response = {\n      responses: [],\n      suggestions: [],\n      user_events: [],\n    };\n    const request = {\n      org_id: orgId,\n      chat_id: chatId,\n      user_id: userId,\n    };\n    try {\n      data = await CommerceApiClient.getInstance().defaultApi.v1GetSessionMessages(request);\n    } catch (error: unknown) {\n      await throwSessionRestartRequiredIf('Failed to get chat responses', error);\n    }\n\n    const responses: Response[][] = data?.responses?.map(turn =>\n      turn\n        .map(response => validateResponse(response))\n        .filter((response): response is Response => response != null),\n    );\n\n    const suggestions: Suggestion[] = data?.suggestions\n      .map(suggestion => validateSuggestion(suggestion))\n      .filter((suggestion): suggestion is Suggestion => suggestion != null);\n\n    const userEvents: UserEvent[] = data?.user_events\n      .map(event => validateUserEvent(event))\n      .filter((event): event is UserEvent => event != null);\n\n    // if a form has already been submitted, don't show it in the chat history\n    const formSubmittedUserEventsFormIds = userEvents\n      .filter(event => event.category === UserEventCategory.FormSubmitted)\n      .map(event => event.attributes.formResponseId);\n\n    const assistantMessages: Message[][] = responses\n      .map(turn =>\n        turn\n          .filter(\n            response =>\n              !(\n                response.category === ResponseCategory.Form &&\n                formSubmittedUserEventsFormIds.includes(response.id)\n              ),\n          )\n          .map(response => messageFromResponse(response))\n          .filter((message): message is Message => message != null),\n      )\n      .filter(turn => turn.length > 0);\n\n    const userMessages: Message[][] = userEvents\n      .map(event => {\n        if ([UserEventCategory.QueryTyped, UserEventCategory.Search].includes(event.category)) {\n          return [messageFromQueryEvent(event)];\n        }\n\n        if (event.category === UserEventCategory.SuggestionClicked) {\n          return [messageFromSuggestionEvent(event, suggestions)];\n        }\n\n        if (event.category === UserEventCategory.FormSubmitted) {\n          const formResponse = responses\n            .flat()\n            .find(\n              response =>\n                response.id === event.attributes.formResponseId &&\n                event.attributes.formType !== FormType.Escalation,\n            );\n\n          if (formResponse && formResponse.category === ResponseCategory.Form) {\n            return [messageFromFormSubmittedEvent(event, formResponse.attributes)];\n          }\n        }\n\n        return [];\n      })\n      .filter((message): message is Message[] => message.length > 0);\n\n    // Sort the messages chronologically to reconstruct the chat history\n    const sortedMessages = [...assistantMessages, ...userMessages].sort(\n      (a, b) => new Date(a[0].createdAt).getTime() - new Date(b[0].createdAt).getTime(),\n    );\n\n    return { responses, userEvents, suggestions, messages: sortedMessages };\n  };\n\n  static getHardcopy = async (request: WidgetTextRequest): Promise<WidgetText> => {\n    const apiRequest = coreWidgetTextRequestToApiRequest(request);\n    const response = await CommerceApiClient.getInstance().inferenceApi.v1WidgetTextPost({\n      WidgetTextRequest: apiRequest,\n    });\n    return apiWidgetTextResponseToCoreWidgetText(apiRequest, response);\n  };\n\n  /**\n   * Retrieves product details for the given product IDs via POST /v1/products/retrieve.\n   * Builds context from the current atom store (org, user, chat, etc.) and returns\n   * products in the shape expected by ProductRetrievalResult (camelCase attributes).\n   *\n   * @param productIds - List of product IDs to retrieve\n   * @returns ProductRetrievalResult with products and totalProductCount\n   */\n  static retrieveProducts = async (productIds: string[]): Promise<ProductRetrievalResult> => {\n    if (productIds.length === 0) {\n      return { products: [], totalProductCount: 0 };\n    }\n\n    try {\n      const atomStore = getAtomStore();\n      const orgShortName = atomStore.get(orgShortNameAtom);\n      const orgId = atomStore.get(orgIdAtom);\n      const userId = atomStore.get(userIdAtom);\n      const chatId = atomStore.get(chatIdAtom);\n      const source = atomStore.get(contextSourceAtom);\n      const env = atomStore.get(envAtom);\n\n      const context: Context = {\n        user_id: userId ?? '',\n        org_id: orgId ?? '',\n        org_short_name: orgShortName ?? '',\n        chat_id: chatId ?? '',\n        source: source ?? ContextSourceEnum.App,\n        env: (env as ContextEnvEnum) ?? ContextEnvEnum.Dev,\n      };\n\n      const response = await CommerceApiClient.getInstance().productsApi.v1ProductsRetrievePost({\n        ProductRetrievalRequest: {\n          context,\n          product_ids: productIds,\n        },\n      });\n\n      return productRetrievalResponseToProductRetrievalResult(response);\n    } catch (err) {\n      await throwSessionRestartRequiredIf('Failed to retrieve products', err);\n      return { products: [], totalProductCount: 0 };\n    }\n  };\n\n  /**\n   *\n   * @param payload\n   * @returns\n   */\n  static isSupportedEvent = async (payload: SupportedEventRequest): Promise<SupportedEvent> => {\n    try {\n      const rawResponse =\n        await CommerceApiClient.getInstance().inferenceApi.v1SupportedEventPostRaw({\n          SupportedEventRequest: coreSupportedEventRequestToApiRequest(payload),\n        });\n\n      // Get the actual HTTP response JSON\n      const httpResponseText = await rawResponse.raw.text();\n      const httpResponseJson = JSON.parse(httpResponseText);\n\n      return {\n        ...httpResponseJson,\n        numberOfReviews: httpResponseJson.num_of_reviews,\n        merchant_tags: httpResponseJson.merchant_tags || [],\n      };\n    } catch (err) {\n      logger.logError('Failed to get response for v1SupportedEventPost', {\n        err,\n      });\n      return {\n        supported: false,\n        ready: false,\n        category: undefined,\n        collections: [],\n        numberOfReviews: undefined,\n        top_category: undefined,\n        merchant_tags: [],\n      };\n    }\n  };\n\n  private static mapContextSourceToV1OrgConfigGetSource = (\n    source: ContextSourceEnum | undefined,\n  ): V1OrgConfigGetSourceEnum | undefined => {\n    if (source === undefined) return undefined;\n    switch (source) {\n      case ContextSourceEnum.Fork:\n        return V1OrgConfigGetSourceEnum.Fork;\n      case ContextSourceEnum.Playground:\n        return V1OrgConfigGetSourceEnum.Playground;\n      case ContextSourceEnum.App:\n        return V1OrgConfigGetSourceEnum.App;\n      case ContextSourceEnum.Test:\n        return V1OrgConfigGetSourceEnum.Test;\n      case ContextSourceEnum.Eval:\n        return V1OrgConfigGetSourceEnum.Test;\n      default: {\n        // This ensures that if new values are added to ContextSourceEnum, we catch it\n        const exhaustiveCheck: never = source;\n        return exhaustiveCheck;\n      }\n    }\n  };\n\n  static getOrgConfig = async (user_id: string): Promise<OrgConfig | undefined> => {\n    try {\n      const atomStore = getAtomStore();\n      const reactAppName = atomStore.get(reactAppNameAtom);\n      const contextSource = atomStore.get(contextSourceAtom);\n      const featureFlagService = atomStore.get(featureFlagServiceAtom); // Get featureFlagService\n      const request: V1OrgConfigGetRequest = {\n        namespace: reactAppName,\n        user_id,\n        source: this.mapContextSourceToV1OrgConfigGetSource(contextSource),\n        include_experiments: Object.values(ProductExperiment),\n        include_feature_gates: Object.entries(\n          featureFlagService?.featureFlagService?.getFeatureFlags() || {},\n        )\n          .filter(([, isEnabled]) => isEnabled)\n          .map(([featureGateName]) => featureGateName), // Use featureFlagService\n      };\n      const response = await CommerceApiClient.getInstance().defaultApi.v1OrgConfigGet(request);\n\n      return validateOrgConfigResults(response);\n    } catch (err) {\n      logger.logError(`Failed to get org config`, err, { err });\n      return undefined;\n    }\n  };\n\n  static addNoteToLatestConversation = async (\n    spiffyUserId: string,\n    email: string,\n    customerServiceProvider: CustomerServiceProvider,\n  ) => {\n    logger.logInfo(\n      `addNoteToLatestConversation - user_id=${spiffyUserId} email=${email} customer_service_provider=${customerServiceProvider}`,\n    );\n    try {\n      await CommerceApiClient.getInstance().customerServiceApi.v1CustserviceAddNoteToLatestConversationPost(\n        {\n          AddNoteToLatestConversationRequest: {\n            spiffy_user_id: spiffyUserId,\n            email,\n            customer_service_provider: customerServiceProvider,\n          },\n        },\n      );\n    } catch (err) {\n      logger.logError('Failed to add note to latest conversation', { err });\n    }\n  };\n\n  static getCustomerServiceApi = () => CommerceApiClient.getInstance().customerServiceApi;\n}\n\nexport default CommerceApiClient;\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"commerce-api.js","names":["Logger","config: Configuration","context: Context","err: unknown","error: unknown","data: V1GetSessionMessages200Response","responses: Response[][]","suggestions: Suggestion[]","userEvents: UserEvent[]","assistantMessages: Message[][]","userMessages: Message[][]","request: V1OrgConfigGetRequest"],"sources":["../../src/application/commerce-api.ts"],"sourcesContent":["import {\n  Configuration,\n  ContextEnvEnum,\n  ContextSourceEnum,\n  CustomerServiceApi,\n  CustomerServiceProvider,\n  DefaultApi,\n  FormType,\n  InferenceApi,\n  ProductsApi,\n  ReportSessionRequest,\n  ResponseCategory,\n  ResponseError,\n  UserEventCategory,\n  V1GetSessionMessages200Response,\n  V1OrgConfigGetRequest,\n  V1OrgConfigGetSourceEnum,\n} from '@spiffy-ai/commerce-api-client';\nimport type { Context } from '@spiffy-ai/commerce-api-client/dist/models/Context';\nimport type { ProductRetrievalResult } from 'src/atoms/search/types';\nimport Logger from 'src/application/logging/logger';\nimport {\n  Message,\n  NextMessageRequest,\n  Response,\n  Suggestion,\n  SupportedEventRequest,\n  UserEvent,\n} from 'src/application/models';\nimport { OrgConfig } from 'src/application/models/api/orgConfigResults';\nimport {\n  ProductDetails,\n  getProductOptionsQuery,\n} from 'src/application/models/graphql/queries/getProductOptionsQuery';\nimport { ProductExperiment } from 'src/application/models/productExperiment';\nimport { validateOrgConfigResults } from 'src/application/models/validators/validateOrgConfigResults';\nimport { validateResponse } from 'src/application/models/validators/validateResponse';\nimport { validateSuggestion } from 'src/application/models/validators/validateSuggestion';\nimport { validateUserEvent } from 'src/application/models/validators/validateUserEvent';\nimport {\n  getQueryParam,\n  messageFromAddToCartEvent,\n  messageFromQueryEvent,\n  messageFromResponse,\n  messageFromSuggestionEvent,\n} from 'src/application/utils';\nimport { messageFromFormSubmittedEvent } from 'src/application/utils/messageFromFormSubmittedEvent';\nimport { messageRequestToCommerceMessageRequest } from 'src/application/utils/nextMessageRequestToApiRequest';\nimport { coreSupportedEventRequestToApiRequest } from 'src/application/utils/supportedEventRequestToApiRequest';\nimport { chatIdAtom, userIdAtom } from 'src/atoms/app'; // Import userIdAtom and chatIdAtom\nimport { SupportedEvent } from 'src/atoms/app/variant';\nimport { getAtomStore } from 'src/atoms/atomStore/atomStore';\nimport { resolvedBaseConfigVersionAtom } from 'src/atoms/envive/resolvedBaseConfigVersion';\nimport {\n  baseUrlAtom,\n  contextSourceAtom,\n  envAtom,\n  orgIdAtom,\n  orgLevelApiKeyAtom,\n  orgShortNameAtom,\n  reactAppNameAtom, // Import envAtom\n} from 'src/atoms/envive/enviveConfig';\nimport { featureFlagServiceAtom } from 'src/atoms/org/graphqlConfig'; // Import new orgIdAtom and featureFlagServiceAtom\nimport { SessionRestartRequired } from 'src/types/exceptions/sessionExceptions';\nimport { UnsupportedProductException } from 'src/types/exceptions/unsupportedProductExceptions';\nimport { WidgetText } from './models/api/widgetText';\nimport { WidgetTextRequest } from './models/api/widgetTextRequest';\nimport { productRetrievalResponseToProductRetrievalResult } from './utils/productRetrievalResponseToProductRetrievalResult';\nimport { apiWidgetTextResponseToCoreWidgetText } from './utils/widgetTextFromApiWidgetTextResponse';\nimport { coreWidgetTextRequestToApiRequest } from './utils/widgetTextRequestToApiRequest';\n\nconst logger = new Logger('commerce-api');\n\nasync function errorResponseBody(error: ResponseError) {\n  try {\n    return await error.response.json();\n  } catch {\n    return {};\n  }\n}\n\nasync function throwSessionRestartRequiredIf(errorMsg: string, error: unknown) {\n  if (!(error instanceof ResponseError)) {\n    logger.logInfo(errorMsg, error);\n    throw error;\n  }\n\n  const errorResponse = await errorResponseBody(error);\n  if (\n    errorResponse?.message?.toLowerCase() === 'unsupported product' || // for backward compatibility. newer versions of the API return sub_code instead of message\n    errorResponse?.app_code?.toUpperCase() === 'PRODUCT_NOT_FOUND'\n  ) {\n    throw new UnsupportedProductException();\n  } else if (\n    errorResponse?.app_code?.toUpperCase() === 'RESTART_SESSION' ||\n    errorResponse?.sub_code?.toUpperCase() === 'NOT_FOUND' // for backward compatibility. new API responses will contain \"app_code\"\n  ) {\n    logger.logInfo(\n      'Session does not exist. Re-start session',\n      error,\n      error.response,\n      errorResponse,\n    );\n    throw new SessionRestartRequired();\n  }\n\n  logger.logInfo(errorMsg, error);\n  throw error;\n}\n\nclass CommerceApiClient {\n  private readonly defaultApi: DefaultApi;\n\n  private readonly customerServiceApi: CustomerServiceApi;\n\n  private readonly inferenceApi: InferenceApi;\n\n  private readonly productsApi: ProductsApi;\n\n  private static instance: CommerceApiClient | undefined;\n\n  private suggestionsAbortController = new AbortController();\n\n  private responsesAbortController = new AbortController();\n\n  private static getInstance = (): CommerceApiClient => {\n    if (!CommerceApiClient.instance) {\n      CommerceApiClient.instance = new CommerceApiClient();\n    }\n\n    return CommerceApiClient.instance;\n  };\n\n  private constructor(basePath?: string) {\n    const atomStore = getAtomStore();\n    const baseUrl = atomStore.get(baseUrlAtom);\n    const apiKey = atomStore.get(orgLevelApiKeyAtom);\n    const path = basePath || baseUrl;\n    // API Key is now handled at the EnviveConfigProvider level\n    const config: Configuration = new Configuration({\n      accessToken: apiKey,\n      basePath: path,\n      headers: {\n        'Content-Type': 'application/json',\n        Accept: 'application/json',\n      },\n    });\n    this.defaultApi = new DefaultApi(config);\n    this.inferenceApi = new InferenceApi(config);\n    this.customerServiceApi = new CustomerServiceApi(config);\n    this.productsApi = new ProductsApi(config);\n  }\n\n  // Dedupes concurrent resolutions of the same URL: the injection bundle\n  // warms this call before React mounts, and PageProvider may request the\n  // same URL while the warm-up is still in flight.\n  private static inFlightUrlResolutions = new Map<string, Promise<unknown>>();\n\n  static resolveUrl = async (url: string) => {\n    const inFlight = CommerceApiClient.inFlightUrlResolutions.get(url);\n    if (inFlight) {\n      return inFlight;\n    }\n    const request = CommerceApiClient.resolveUrlUncached(url);\n    CommerceApiClient.inFlightUrlResolutions.set(url, request);\n    try {\n      return await request;\n    } finally {\n      CommerceApiClient.inFlightUrlResolutions.delete(url);\n    }\n  };\n\n  private static resolveUrlUncached = async (url: string) => {\n    const atomStore = getAtomStore();\n    const orgShortName = atomStore.get(orgShortNameAtom);\n    const orgId = atomStore.get(orgIdAtom);\n    const userId = atomStore.get(userIdAtom);\n    const chatId = atomStore.get(chatIdAtom);\n    const source = atomStore.get(contextSourceAtom);\n    const env = atomStore.get(envAtom);\n\n    const featureFlagService = atomStore.get(featureFlagServiceAtom);\n\n    const context: Context = {\n      user_id: userId ?? '',\n      org_id: orgId ?? '',\n      org_short_name: orgShortName ?? '',\n      chat_id: chatId ?? '',\n      source: source ?? ContextSourceEnum.App,\n      env: (env as ContextEnvEnum) ?? ContextEnvEnum.Dev, // Cast env to ContextEnvEnum\n    };\n\n    const overrideConfigVersion =\n      getQueryParam('spiffy_config_version') ||\n      getQueryParam('envive_config_version') ||\n      getAtomStore().get(resolvedBaseConfigVersionAtom) ||\n      undefined;\n\n    const featureGates = featureFlagService?.featureFlagService?.getFeatureFlags() || {};\n    const urlResolvingRequest = {\n      url,\n      context,\n      feature_gates: featureGates,\n      override_config_version: overrideConfigVersion,\n    };\n\n    const rawResponse = await CommerceApiClient.getInstance().inferenceApi.v1UrlResolvingPostRaw({\n      UrlResolvingRequest: urlResolvingRequest,\n    });\n\n    const responseBody = await rawResponse.raw.json();\n\n    return responseBody;\n  };\n\n  static reportSession = async (reportRequest: ReportSessionRequest): Promise<void> => {\n    await CommerceApiClient.getInstance().defaultApi.v1ChatsReportSessionIdPost({\n      ReportSessionRequest: reportRequest,\n    });\n  };\n\n  static getNextResponses = async (payload: NextMessageRequest): Promise<Message[]> => {\n    try {\n      const response = await CommerceApiClient.getInstance().inferenceApi.v1NextResponsesPost({\n        NextMessageRequest: messageRequestToCommerceMessageRequest(payload),\n      });\n      const messages = response\n        .map(resp => validateResponse(resp))\n        .map(resp => messageFromResponse(resp));\n\n      return messages.filter((m): m is Message => m != null);\n    } catch (err: unknown) {\n      logger.logInfo('Failed to get next responses', err, {\n        payloadContext: payload?.context,\n        userEvents: payload?.userEvents,\n      });\n      await throwSessionRestartRequiredIf('Failed to get next responses', err);\n      return [];\n    }\n  };\n\n  static getNextResponseStreaming = (\n    payload: NextMessageRequest,\n  ): AsyncGenerator<Response, void, unknown> => {\n    async function* generate(inferenceApi: InferenceApi, abortController: AbortController) {\n      // make sure streaming is enabled\n      try {\n        const response = await inferenceApi.v1NextResponsesPostRaw(\n          {\n            NextMessageRequest: messageRequestToCommerceMessageRequest(payload),\n          },\n          { signal: abortController.signal },\n        );\n\n        // Read the response as a stream of data\n        if (!response.raw.body) {\n          logger.logError('No body in the streamed response', undefined, {\n            response: response.raw,\n          });\n          return;\n        }\n\n        const reader = response.raw.body.getReader();\n        const decoder = new TextDecoder('utf-8');\n\n        let partial = '';\n        // TODO this function is recreated every time new data comes from the stream - define it outside of the generator\n        const safeParse = (line: string): unknown => {\n          try {\n            return JSON.parse(line); // Parse the JSON string\n          } catch (err) {\n            logger.logError('Error parsing streamed line', err, {\n              line,\n              partial,\n            });\n            // swallow the error and set the partial to our current chunk\n            partial = line;\n            return partial;\n          }\n        };\n\n        // TODO this function is recreated every time new data comes from the stream - define it outside of the generator\n        const processChunk = (chunk: string): unknown[] => {\n          // merge the partial with the incoming chunk\n          const lines = `${partial}${chunk}`.split('\\n');\n\n          const parsedLines = lines\n            .map(line => line.replace(/^data: /, '').trim()) // Remove the \"data: \" prefix\n            .filter(line => line !== '' && line !== '[DONE]') // Remove empty lines and \"[DONE]\"\n            .map(safeParse)\n            .filter(v => v); // and filter out the undefined values\n          return parsedLines;\n        };\n\n        while (true) {\n          // eslint-disable-next-line no-await-in-loop\n          const { done, value } = await reader.read();\n\n          if (done) {\n            break;\n          }\n\n          // Massage and parse the chunk of data\n          const chunk = decoder.decode(value);\n          const parsedLines = processChunk(chunk);\n\n          for (const parsedLine of parsedLines) {\n            const validatedResponse = validateResponse(parsedLine);\n\n            if (validatedResponse) {\n              yield validatedResponse;\n            }\n          }\n        }\n      } catch (error: unknown) {\n        logger.logError('Failed to get next streaming responses', error, {\n          payloadContext: payload?.context,\n          userEvents: payload?.userEvents,\n        });\n        await throwSessionRestartRequiredIf('Failed to get next streaming responses', error);\n      }\n    }\n\n    CommerceApiClient.getInstance().responsesAbortController.abort();\n    CommerceApiClient.getInstance().responsesAbortController = new AbortController();\n\n    return generate(\n      CommerceApiClient.getInstance().inferenceApi,\n      CommerceApiClient.getInstance().responsesAbortController,\n    );\n  };\n\n  static getNextSuggestions = async (payload: NextMessageRequest): Promise<Suggestion[]> => {\n    try {\n      CommerceApiClient.getInstance().suggestionsAbortController.abort();\n      CommerceApiClient.getInstance().suggestionsAbortController = new AbortController();\n\n      const response = await CommerceApiClient.getInstance().inferenceApi.v1NextSuggestionsPost(\n        {\n          NextMessageRequest: messageRequestToCommerceMessageRequest(payload),\n        },\n        {\n          signal: CommerceApiClient.getInstance().suggestionsAbortController.signal,\n        },\n      );\n\n      const suggestions = response\n        .map(resp => validateSuggestion(resp))\n        .filter((suggestion): suggestion is Suggestion => suggestion != null);\n\n      return suggestions;\n    } catch (error: unknown) {\n      logger.logInfo('Failed to get suggestions', error, {\n        payloadContext: payload?.context,\n        userEvents: payload?.userEvents,\n      });\n\n      await throwSessionRestartRequiredIf('Failed to get suggestions', error);\n      return [];\n    }\n  };\n\n  /**\n   * Fetches the existing chat data for a given session and transforms them to reconstruct the chat history.\n   *\n   * @param orgId The organization Id\n   * @param chatId The existing chat Id\n   * @param userId The user Id\n   *\n   * @returns A list of messages that were exchanged in the chat, throws an error if the chat session has expired.\n   */\n  static getResponses = async (\n    orgId: string,\n    chatId: string,\n    userId: string,\n  ): Promise<{\n    responses: Response[][];\n    userEvents: UserEvent[];\n    suggestions: Suggestion[];\n    messages: Message[][];\n  }> => {\n    let data: V1GetSessionMessages200Response = {\n      responses: [],\n      suggestions: [],\n      user_events: [],\n    };\n    const request = {\n      org_id: orgId,\n      chat_id: chatId,\n      user_id: userId,\n    };\n    try {\n      data = await CommerceApiClient.getInstance().defaultApi.v1GetSessionMessages(request);\n    } catch (error: unknown) {\n      await throwSessionRestartRequiredIf('Failed to get chat responses', error);\n    }\n\n    const responses: Response[][] = data?.responses?.map(turn =>\n      turn\n        .map(response => validateResponse(response))\n        .filter((response): response is Response => response != null),\n    );\n\n    const suggestions: Suggestion[] = data?.suggestions\n      .map(suggestion => validateSuggestion(suggestion))\n      .filter((suggestion): suggestion is Suggestion => suggestion != null);\n\n    const userEvents: UserEvent[] = data?.user_events\n      .map(event => validateUserEvent(event))\n      .filter((event): event is UserEvent => event != null);\n\n    // if a form has already been submitted, don't show it in the chat history\n    const formSubmittedUserEventsFormIds = userEvents\n      .filter(event => event.category === UserEventCategory.FormSubmitted)\n      .map(event => event.attributes.formResponseId);\n\n    const assistantMessages: Message[][] = responses\n      .map(turn =>\n        turn\n          .filter(\n            response =>\n              !(\n                response.category === ResponseCategory.Form &&\n                formSubmittedUserEventsFormIds.includes(response.id)\n              ),\n          )\n          .map(response => messageFromResponse(response))\n          .filter((message): message is Message => message != null),\n      )\n      .filter(turn => turn.length > 0);\n\n    const userMessages: Message[][] = (\n      await Promise.all(\n        userEvents.map(async event => {\n          if ([UserEventCategory.QueryTyped, UserEventCategory.Search].includes(event.category)) {\n            return [messageFromQueryEvent(event)];\n          }\n\n          if (event.category === UserEventCategory.SuggestionClicked) {\n            return [messageFromSuggestionEvent(event, suggestions)];\n          }\n\n          if (event.category === UserEventCategory.AddToCart) {\n            // Historical events never carried a client-local productTitle (it's\n            // dropped before hitting the backend), so resolve it here: first for\n            // free from a matching Product response already fetched above, then\n            // as a fallback via the cached product-details call.\n            const matchedProduct = responses\n              .flat()\n              .find(\n                response =>\n                  response.category === ResponseCategory.Product &&\n                  response.attributes.id === event.attributes.productId,\n              );\n            let productTitle =\n              matchedProduct?.category === ResponseCategory.Product\n                ? matchedProduct.attributes.title\n                : undefined;\n            if (!productTitle) {\n              try {\n                const details = await CommerceApiClient.retrieveProductDetails(\n                  event.attributes.productId,\n                );\n                productTitle = details?.title;\n              } catch {\n                productTitle = undefined;\n              }\n            }\n            return [messageFromAddToCartEvent(event, productTitle)];\n          }\n\n          if (event.category === UserEventCategory.FormSubmitted) {\n            const formResponse = responses\n              .flat()\n              .find(\n                response =>\n                  response.id === event.attributes.formResponseId &&\n                  event.attributes.formType !== FormType.Escalation,\n              );\n\n            if (formResponse && formResponse.category === ResponseCategory.Form) {\n              return [messageFromFormSubmittedEvent(event, formResponse.attributes)];\n            }\n          }\n\n          return [];\n        }),\n      )\n    ).filter((message): message is Message[] => message.length > 0);\n\n    // Sort the messages chronologically to reconstruct the chat history\n    const sortedMessages = [...assistantMessages, ...userMessages].sort(\n      (a, b) => new Date(a[0].createdAt).getTime() - new Date(b[0].createdAt).getTime(),\n    );\n\n    return { responses, userEvents, suggestions, messages: sortedMessages };\n  };\n\n  static getHardcopy = async (request: WidgetTextRequest): Promise<WidgetText> => {\n    const apiRequest = coreWidgetTextRequestToApiRequest(request);\n    const response = await CommerceApiClient.getInstance().inferenceApi.v1WidgetTextPost({\n      WidgetTextRequest: apiRequest,\n    });\n    return apiWidgetTextResponseToCoreWidgetText(apiRequest, response);\n  };\n\n  /**\n   * Retrieves product details for the given product IDs via POST /v1/products/retrieve.\n   * Builds context from the current atom store (org, user, chat, etc.) and returns\n   * products in the shape expected by ProductRetrievalResult (camelCase attributes).\n   *\n   * @param productIds - List of product IDs to retrieve\n   * @returns ProductRetrievalResult with products and totalProductCount\n   */\n  static retrieveProducts = async (productIds: string[]): Promise<ProductRetrievalResult> => {\n    if (productIds.length === 0) {\n      return { products: [], totalProductCount: 0 };\n    }\n\n    try {\n      const atomStore = getAtomStore();\n      const orgShortName = atomStore.get(orgShortNameAtom);\n      const orgId = atomStore.get(orgIdAtom);\n      const userId = atomStore.get(userIdAtom);\n      const chatId = atomStore.get(chatIdAtom);\n      const source = atomStore.get(contextSourceAtom);\n      const env = atomStore.get(envAtom);\n\n      const context: Context = {\n        user_id: userId ?? '',\n        org_id: orgId ?? '',\n        org_short_name: orgShortName ?? '',\n        chat_id: chatId ?? '',\n        source: source ?? ContextSourceEnum.App,\n        env: (env as ContextEnvEnum) ?? ContextEnvEnum.Dev,\n      };\n\n      const response = await CommerceApiClient.getInstance().productsApi.v1ProductsRetrievePost({\n        ProductRetrievalRequest: {\n          context,\n          product_ids: productIds,\n        },\n      });\n\n      return productRetrievalResponseToProductRetrievalResult(response);\n    } catch (err) {\n      await throwSessionRestartRequiredIf('Failed to retrieve products', err);\n      return { products: [], totalProductCount: 0 };\n    }\n  };\n\n  // Caches resolved product details by productId for the lifetime of the\n  // session: variant selection, the display of the add-to-cart chat message,\n  // and useProductDetails all resolve the same product repeatedly. Failed\n  // requests are evicted so a later call can retry.\n  private static productDetailsCache = new Map<string, Promise<ProductDetails | undefined>>();\n\n  static retrieveProductDetails = (productId: string): Promise<ProductDetails | undefined> => {\n    const cached = CommerceApiClient.productDetailsCache.get(productId);\n    if (cached) {\n      return cached;\n    }\n    const request = CommerceApiClient.retrieveProductDetailsUncached(productId).catch(err => {\n      CommerceApiClient.productDetailsCache.delete(productId);\n      throw err;\n    });\n    CommerceApiClient.productDetailsCache.set(productId, request);\n    return request;\n  };\n\n  /**\n   * Retrieves variant-level product details for a single product via the GraphQL\n   * `me.productOptions` query on POST /v1/graphql. Only meaningful for products\n   * that offer variations.\n   *\n   * @param productId - The product ID to retrieve details for\n   * @returns ProductDetails, or undefined when the product has no options data\n   * @throws on network/HTTP failure or GraphQL errors\n   */\n  private static retrieveProductDetailsUncached = async (\n    productId: string,\n  ): Promise<ProductDetails | undefined> => {\n    const atomStore = getAtomStore();\n    const baseUrl = atomStore.get(baseUrlAtom);\n    const apiKey = atomStore.get(orgLevelApiKeyAtom);\n\n    try {\n      const response = await fetch(`${baseUrl}/v1/graphql`, {\n        method: 'POST',\n        headers: {\n          'Content-Type': 'application/json',\n          Authorization: `Bearer ${apiKey}`,\n        },\n        body: JSON.stringify({\n          query: getProductOptionsQuery(),\n          variables: { productId },\n        }),\n      });\n\n      if (!response.ok) {\n        throw new ResponseError(response, `GraphQL request failed: ${response.statusText}`);\n      }\n\n      const result = await response.json();\n      if (result.errors) {\n        throw new Error(`GraphQL errors: ${JSON.stringify(result.errors)}`);\n      }\n\n      return result.data?.me?.productOptions ?? undefined;\n    } catch (err) {\n      await throwSessionRestartRequiredIf('Failed to retrieve product details', err);\n      return undefined;\n    }\n  };\n\n  /**\n   *\n   * @param payload\n   * @returns\n   */\n  static isSupportedEvent = async (payload: SupportedEventRequest): Promise<SupportedEvent> => {\n    try {\n      const rawResponse =\n        await CommerceApiClient.getInstance().inferenceApi.v1SupportedEventPostRaw({\n          SupportedEventRequest: coreSupportedEventRequestToApiRequest(payload),\n        });\n\n      // Get the actual HTTP response JSON\n      const httpResponseText = await rawResponse.raw.text();\n      const httpResponseJson = JSON.parse(httpResponseText);\n\n      return {\n        ...httpResponseJson,\n        numberOfReviews: httpResponseJson.num_of_reviews,\n        merchant_tags: httpResponseJson.merchant_tags || [],\n      };\n    } catch (err) {\n      logger.logError('Failed to get response for v1SupportedEventPost', {\n        err,\n      });\n      return {\n        supported: false,\n        ready: false,\n        category: undefined,\n        collections: [],\n        numberOfReviews: undefined,\n        top_category: undefined,\n        merchant_tags: [],\n      };\n    }\n  };\n\n  private static mapContextSourceToV1OrgConfigGetSource = (\n    source: ContextSourceEnum | undefined,\n  ): V1OrgConfigGetSourceEnum | undefined => {\n    if (source === undefined) return undefined;\n    switch (source) {\n      case ContextSourceEnum.Fork:\n        return V1OrgConfigGetSourceEnum.Fork;\n      case ContextSourceEnum.Playground:\n        return V1OrgConfigGetSourceEnum.Playground;\n      case ContextSourceEnum.App:\n        return V1OrgConfigGetSourceEnum.App;\n      case ContextSourceEnum.Test:\n        return V1OrgConfigGetSourceEnum.Test;\n      case ContextSourceEnum.Eval:\n        return V1OrgConfigGetSourceEnum.Test;\n      default: {\n        // This ensures that if new values are added to ContextSourceEnum, we catch it\n        const exhaustiveCheck: never = source;\n        return exhaustiveCheck;\n      }\n    }\n  };\n\n  static getOrgConfig = async (user_id: string): Promise<OrgConfig | undefined> => {\n    try {\n      const atomStore = getAtomStore();\n      const reactAppName = atomStore.get(reactAppNameAtom);\n      const contextSource = atomStore.get(contextSourceAtom);\n      const featureFlagService = atomStore.get(featureFlagServiceAtom); // Get featureFlagService\n      const request: V1OrgConfigGetRequest = {\n        namespace: reactAppName,\n        user_id,\n        source: this.mapContextSourceToV1OrgConfigGetSource(contextSource),\n        include_experiments: Object.values(ProductExperiment),\n        include_feature_gates: Object.entries(\n          featureFlagService?.featureFlagService?.getFeatureFlags() || {},\n        )\n          .filter(([, isEnabled]) => isEnabled)\n          .map(([featureGateName]) => featureGateName), // Use featureFlagService\n      };\n      const response = await CommerceApiClient.getInstance().defaultApi.v1OrgConfigGet(request);\n\n      return validateOrgConfigResults(response);\n    } catch (err) {\n      logger.logError(`Failed to get org config`, err, { err });\n      return undefined;\n    }\n  };\n\n  static addNoteToLatestConversation = async (\n    spiffyUserId: string,\n    email: string,\n    customerServiceProvider: CustomerServiceProvider,\n  ) => {\n    logger.logInfo(\n      `addNoteToLatestConversation - user_id=${spiffyUserId} email=${email} customer_service_provider=${customerServiceProvider}`,\n    );\n    try {\n      await CommerceApiClient.getInstance().customerServiceApi.v1CustserviceAddNoteToLatestConversationPost(\n        {\n          AddNoteToLatestConversationRequest: {\n            spiffy_user_id: spiffyUserId,\n            email,\n            customer_service_provider: customerServiceProvider,\n          },\n        },\n      );\n    } catch (err) {\n      logger.logError('Failed to add note to latest conversation', { err });\n    }\n  };\n\n  static getCustomerServiceApi = () => CommerceApiClient.getInstance().customerServiceApi;\n}\n\nexport default CommerceApiClient;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,MAAM,SAAS,IAAIA,eAAO,eAAe;AAEzC,eAAe,kBAAkB,OAAsB;AACrD,KAAI;AACF,SAAO,MAAM,MAAM,SAAS,MAAM;SAC5B;AACN,SAAO,EAAE;;;AAIb,eAAe,8BAA8B,UAAkB,OAAgB;AAC7E,KAAI,EAAE,iBAAiB,gBAAgB;AACrC,SAAO,QAAQ,UAAU,MAAM;AAC/B,QAAM;;CAGR,MAAM,gBAAgB,MAAM,kBAAkB,MAAM;AACpD,KACE,eAAe,SAAS,aAAa,KAAK,yBAC1C,eAAe,UAAU,aAAa,KAAK,oBAE3C,OAAM,IAAI,6BAA6B;UAEvC,eAAe,UAAU,aAAa,KAAK,qBAC3C,eAAe,UAAU,aAAa,KAAK,aAC3C;AACA,SAAO,QACL,4CACA,OACA,MAAM,UACN,cACD;AACD,QAAM,IAAI,wBAAwB;;AAGpC,QAAO,QAAQ,UAAU,MAAM;AAC/B,OAAM;;AAGR,IAAM,oBAAN,MAAM,kBAAkB;;2BAegC;AACpD,OAAI,CAAC,kBAAkB,SACrB,mBAAkB,WAAW,IAAI,mBAAmB;AAGtD,UAAO,kBAAkB;;;CAG3B,AAAQ,YAAY,UAAmB;oCAZF,IAAI,iBAAiB;kCAEvB,IAAI,iBAAiB;EAWtD,MAAM,YAAY,cAAc;EAChC,MAAM,UAAU,UAAU,IAAI,YAAY;EAI1C,MAAMC,SAAwB,IAAI,cAAc;GAC9C,aAJa,UAAU,IAAI,mBAAmB;GAK9C,UAJW,YAAY;GAKvB,SAAS;IACP,gBAAgB;IAChB,QAAQ;IACT;GACF,CAAC;AACF,OAAK,aAAa,IAAI,WAAW,OAAO;AACxC,OAAK,eAAe,IAAI,aAAa,OAAO;AAC5C,OAAK,qBAAqB,IAAI,mBAAmB,OAAO;AACxD,OAAK,cAAc,IAAI,YAAY,OAAO;;;gDAMJ,IAAI,KAA+B;;;oBAEvD,OAAO,QAAgB;GACzC,MAAM,WAAW,kBAAkB,uBAAuB,IAAI,IAAI;AAClE,OAAI,SACF,QAAO;GAET,MAAM,UAAU,kBAAkB,mBAAmB,IAAI;AACzD,qBAAkB,uBAAuB,IAAI,KAAK,QAAQ;AAC1D,OAAI;AACF,WAAO,MAAM;aACL;AACR,sBAAkB,uBAAuB,OAAO,IAAI;;;;;4BAIpB,OAAO,QAAgB;GACzD,MAAM,YAAY,cAAc;GAChC,MAAM,eAAe,UAAU,IAAI,iBAAiB;GACpD,MAAM,QAAQ,UAAU,IAAI,UAAU;GACtC,MAAM,SAAS,UAAU,IAAI,WAAW;GACxC,MAAM,SAAS,UAAU,IAAI,WAAW;GACxC,MAAM,SAAS,UAAU,IAAI,kBAAkB;GAC/C,MAAM,MAAM,UAAU,IAAI,QAAQ;GAElC,MAAM,qBAAqB,UAAU,IAAI,uBAAuB;GAEhE,MAAMC,UAAmB;IACvB,SAAS,UAAU;IACnB,QAAQ,SAAS;IACjB,gBAAgB,gBAAgB;IAChC,SAAS,UAAU;IACnB,QAAQ,UAAU,kBAAkB;IACpC,KAAM,OAA0B,eAAe;IAChD;GAED,MAAM,wBACJ,cAAc,wBAAwB,IACtC,cAAc,wBAAwB,IACtC,cAAc,CAAC,IAAI,8BAA8B,IACjD;GAGF,MAAM,sBAAsB;IAC1B;IACA;IACA,eAJmB,oBAAoB,oBAAoB,iBAAiB,IAAI,EAAE;IAKlF,yBAAyB;IAC1B;AAQD,UAFqB,OAJD,MAAM,kBAAkB,aAAa,CAAC,aAAa,sBAAsB,EAC3F,qBAAqB,qBACtB,CAAC,EAEqC,IAAI,MAAM;;;;uBAK5B,OAAO,kBAAuD;AACnF,SAAM,kBAAkB,aAAa,CAAC,WAAW,2BAA2B,EAC1E,sBAAsB,eACvB,CAAC;;;;0BAGsB,OAAO,YAAoD;AACnF,OAAI;AAQF,YAPiB,MAAM,kBAAkB,aAAa,CAAC,aAAa,oBAAoB,EACtF,oBAAoB,uCAAuC,QAAQ,EACpE,CAAC,EAEC,KAAI,SAAQ,iBAAiB,KAAK,CAAC,CACnC,KAAI,SAAQ,oBAAoB,KAAK,CAAC,CAEzB,QAAQ,MAAoB,KAAK,KAAK;YAC/CC,KAAc;AACrB,WAAO,QAAQ,gCAAgC,KAAK;KAClD,gBAAgB,SAAS;KACzB,YAAY,SAAS;KACtB,CAAC;AACF,UAAM,8BAA8B,gCAAgC,IAAI;AACxE,WAAO,EAAE;;;;;mCAKX,YAC4C;GAC5C,gBAAgB,SAAS,cAA4B,iBAAkC;AAErF,QAAI;KACF,MAAM,WAAW,MAAM,aAAa,uBAClC,EACE,oBAAoB,uCAAuC,QAAQ,EACpE,EACD,EAAE,QAAQ,gBAAgB,QAAQ,CACnC;AAGD,SAAI,CAAC,SAAS,IAAI,MAAM;AACtB,aAAO,SAAS,oCAAoC,QAAW,EAC7D,UAAU,SAAS,KACpB,CAAC;AACF;;KAGF,MAAM,SAAS,SAAS,IAAI,KAAK,WAAW;KAC5C,MAAM,UAAU,IAAI,YAAY,QAAQ;KAExC,IAAI,UAAU;KAEd,MAAM,aAAa,SAA0B;AAC3C,UAAI;AACF,cAAO,KAAK,MAAM,KAAK;eAChB,KAAK;AACZ,cAAO,SAAS,+BAA+B,KAAK;QAClD;QACA;QACD,CAAC;AAEF,iBAAU;AACV,cAAO;;;KAKX,MAAM,gBAAgB,UAA6B;AASjD,aAPc,GAAG,UAAU,QAAQ,MAAM,KAAK,CAG3C,KAAI,SAAQ,KAAK,QAAQ,WAAW,GAAG,CAAC,MAAM,CAAC,CAC/C,QAAO,SAAQ,SAAS,MAAM,SAAS,SAAS,CAChD,IAAI,UAAU,CACd,QAAO,MAAK,EAAE;;AAInB,YAAO,MAAM;MAEX,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,MAAM;AAE3C,UAAI,KACF;MAKF,MAAM,cAAc,aADN,QAAQ,OAAO,MAAM,CACI;AAEvC,WAAK,MAAM,cAAc,aAAa;OACpC,MAAM,oBAAoB,iBAAiB,WAAW;AAEtD,WAAI,kBACF,OAAM;;;aAILC,OAAgB;AACvB,YAAO,SAAS,0CAA0C,OAAO;MAC/D,gBAAgB,SAAS;MACzB,YAAY,SAAS;MACtB,CAAC;AACF,WAAM,8BAA8B,0CAA0C,MAAM;;;AAIxF,qBAAkB,aAAa,CAAC,yBAAyB,OAAO;AAChE,qBAAkB,aAAa,CAAC,2BAA2B,IAAI,iBAAiB;AAEhF,UAAO,SACL,kBAAkB,aAAa,CAAC,cAChC,kBAAkB,aAAa,CAAC,yBACjC;;;;4BAGyB,OAAO,YAAuD;AACxF,OAAI;AACF,sBAAkB,aAAa,CAAC,2BAA2B,OAAO;AAClE,sBAAkB,aAAa,CAAC,6BAA6B,IAAI,iBAAiB;AAelF,YAbiB,MAAM,kBAAkB,aAAa,CAAC,aAAa,sBAClE,EACE,oBAAoB,uCAAuC,QAAQ,EACpE,EACD,EACE,QAAQ,kBAAkB,aAAa,CAAC,2BAA2B,QACpE,CACF,EAGE,KAAI,SAAQ,mBAAmB,KAAK,CAAC,CACrC,QAAQ,eAAyC,cAAc,KAAK;YAGhEA,OAAgB;AACvB,WAAO,QAAQ,6BAA6B,OAAO;KACjD,gBAAgB,SAAS;KACzB,YAAY,SAAS;KACtB,CAAC;AAEF,UAAM,8BAA8B,6BAA6B,MAAM;AACvE,WAAO,EAAE;;;;;sBAaS,OACpB,OACA,QACA,WAMI;GACJ,IAAIC,OAAwC;IAC1C,WAAW,EAAE;IACb,aAAa,EAAE;IACf,aAAa,EAAE;IAChB;GACD,MAAM,UAAU;IACd,QAAQ;IACR,SAAS;IACT,SAAS;IACV;AACD,OAAI;AACF,WAAO,MAAM,kBAAkB,aAAa,CAAC,WAAW,qBAAqB,QAAQ;YAC9ED,OAAgB;AACvB,UAAM,8BAA8B,gCAAgC,MAAM;;GAG5E,MAAME,YAA0B,MAAM,WAAW,KAAI,SACnD,KACG,KAAI,aAAY,iBAAiB,SAAS,CAAC,CAC3C,QAAQ,aAAmC,YAAY,KAAK,CAChE;GAED,MAAMC,cAA4B,MAAM,YACrC,KAAI,eAAc,mBAAmB,WAAW,CAAC,CACjD,QAAQ,eAAyC,cAAc,KAAK;GAEvE,MAAMC,aAA0B,MAAM,YACnC,KAAI,UAAS,kBAAkB,MAAM,CAAC,CACtC,QAAQ,UAA8B,SAAS,KAAK;GAGvD,MAAM,iCAAiC,WACpC,QAAO,UAAS,MAAM,aAAa,kBAAkB,cAAc,CACnE,KAAI,UAAS,MAAM,WAAW,eAAe;GAEhD,MAAMC,oBAAiC,UACpC,KAAI,SACH,KACG,QACC,aACE,EACE,SAAS,aAAa,iBAAiB,QACvC,+BAA+B,SAAS,SAAS,GAAG,EAEzD,CACA,KAAI,aAAY,oBAAoB,SAAS,CAAC,CAC9C,QAAQ,YAAgC,WAAW,KAAK,CAC5D,CACA,QAAO,SAAQ,KAAK,SAAS,EAAE;GAElC,MAAMC,gBACJ,MAAM,QAAQ,IACZ,WAAW,IAAI,OAAM,UAAS;AAC5B,QAAI,CAAC,kBAAkB,YAAY,kBAAkB,OAAO,CAAC,SAAS,MAAM,SAAS,CACnF,QAAO,CAAC,sBAAsB,MAAM,CAAC;AAGvC,QAAI,MAAM,aAAa,kBAAkB,kBACvC,QAAO,CAAC,2BAA2B,OAAO,YAAY,CAAC;AAGzD,QAAI,MAAM,aAAa,kBAAkB,WAAW;KAKlD,MAAM,iBAAiB,UACpB,MAAM,CACN,MACC,aACE,SAAS,aAAa,iBAAiB,WACvC,SAAS,WAAW,OAAO,MAAM,WAAW,UAC/C;KACH,IAAI,eACF,gBAAgB,aAAa,iBAAiB,UAC1C,eAAe,WAAW,QAC1B;AACN,SAAI,CAAC,aACH,KAAI;AAIF,sBAHgB,MAAM,kBAAkB,uBACtC,MAAM,WAAW,UAClB,GACuB;aAClB;AACN,qBAAe;;AAGnB,YAAO,CAAC,0BAA0B,OAAO,aAAa,CAAC;;AAGzD,QAAI,MAAM,aAAa,kBAAkB,eAAe;KACtD,MAAM,eAAe,UAClB,MAAM,CACN,MACC,aACE,SAAS,OAAO,MAAM,WAAW,kBACjC,MAAM,WAAW,aAAa,SAAS,WAC1C;AAEH,SAAI,gBAAgB,aAAa,aAAa,iBAAiB,KAC7D,QAAO,CAAC,8BAA8B,OAAO,aAAa,WAAW,CAAC;;AAI1E,WAAO,EAAE;KACT,CACH,EACD,QAAQ,YAAkC,QAAQ,SAAS,EAAE;AAO/D,UAAO;IAAE;IAAW;IAAY;IAAa,UAJtB,CAAC,GAAG,mBAAmB,GAAG,aAAa,CAAC,MAC5D,GAAG,MAAM,IAAI,KAAK,EAAE,GAAG,UAAU,CAAC,SAAS,GAAG,IAAI,KAAK,EAAE,GAAG,UAAU,CAAC,SAAS,CAClF;IAEsE;;;;qBAGpD,OAAO,YAAoD;GAC9E,MAAM,aAAa,kCAAkC,QAAQ;AAI7D,UAAO,sCAAsC,YAH5B,MAAM,kBAAkB,aAAa,CAAC,aAAa,iBAAiB,EACnF,mBAAmB,YACpB,CAAC,CACgE;;;;0BAW1C,OAAO,eAA0D;AACzF,OAAI,WAAW,WAAW,EACxB,QAAO;IAAE,UAAU,EAAE;IAAE,mBAAmB;IAAG;AAG/C,OAAI;IACF,MAAM,YAAY,cAAc;IAChC,MAAM,eAAe,UAAU,IAAI,iBAAiB;IACpD,MAAM,QAAQ,UAAU,IAAI,UAAU;IACtC,MAAM,SAAS,UAAU,IAAI,WAAW;IACxC,MAAM,SAAS,UAAU,IAAI,WAAW;IACxC,MAAM,SAAS,UAAU,IAAI,kBAAkB;IAC/C,MAAM,MAAM,UAAU,IAAI,QAAQ;IAElC,MAAMR,UAAmB;KACvB,SAAS,UAAU;KACnB,QAAQ,SAAS;KACjB,gBAAgB,gBAAgB;KAChC,SAAS,UAAU;KACnB,QAAQ,UAAU,kBAAkB;KACpC,KAAM,OAA0B,eAAe;KAChD;AASD,WAAO,iDAPU,MAAM,kBAAkB,aAAa,CAAC,YAAY,uBAAuB,EACxF,yBAAyB;KACvB;KACA,aAAa;KACd,EACF,CAAC,CAE+D;YAC1D,KAAK;AACZ,UAAM,8BAA8B,+BAA+B,IAAI;AACvE,WAAO;KAAE,UAAU,EAAE;KAAE,mBAAmB;KAAG;;;;;6CAQZ,IAAI,KAAkD;;;iCAE1D,cAA2D;GAC1F,MAAM,SAAS,kBAAkB,oBAAoB,IAAI,UAAU;AACnE,OAAI,OACF,QAAO;GAET,MAAM,UAAU,kBAAkB,+BAA+B,UAAU,CAAC,OAAM,QAAO;AACvF,sBAAkB,oBAAoB,OAAO,UAAU;AACvD,UAAM;KACN;AACF,qBAAkB,oBAAoB,IAAI,WAAW,QAAQ;AAC7D,UAAO;;;;wCAYuC,OAC9C,cACwC;GACxC,MAAM,YAAY,cAAc;GAChC,MAAM,UAAU,UAAU,IAAI,YAAY;GAC1C,MAAM,SAAS,UAAU,IAAI,mBAAmB;AAEhD,OAAI;IACF,MAAM,WAAW,MAAM,MAAM,GAAG,QAAQ,cAAc;KACpD,QAAQ;KACR,SAAS;MACP,gBAAgB;MAChB,eAAe,UAAU;MAC1B;KACD,MAAM,KAAK,UAAU;MACnB,OAAO,wBAAwB;MAC/B,WAAW,EAAE,WAAW;MACzB,CAAC;KACH,CAAC;AAEF,QAAI,CAAC,SAAS,GACZ,OAAM,IAAI,cAAc,UAAU,2BAA2B,SAAS,aAAa;IAGrF,MAAM,SAAS,MAAM,SAAS,MAAM;AACpC,QAAI,OAAO,OACT,OAAM,IAAI,MAAM,mBAAmB,KAAK,UAAU,OAAO,OAAO,GAAG;AAGrE,WAAO,OAAO,MAAM,IAAI,kBAAkB;YACnC,KAAK;AACZ,UAAM,8BAA8B,sCAAsC,IAAI;AAC9E;;;;;0BASsB,OAAO,YAA4D;AAC3F,OAAI;IAOF,MAAM,mBAAmB,OALvB,MAAM,kBAAkB,aAAa,CAAC,aAAa,wBAAwB,EACzE,uBAAuB,sCAAsC,QAAQ,EACtE,CAAC,EAGuC,IAAI,MAAM;IACrD,MAAM,mBAAmB,KAAK,MAAM,iBAAiB;AAErD,WAAO;KACL,GAAG;KACH,iBAAiB,iBAAiB;KAClC,eAAe,iBAAiB,iBAAiB,EAAE;KACpD;YACM,KAAK;AACZ,WAAO,SAAS,mDAAmD,EACjE,KACD,CAAC;AACF,WAAO;KACL,WAAW;KACX,OAAO;KACP,UAAU;KACV,aAAa,EAAE;KACf,iBAAiB;KACjB,cAAc;KACd,eAAe,EAAE;KAClB;;;;;iDAKH,WACyC;AACzC,OAAI,WAAW,OAAW,QAAO;AACjC,WAAQ,QAAR;IACE,KAAK,kBAAkB,KACrB,QAAO,yBAAyB;IAClC,KAAK,kBAAkB,WACrB,QAAO,yBAAyB;IAClC,KAAK,kBAAkB,IACrB,QAAO,yBAAyB;IAClC,KAAK,kBAAkB,KACrB,QAAO,yBAAyB;IAClC,KAAK,kBAAkB,KACrB,QAAO,yBAAyB;IAClC,QAGE,QAD+B;;;;;sBAMf,OAAO,YAAoD;AAC/E,OAAI;IACF,MAAM,YAAY,cAAc;IAChC,MAAM,eAAe,UAAU,IAAI,iBAAiB;IACpD,MAAM,gBAAgB,UAAU,IAAI,kBAAkB;IACtD,MAAM,qBAAqB,UAAU,IAAI,uBAAuB;IAChE,MAAMS,UAAiC;KACrC,WAAW;KACX;KACA,QAAQ,KAAK,uCAAuC,cAAc;KAClE,qBAAqB,OAAO,OAAO,kBAAkB;KACrD,uBAAuB,OAAO,QAC5B,oBAAoB,oBAAoB,iBAAiB,IAAI,EAAE,CAChE,CACE,QAAQ,GAAG,eAAe,UAAU,CACpC,KAAK,CAAC,qBAAqB,gBAAgB;KAC/C;AAGD,WAAO,yBAFU,MAAM,kBAAkB,aAAa,CAAC,WAAW,eAAe,QAAQ,CAEhD;YAClC,KAAK;AACZ,WAAO,SAAS,4BAA4B,KAAK,EAAE,KAAK,CAAC;AACzD;;;;;qCAIiC,OACnC,cACA,OACA,4BACG;AACH,UAAO,QACL,yCAAyC,aAAa,SAAS,MAAM,6BAA6B,0BACnG;AACD,OAAI;AACF,UAAM,kBAAkB,aAAa,CAAC,mBAAmB,6CACvD,EACE,oCAAoC;KAClC,gBAAgB;KAChB;KACA,2BAA2B;KAC5B,EACF,CACF;YACM,KAAK;AACZ,WAAO,SAAS,6CAA6C,EAAE,KAAK,CAAC;;;;;qCAIpC,kBAAkB,aAAa,CAAC;;;AAGvE,2BAAe"}

package/dist/application/models/api/userEvent.d.cts

@@ -2,7 +2,14 @@ import { CamelCasedPropertiesDeep } from "../utilityTypes/camelCasedPropertiesDe
 import { FormType, PDPAttributes, PLPAttributes, PageVisitCategory, QueryTypedAttributes, SearchAttributes, SuggestionClickedAttributes, UserEvent, UserEventCategory } from "@spiffy-ai/commerce-api-client";
 
 //#region src/application/models/api/userEvent.d.ts
-interface PDPAttributes$1 extends CamelCasedPropertiesDeep<PDPAttributes> {}
+interface PDPAttributes$1 extends CamelCasedPropertiesDeep<PDPAttributes> {
+  /**
+   * 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;
+}
 interface PLPAttributes$1 extends CamelCasedPropertiesDeep<PLPAttributes> {}
 interface SearchAttributes$1 extends CamelCasedPropertiesDeep<SearchAttributes> {}
 interface QueryTypedAttributes$1 extends CamelCasedPropertiesDeep<QueryTypedAttributes> {
@@ -58,4 +65,4 @@ interface FormSubmitted {
 type UserEvent$1 = CamelCasedPropertiesDeep<Pick<UserEvent, 'event_id' | 'category' | 'created_at'>> & (SuggestionsClickedUserEvent | AppLoadedUserEvent | PDPUserEvent | QueryTypedUserEvent | SearchUserEvent | AppUnloadedEvent | PLPUserEvent | PageVisitEvent | FormSubmitted);
 //#endregion
 export { AppLoadedUserEvent, AppUnloadedEvent, FormSubmitted, FormSubmittedAttributes$1 as FormSubmittedAttributes, PDPAttributes$1 as PDPAttributes, PDPUserEvent, PLPAttributes$1 as PLPAttributes, PLPUserEvent, PageVisitAttributes, PageVisitEvent, QueryTypedAttributes$1 as QueryTypedAttributes, QueryTypedUserEvent, SearchAttributes$1 as SearchAttributes, SearchUserEvent, SuggestionClickedAttributes$1 as SuggestionClickedAttributes, SuggestionsClickedUserEvent, UserEvent$1 as UserEvent, UserEventAttributes };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/models/api/userEvent.d.ts

@@ -2,7 +2,14 @@ import { CamelCasedPropertiesDeep } from "../utilityTypes/camelCasedPropertiesDe
 import { FormType, PDPAttributes, PLPAttributes, PageVisitCategory, QueryTypedAttributes, SearchAttributes, SuggestionClickedAttributes, UserEvent, UserEventCategory } from "@spiffy-ai/commerce-api-client";
 
 //#region src/application/models/api/userEvent.d.ts
-interface PDPAttributes$1 extends CamelCasedPropertiesDeep<PDPAttributes> {}
+interface PDPAttributes$1 extends CamelCasedPropertiesDeep<PDPAttributes> {
+  /**
+   * 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;
+}
 interface PLPAttributes$1 extends CamelCasedPropertiesDeep<PLPAttributes> {}
 interface SearchAttributes$1 extends CamelCasedPropertiesDeep<SearchAttributes> {}
 interface QueryTypedAttributes$1 extends CamelCasedPropertiesDeep<QueryTypedAttributes> {
@@ -58,4 +65,4 @@ interface FormSubmitted {
 type UserEvent$1 = CamelCasedPropertiesDeep<Pick<UserEvent, 'event_id' | 'category' | 'created_at'>> & (SuggestionsClickedUserEvent | AppLoadedUserEvent | PDPUserEvent | QueryTypedUserEvent | SearchUserEvent | AppUnloadedEvent | PLPUserEvent | PageVisitEvent | FormSubmitted);
 //#endregion
 export { AppLoadedUserEvent, AppUnloadedEvent, FormSubmitted, FormSubmittedAttributes$1 as FormSubmittedAttributes, PDPAttributes$1 as PDPAttributes, PDPUserEvent, PLPAttributes$1 as PLPAttributes, PLPUserEvent, PageVisitAttributes, PageVisitEvent, QueryTypedAttributes$1 as QueryTypedAttributes, QueryTypedUserEvent, SearchAttributes$1 as SearchAttributes, SearchUserEvent, SuggestionClickedAttributes$1 as SuggestionClickedAttributes, SuggestionsClickedUserEvent, UserEvent$1 as UserEvent, UserEventAttributes };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/models/featureGates.cjs

@@ -27,6 +27,7 @@ let FeatureGates = /* @__PURE__ */ function(FeatureGates$1) {
 	FeatureGates$1["IsAiSuggestionsVariantEnabled"] = "is_ai_suggestions_variant_enabled";
 	FeatureGates$1["IsAiSuggestionsVariantAEnabled"] = "is_ai_suggestions_variant_a_enabled";
 	FeatureGates$1["IsAiSuggestionsVariantBEnabled"] = "is_ai_suggestions_variant_b_enabled";
+	FeatureGates$1["IsAiSuggestionsStorefrontEnabled"] = "is_ai_suggestions_storefront_enabled";
 	FeatureGates$1["IsVoiceInputEnabled"] = "is_voice_input_enabled";
 	FeatureGates$1["UseUnifiedConfig"] = "use_unified_config";
 	return FeatureGates$1;
@@ -34,4 +35,4 @@ let FeatureGates = /* @__PURE__ */ function(FeatureGates$1) {
 
 //#endregion
 exports.FeatureGates = FeatureGates;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVhdHVyZUdhdGVzLmNqcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBwbGljYXRpb24vbW9kZWxzL2ZlYXR1cmVHYXRlcy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBGZWF0dXJlR2F0ZXMge1xuICBJc0NsaWVudFNlc3Npb25FbmFibGVkID0gJ2lzX2NsaWVudF9zZXNzaW9uX2VuYWJsZWQnLFxuICBJc1NhbGVzQWdlbnRFbmFibGVkID0gJ2lzX3NhbGVzX2FnZW50X2VuYWJsZWQnLFxuICBJc05ld0ZlYXR1cmVFbmFibGVkID0gJ2lzX25ld19mZWF0dXJlX2VuYWJsZWQnLFxuICAvLyBJc0ZpbmVUdW5lZE1vZGVsOGIgaXMgZGVmaW5lZCBoZXJlIGZvciB0aGUgc29sZSBwdXJwb3NlIG9mIGNvcnJlbGF0aW5nIGV2ZW50cyB0byBhIHNwZWNpZmljIG1vZGVsIGluIEFtcGxpdHVkZVxuICBJc0ZpbmVUdW5lZE1vZGVsOGIgPSAnaXNfZmluZV90dW5lZF9tb2RlbF84YicsXG4gIElzSW1hZ2VCYW5uZXJFbmFibGVkID0gJ2lzX2ltYWdlX2Jhbm5lcl9lbmFibGVkJyxcbiAgSXNPcmRlckxvb2t1cEVuYWJsZWQgPSAnaXNfb3JkZXJfbG9va3VwX2VuYWJsZWQnLFxuICBJc1N1bW1hcml6ZVJldmlld3NFbmFibGVkID0gJ2lzX3N1bW1hcml6ZV9yZXZpZXdzX2VuYWJsZWQnLFxuICBJc0dsb2JhbFNlYXJjaEVuYWJsZWQgPSAnaXNfZ2xvYmFsX3NlYXJjaF9lbmFibGVkJyxcbiAgSXNJbWFnZVByb21wdEVuYWJsZWQgPSAnaXNfaW1hZ2VfcHJvbXB0X2VuYWJsZWQnLFxuICBJc1dhdGVybWFya0VuYWJsZWQgPSAnaXNfd2F0ZXJtYXJrX2VuYWJsZWQnLFxuICBJc0luZmVyZW5jZVJlZ2lvbjAgPSAnaXNfaW5mZXJlbmNlX3JlZ2lvbl8wJyxcbiAgSXNDaGF0VmFyaWFudEVuYWJsZWQgPSAnaXNfY2hhdF92YXJpYW50X2VuYWJsZWQnLFxuICBJc0NoYXRWYXJpYW50QUVuYWJsZWQgPSAnaXNfY2hhdF92YXJpYW50X2FfZW5hYmxlZCcsXG4gIElzQ2hhdFZhcmlhbnRCRW5hYmxlZCA9ICdpc19jaGF0X3ZhcmlhbnRfYl9lbmFibGVkJyxcbiAgSXNVc2VyUXVlcnlBbHdheXNFbmFibGVkID0gJ2lzX3VzZXJfcXVlcnlfYWx3YXlzX2VuYWJsZWQnLFxuICBJc1NlYXJjaEF1dG9jb21wbGV0ZUVuYWJsZWQgPSAnaXNfc2VhcmNoX2F1dG9jb21wbGV0ZV9lbmFibGVkJyxcbiAgSXNFbXB0eURpdlBMUEVuYWJsZWQgPSAnaXNfZW1wdHlfZGl2X3BscF9lbmFibGVkJyxcbiAgSXNSZWNvbW1lbmRlZFByb2R1Y3RzRW5hYmxlZCA9ICdpc19yZWNvbW1lbmRlZF9wcm9kdWN0c19lbmFibGVkJyxcbiAgSXNDaGF0U2Nyb2xsUGF1c2VkID0gJ2lzX2NoYXRfc2Nyb2xsX3BhdXNlZCcsXG4gIElzU2Vzc2lvbkluU2VhcmNoUmVyYW5rZXJUZXN0ID0gJ2lzX3Nlc3Npb25faW5fc2VhcmNoX3JlcmFua2VyX3Rlc3QnLFxuICBJc1JlZmVycmVyQmFzZWRQcm9tcHRFbmFibGVkID0gJ2lzX3JlZmVycmVyX2Jhc2VkX3Byb21wdF9lbmFibGVkJyxcbiAgLy8gTW9kZWwgZXhwZXJpbWVudCBmbGFnc1xuICBJc0luTW9kZWxFeHBlcmltZW50ID0gJ2lzX2luX21vZGVsX2V4cGVyaW1lbnQnLFxuICBJc01vZGVsRXhwZXJpbWVudFRyZWF0bWVudCA9ICdpc19tb2RlbF9leHBlcmltZW50X3RyZWF0bWVudCcsXG4gIElzQWlTdWdnZXN0aW9uc1ZhcmlhbnRFbmFibGVkID0gJ2lzX2FpX3N1Z2dlc3Rpb25zX3ZhcmlhbnRfZW5hYmxlZCcsXG4gIElzQWlTdWdnZXN0aW9uc1ZhcmlhbnRBRW5hYmxlZCA9ICdpc19haV9zdWdnZXN0aW9uc192YXJpYW50X2FfZW5hYmxlZCcsXG4gIElzQWlTdWdnZXN0aW9uc1ZhcmlhbnRCRW5hYmxlZCA9ICdpc19haV9zdWdnZXN0aW9uc192YXJpYW50X2JfZW5hYmxlZCcsXG4gIC8vIFNlcnZlcyB0aGUgYWdlbnRpYyBzdG9yZWZyb250IChGdWxsUGFnZVNhbGVzQWdlbnRWMyB3ZWxjb21lIG92ZXJsYXkpXG4gIC8vIGluZGVwZW5kZW50bHkgb2YgdGhlIHBkcC9wbHAgdmFyaWFudF9iIGV4cGVyaW1lbnQuIFRoZSBiYWNrZW5kIHNlcnZlcyB0aGVcbiAgLy8gc3RvcmVmcm9udCB1bmRlciB0aGlzIGdhdGUgYW5kIGZhbGxzIGJhY2sgdG8gdmFyaWFudF9iIG9ubHkgdW50aWwgdGhpc1xuICAvLyBzaGlwcywgc28gYW4gb3JnIGNhbiBydW4gdGhlIHN0b3JlZnJvbnQgd2l0aG91dCBvcHRpbmcgcGRwL3BscCBpbnRvIHZhcmlhbnRfYi5cbiAgSXNBaVN1Z2dlc3Rpb25zU3RvcmVmcm9udEVuYWJsZWQgPSAnaXNfYWlfc3VnZ2VzdGlvbnNfc3RvcmVmcm9udF9lbmFibGVkJyxcbiAgSXNWb2ljZUlucHV0RW5hYmxlZCA9ICdpc192b2ljZV9pbnB1dF9lbmFibGVkJyxcbiAgLy8gU3RhdHNpZyBleHBlcmltZW50cyAvIHVuaWZpZWQgZ2V0V2lkZ2V0Q29uZmlnIGVuZHBvaW50IG1pZ3JhdGlvbi4gV2hlblxuICAvLyB0cnVlLCBFbnZpdmVDb25maWdTZXJ2aWNlIGNhbGxzIGdldFdpZGdldENvbmZpZyAoZXhwZXJpbWVudC1hd2FyZSlcbiAgLy8gaW5zdGVhZCBvZiB0aGUgbGVnYWN5IGdldFByb2R1Y3RzQ29uZmlnQnlWZXJzaW9uIC8gZ2V0Q29sb3JzQW5kRnJvbnRlbmRcbiAgLy8gcGF0aC5cbiAgVXNlVW5pZmllZENvbmZpZyA9ICd1c2VfdW5pZmllZF9jb25maWcnLFxufVxuIl0sIm1hcHBpbmdzIjoiOztBQUFBLElBQVksd0RBQUw7QUFDTDtBQUNBO0FBQ0E7QUFFQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFFQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBS0E7QUFDQTtBQUtBIn0=

package/dist/application/models/featureGates.d.cts

@@ -26,9 +26,10 @@ declare enum FeatureGates {
   IsAiSuggestionsVariantEnabled = "is_ai_suggestions_variant_enabled",
   IsAiSuggestionsVariantAEnabled = "is_ai_suggestions_variant_a_enabled",
   IsAiSuggestionsVariantBEnabled = "is_ai_suggestions_variant_b_enabled",
+  IsAiSuggestionsStorefrontEnabled = "is_ai_suggestions_storefront_enabled",
   IsVoiceInputEnabled = "is_voice_input_enabled",
   UseUnifiedConfig = "use_unified_config",
 }
 //#endregion
 export { FeatureGates };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/models/featureGates.d.ts

@@ -26,9 +26,10 @@ declare enum FeatureGates {
   IsAiSuggestionsVariantEnabled = "is_ai_suggestions_variant_enabled",
   IsAiSuggestionsVariantAEnabled = "is_ai_suggestions_variant_a_enabled",
   IsAiSuggestionsVariantBEnabled = "is_ai_suggestions_variant_b_enabled",
+  IsAiSuggestionsStorefrontEnabled = "is_ai_suggestions_storefront_enabled",
   IsVoiceInputEnabled = "is_voice_input_enabled",
   UseUnifiedConfig = "use_unified_config",
 }
 //#endregion
 export { FeatureGates };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/models/featureGates.js

@@ -26,6 +26,7 @@ let FeatureGates = /* @__PURE__ */ function(FeatureGates$1) {
 	FeatureGates$1["IsAiSuggestionsVariantEnabled"] = "is_ai_suggestions_variant_enabled";
 	FeatureGates$1["IsAiSuggestionsVariantAEnabled"] = "is_ai_suggestions_variant_a_enabled";
 	FeatureGates$1["IsAiSuggestionsVariantBEnabled"] = "is_ai_suggestions_variant_b_enabled";
+	FeatureGates$1["IsAiSuggestionsStorefrontEnabled"] = "is_ai_suggestions_storefront_enabled";
 	FeatureGates$1["IsVoiceInputEnabled"] = "is_voice_input_enabled";
 	FeatureGates$1["UseUnifiedConfig"] = "use_unified_config";
 	return FeatureGates$1;
@@ -33,4 +34,4 @@ let FeatureGates = /* @__PURE__ */ function(FeatureGates$1) {
 
 //#endregion
 export { FeatureGates };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/models/graphql/queries/getProductOptionsQuery.cjs

@@ -0,0 +1,33 @@
+
+//#region src/application/models/graphql/queries/getProductOptionsQuery.ts
+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
+          }
+        }
+      }
+    }
+  }
+`;
+
+//#endregion
+exports.getProductOptionsQuery = getProductOptionsQuery;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/models/graphql/queries/getProductOptionsQuery.d.cts

@@ -0,0 +1,28 @@
+//#region src/application/models/graphql/queries/getProductOptionsQuery.d.ts
+interface ProductVariantOption {
+  name: string;
+  value: string;
+}
+interface ProductVariant {
+  variantId: string;
+  available: boolean;
+  originalPrice?: number;
+  salePrice?: number;
+  imageUrl?: string;
+  url?: string;
+  options: ProductVariantOption[];
+}
+interface ProductOption {
+  name: string;
+  values: string[];
+}
+interface ProductDetails {
+  productId: string;
+  virtualParentId?: string;
+  title: string;
+  options: ProductOption[];
+  variants: ProductVariant[];
+}
+//#endregion
+export { ProductDetails, ProductOption, ProductVariant, ProductVariantOption };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0UHJvZHVjdE9wdGlvbnNRdWVyeS5kLmN0cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBwbGljYXRpb24vbW9kZWxzL2dyYXBocWwvcXVlcmllcy9nZXRQcm9kdWN0T3B0aW9uc1F1ZXJ5LmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlY2xhcmUgY29uc3QgZ2V0UHJvZHVjdE9wdGlvbnNRdWVyeTogKCkgPT4gc3RyaW5nO1xuZXhwb3J0IGludGVyZmFjZSBQcm9kdWN0VmFyaWFudE9wdGlvbiB7XG4gICAgbmFtZTogc3RyaW5nO1xuICAgIHZhbHVlOiBzdHJpbmc7XG59XG5leHBvcnQgaW50ZXJmYWNlIFByb2R1Y3RWYXJpYW50IHtcbiAgICB2YXJpYW50SWQ6IHN0cmluZztcbiAgICBhdmFpbGFibGU6IGJvb2xlYW47XG4gICAgb3JpZ2luYWxQcmljZT86IG51bWJlcjtcbiAgICBzYWxlUHJpY2U/OiBudW1iZXI7XG4gICAgaW1hZ2VVcmw/OiBzdHJpbmc7XG4gICAgdXJsPzogc3RyaW5nO1xuICAgIG9wdGlvbnM6IFByb2R1Y3RWYXJpYW50T3B0aW9uW107XG59XG5leHBvcnQgaW50ZXJmYWNlIFByb2R1Y3RPcHRpb24ge1xuICAgIG5hbWU6IHN0cmluZztcbiAgICB2YWx1ZXM6IHN0cmluZ1tdO1xufVxuZXhwb3J0IGludGVyZmFjZSBQcm9kdWN0RGV0YWlscyB7XG4gICAgcHJvZHVjdElkOiBzdHJpbmc7XG4gICAgdmlydHVhbFBhcmVudElkPzogc3RyaW5nO1xuICAgIHRpdGxlOiBzdHJpbmc7XG4gICAgb3B0aW9uczogUHJvZHVjdE9wdGlvbltdO1xuICAgIHZhcmlhbnRzOiBQcm9kdWN0VmFyaWFudFtdO1xufVxuIl0sIm1hcHBpbmdzIjoiO0FBQ0EsSUFBVyx1QkFBdUIsQ0FBQyxJQUFHO0FBQ3RDLElBQVcsaUJBQUssQ0FBQSxXQUFBLHFCQUFBO0FBQ2hCLElBQVcsZ0JBQU0sQ0FBQSxJQUFBO0FBQ2pCLElBQUEsaUJBQUE7Q0FBQTtPQUFBO09BQUE7Q0FBQSJ9