@envive-ai/react-hooks 0.2.10-arthur-3 → 0.2.11

package/README.md

@@ -2,36 +2,3 @@
 # envive-react-hooks
 
 State and data providers for intergrating with Envive.
-
-## Local Development
-
-In order to develop packages in tandem, we use npm link. Due to a limitation around react hooks and link, you will receive an error unless you follow these steps.
-
-The following example assumes a file system where all your repos share a top level directory. If you organize your code differently, you will need to change the paths accordingly.
-
-```md
-my-code/
-├── envive-app-blocks/
-├── envive-react-hooks/
-├── envive-react-toolkit/
-│   ├──packages/
-│       ├── components/
-│       ├── icons/
-│       ├── storybook/
-```
-
-For the hooks library:
-
-1. Starting from /envive-app-blocks `npm i`
-2. `cd ../envive-react-hooks`
-3. `npm link ../envive-app-blocks/node_modules/react`
-4. `npm run build:watch`
-5. `cd ../envive-app-blocks`
-6. `npm link ../envive-react-hooks`
-7. `npm run dev:local`
-
-### Troubleshooting link
-
-* If you see an error such as this, something may have not been linked correctly.
-`Hooks can only be called inside the body of a function component.`, there is likely nothing wrong with your code.
-* If you run `npm i` in either package, you will get unlinked, if you are doing a lot of testing around your dependencies, you can use `npm link --save`. This will add a file reference to your package.json that you will need to correct before merge.

package/dist/{chunk-CUT6urMc.cjs → _virtual/rolldown_runtime.cjs}

@@ -6,12 +6,16 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
 	}
 	return to;
 };
@@ -22,9 +26,4 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});
+exports.__toESM = __toESM;

package/dist/application/commerce-api.cjs

@@ -0,0 +1,319 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_productExperiment = require('./models/productExperiment.cjs');
+const require_logger = require('./logging/logger.cjs');
+const require_validateOrgConfigResults = require('./models/validators/validateOrgConfigResults.cjs');
+const require_validateResponse = require('./models/validators/validateResponse.cjs');
+const require_validateSuggestion = require('./models/validators/validateSuggestion.cjs');
+const require_validateUserEvent = require('./models/validators/validateUserEvent.cjs');
+const require_enviveConfig = require('../atoms/envive/enviveConfig.cjs');
+const require_atomStore = require('../atoms/atomStore/atomStore.cjs');
+const require_atoms_app_index = require('../atoms/app/index.cjs');
+const require_messageFromFormSubmittedEvent = require('./utils/messageFromFormSubmittedEvent.cjs');
+const require_messageFromQueryEvent = require('./utils/messageFromQueryEvent.cjs');
+const require_messageFromResponse = require('./utils/messageFromResponse.cjs');
+const require_messageFromSuggestionEvent = require('./utils/messageFromSuggestionEvent.cjs');
+const require_nextMessageRequestToApiRequest = require('./utils/nextMessageRequestToApiRequest.cjs');
+const require_supportedEventRequestToApiRequest = require('./utils/supportedEventRequestToApiRequest.cjs');
+require('./utils/index.cjs');
+const require_graphqlConfig = require('../atoms/org/graphqlConfig.cjs');
+const require_sessionExceptions = require('../types/exceptions/sessionExceptions.cjs');
+const require_unsupportedProductExceptions = require('../types/exceptions/unsupportedProductExceptions.cjs');
+let __spiffy_ai_commerce_api_client = require("@spiffy-ai/commerce-api-client");
+
+//#region src/application/commerce-api.ts
+async function errorResponseBody(error) {
+	try {
+		return await error.response.json();
+	} catch {
+		return {};
+	}
+}
+async function throwSessionRestartRequiredIf(errorMsg, error) {
+	if (!(error instanceof __spiffy_ai_commerce_api_client.ResponseError)) {
+		require_logger.default.logInfo(errorMsg, error);
+		throw error;
+	}
+	const errorResponse = await errorResponseBody(error);
+	if (errorResponse?.message?.toLowerCase() === "unsupported product" || errorResponse?.app_code?.toUpperCase() === "PRODUCT_NOT_FOUND") throw new require_unsupportedProductExceptions.UnsupportedProductException();
+	else if (errorResponse?.app_code?.toUpperCase() === "RESTART_SESSION" || errorResponse?.sub_code?.toUpperCase() === "NOT_FOUND") {
+		require_logger.default.logInfo("Session does not exist. Re-start session", error, error.response, errorResponse);
+		throw new require_sessionExceptions.SessionRestartRequired();
+	}
+	require_logger.default.logInfo(errorMsg, error);
+	throw error;
+}
+var CommerceApiClient = class CommerceApiClient {
+	static {
+		this.getInstance = () => {
+			if (!CommerceApiClient.instance) CommerceApiClient.instance = new CommerceApiClient();
+			return CommerceApiClient.instance;
+		};
+	}
+	constructor(basePath) {
+		this.suggestionsAbortController = new AbortController();
+		this.responsesAbortController = new AbortController();
+		const baseUrl = require_atomStore.getAtomStore().get(require_enviveConfig.baseUrlAtom);
+		const config = new __spiffy_ai_commerce_api_client.Configuration({
+			basePath: basePath || baseUrl,
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json"
+			}
+		});
+		this.defaultApi = new __spiffy_ai_commerce_api_client.DefaultApi(config);
+		this.inferenceApi = new __spiffy_ai_commerce_api_client.InferenceApi(config);
+		this.customerServiceApi = new __spiffy_ai_commerce_api_client.CustomerServiceApi(config);
+	}
+	static {
+		this.resolveUrl = async (url) => {
+			const atomStore = require_atomStore.getAtomStore();
+			const orgShortName = atomStore.get(require_enviveConfig.orgShortNameAtom);
+			const orgId = atomStore.get(require_graphqlConfig.orgIdAtom);
+			const userId = atomStore.get(require_atoms_app_index.userIdAtom);
+			const chatId = atomStore.get(require_atoms_app_index.chatIdAtom);
+			const source = atomStore.get(require_enviveConfig.contextSourceAtom);
+			const env = atomStore.get(require_enviveConfig.envAtom);
+			const featureFlagService = atomStore.get(require_graphqlConfig.featureFlagServiceAtom);
+			const urlResolvingRequest = {
+				url,
+				context: {
+					user_id: userId ?? "",
+					org_id: orgId ?? "",
+					org_short_name: orgShortName ?? "",
+					chat_id: chatId ?? "",
+					source: source ?? __spiffy_ai_commerce_api_client.ContextSourceEnum.App,
+					env: env ?? __spiffy_ai_commerce_api_client.ContextEnvEnum.Dev
+				},
+				feature_gates: featureFlagService?.featureFlagService?.getFeatureFlags() || {}
+			};
+			return await (await CommerceApiClient.getInstance().inferenceApi.v1UrlResolvingPostRaw({ UrlResolvingRequest: urlResolvingRequest })).raw.json();
+		};
+	}
+	static {
+		this.reportSession = async (reportRequest) => {
+			await CommerceApiClient.getInstance().defaultApi.v1ChatsReportSessionIdPost({ ReportSessionRequest: reportRequest });
+		};
+	}
+	static {
+		this.getNextResponses = async (payload) => {
+			try {
+				return (await CommerceApiClient.getInstance().inferenceApi.v1NextResponsesPost({ NextMessageRequest: require_nextMessageRequestToApiRequest.messageRequestToCommerceMessageRequest(payload) })).map((resp) => require_validateResponse.validateResponse(resp)).map((resp) => require_messageFromResponse.messageFromResponse(resp)).filter((m) => m != null);
+			} catch (err) {
+				require_logger.default.logInfo("Failed to get next responses", err, {
+					payloadContext: payload?.context,
+					userEvents: payload?.userEvents
+				});
+				await throwSessionRestartRequiredIf("Failed to get next responses", err);
+				return [];
+			}
+		};
+	}
+	static {
+		this.getNextResponseStreaming = (payload) => {
+			async function* generate(inferenceApi, abortController) {
+				try {
+					const response = await inferenceApi.v1NextResponsesPostRaw({ NextMessageRequest: require_nextMessageRequestToApiRequest.messageRequestToCommerceMessageRequest(payload) }, { signal: abortController.signal });
+					if (!response.raw.body) {
+						require_logger.default.logError("[spiffy-ai] No body in the streamed response", void 0, { response: response.raw });
+						return;
+					}
+					const reader = response.raw.body.getReader();
+					const decoder = new TextDecoder("utf-8");
+					let partial = "";
+					const safeParse = (line) => {
+						try {
+							return JSON.parse(line);
+						} catch (err) {
+							require_logger.default.logError("[spiffy-ai] Error parsing streamed line", err, {
+								line,
+								partial
+							});
+							partial = line;
+							return partial;
+						}
+					};
+					const processChunk = (chunk) => {
+						return `${partial}${chunk}`.split("\n").map((line) => line.replace(/^data: /, "").trim()).filter((line) => line !== "" && line !== "[DONE]").map(safeParse).filter((v) => v);
+					};
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						const parsedLines = processChunk(decoder.decode(value));
+						for (const parsedLine of parsedLines) {
+							const validatedResponse = require_validateResponse.validateResponse(parsedLine);
+							if (validatedResponse) yield validatedResponse;
+						}
+					}
+				} catch (error) {
+					require_logger.default.logError("[spiffy-ai] Failed to get next streaming responses", error, {
+						payloadContext: payload?.context,
+						userEvents: payload?.userEvents
+					});
+					await throwSessionRestartRequiredIf("Failed to get next streaming responses", error);
+				}
+			}
+			CommerceApiClient.getInstance().responsesAbortController.abort();
+			CommerceApiClient.getInstance().responsesAbortController = new AbortController();
+			return generate(CommerceApiClient.getInstance().inferenceApi, CommerceApiClient.getInstance().responsesAbortController);
+		};
+	}
+	static {
+		this.getNextSuggestions = async (payload) => {
+			try {
+				CommerceApiClient.getInstance().suggestionsAbortController.abort();
+				CommerceApiClient.getInstance().suggestionsAbortController = new AbortController();
+				return (await CommerceApiClient.getInstance().inferenceApi.v1NextSuggestionsPost({ NextMessageRequest: require_nextMessageRequestToApiRequest.messageRequestToCommerceMessageRequest(payload) }, { signal: CommerceApiClient.getInstance().suggestionsAbortController.signal })).map((resp) => require_validateSuggestion.validateSuggestion(resp)).filter((suggestion) => suggestion != null);
+			} catch (error) {
+				require_logger.default.logInfo("Failed to get suggestions", error, {
+					payloadContext: payload?.context,
+					userEvents: payload?.userEvents
+				});
+				await throwSessionRestartRequiredIf("Failed to get suggestions", error);
+				return [];
+			}
+		};
+	}
+	static {
+		this.getResponses = async (orgId, chatId, userId) => {
+			let data = {
+				responses: [],
+				suggestions: [],
+				user_events: []
+			};
+			const request = {
+				org_id: orgId,
+				chat_id: chatId,
+				user_id: userId
+			};
+			try {
+				data = await CommerceApiClient.getInstance().defaultApi.v1GetSessionMessages(request);
+			} catch (error) {
+				await throwSessionRestartRequiredIf("Failed to get chat responses", error);
+			}
+			const responses = data?.responses?.map((turn) => turn.map((response) => require_validateResponse.validateResponse(response)).filter((response) => response != null));
+			const suggestions = data?.suggestions.map((suggestion) => require_validateSuggestion.validateSuggestion(suggestion)).filter((suggestion) => suggestion != null);
+			const userEvents = data?.user_events.map((event) => require_validateUserEvent.validateUserEvent(event)).filter((event) => event != null);
+			const formSubmittedUserEventsFormIds = userEvents.filter((event) => event.category === __spiffy_ai_commerce_api_client.UserEventCategory.FormSubmitted).map((event) => event.attributes.formResponseId);
+			const assistantMessages = responses.map((turn) => turn.filter((response) => !(response.category === __spiffy_ai_commerce_api_client.ResponseCategory.Form && formSubmittedUserEventsFormIds.includes(response.id))).map((response) => require_messageFromResponse.messageFromResponse(response)).filter((message) => message != null)).filter((turn) => turn.length > 0);
+			const userMessages = userEvents.map((event) => {
+				if ([__spiffy_ai_commerce_api_client.UserEventCategory.QueryTyped, __spiffy_ai_commerce_api_client.UserEventCategory.Search].includes(event.category)) return [require_messageFromQueryEvent.messageFromQueryEvent(event)];
+				if (event.category === __spiffy_ai_commerce_api_client.UserEventCategory.SuggestionClicked) return [require_messageFromSuggestionEvent.messageFromSuggestionEvent(event, suggestions)];
+				if (event.category === __spiffy_ai_commerce_api_client.UserEventCategory.FormSubmitted) {
+					const formResponse = responses.flat().find((response) => response.id === event.attributes.formResponseId && event.attributes.formType !== __spiffy_ai_commerce_api_client.FormType.Escalation);
+					if (formResponse && formResponse.category === __spiffy_ai_commerce_api_client.ResponseCategory.Form) return [require_messageFromFormSubmittedEvent.messageFromFormSubmittedEvent(event, formResponse.attributes)];
+				}
+				return [];
+			}).filter((message) => message.length > 0);
+			return {
+				responses,
+				userEvents,
+				suggestions,
+				messages: [...assistantMessages, ...userMessages].sort((a, b) => new Date(a[0].createdAt).getTime() - new Date(b[0].createdAt).getTime())
+			};
+		};
+	}
+	static {
+		this.isSupportedEvent = async (payload) => {
+			try {
+				const httpResponseText = await (await CommerceApiClient.getInstance().inferenceApi.v1SupportedEventPostRaw({ SupportedEventRequest: require_supportedEventRequestToApiRequest.coreSupportedEventRequestToApiRequest(payload) })).raw.text();
+				const httpResponseJson = JSON.parse(httpResponseText);
+				return {
+					...httpResponseJson,
+					numberOfReviews: httpResponseJson.num_of_reviews,
+					merchant_tags: httpResponseJson.merchant_tags || []
+				};
+			} catch (err) {
+				require_logger.default.logError("Failed to get response for v1SupportedEventPost", { err });
+				return {
+					supported: false,
+					ready: false,
+					category: void 0,
+					collections: [],
+					numberOfReviews: void 0,
+					top_category: void 0,
+					merchant_tags: []
+				};
+			}
+		};
+	}
+	static {
+		this.identifyUser = async (spiffyUserId, merchantUserId, uaDetails) => {
+			try {
+				await CommerceApiClient.getInstance().defaultApi.v1AnalyticsIdentifyPost({ AnalyticsIdentifyRequest: {
+					user_id: spiffyUserId,
+					os_name: uaDetails.os,
+					os_version: uaDetails.osVersion,
+					platform: uaDetails.os,
+					device_id: uaDetails.deviceModel,
+					device_brand: uaDetails.deviceBrand,
+					device_manufacturer: uaDetails.deviceManufacturer,
+					device_model: uaDetails.deviceModel,
+					user_properties: {
+						cdp_user_id: merchantUserId,
+						browser: uaDetails.browser,
+						browser_version: uaDetails.browserVersion,
+						user_agent: uaDetails.userAgent
+					}
+				} });
+			} catch (err) {
+				require_logger.default.logError("Failed to identify user", err);
+			}
+		};
+	}
+	static {
+		this.mapContextSourceToV1OrgConfigGetSource = (source) => {
+			if (source === void 0) return void 0;
+			switch (source) {
+				case __spiffy_ai_commerce_api_client.ContextSourceEnum.Fork: return __spiffy_ai_commerce_api_client.V1OrgConfigGetSourceEnum.Fork;
+				case __spiffy_ai_commerce_api_client.ContextSourceEnum.Playground: return __spiffy_ai_commerce_api_client.V1OrgConfigGetSourceEnum.Playground;
+				case __spiffy_ai_commerce_api_client.ContextSourceEnum.App: return __spiffy_ai_commerce_api_client.V1OrgConfigGetSourceEnum.App;
+				case __spiffy_ai_commerce_api_client.ContextSourceEnum.Test: return __spiffy_ai_commerce_api_client.V1OrgConfigGetSourceEnum.Test;
+				case __spiffy_ai_commerce_api_client.ContextSourceEnum.Eval: return __spiffy_ai_commerce_api_client.V1OrgConfigGetSourceEnum.Test;
+				default: return source;
+			}
+		};
+	}
+	static {
+		this.getOrgConfig = async (user_id) => {
+			try {
+				const atomStore = require_atomStore.getAtomStore();
+				const reactAppName = atomStore.get(require_enviveConfig.reactAppNameAtom);
+				const contextSource = atomStore.get(require_enviveConfig.contextSourceAtom);
+				const featureFlagService = atomStore.get(require_graphqlConfig.featureFlagServiceAtom);
+				const request = {
+					namespace: reactAppName,
+					user_id,
+					source: this.mapContextSourceToV1OrgConfigGetSource(contextSource),
+					include_experiments: Object.values(require_productExperiment.ProductExperiment),
+					include_feature_gates: Object.entries(featureFlagService?.featureFlagService?.getFeatureFlags() || {}).filter(([, isEnabled]) => isEnabled).map(([featureGateName]) => featureGateName)
+				};
+				return require_validateOrgConfigResults.validateOrgConfigResults(await CommerceApiClient.getInstance().defaultApi.v1OrgConfigGet(request));
+			} catch (err) {
+				require_logger.default.logError(`Failed to get org config`, err, { err });
+				return;
+			}
+		};
+	}
+	static {
+		this.addNoteToLatestConversation = async (spiffyUserId, email, customerServiceProvider) => {
+			require_logger.default.logInfo(`addNoteToLatestConversation - user_id=${spiffyUserId} email=${email} customer_service_provider=${customerServiceProvider}`);
+			try {
+				await CommerceApiClient.getInstance().customerServiceApi.v1CustserviceAddNoteToLatestConversationPost({ AddNoteToLatestConversationRequest: {
+					spiffy_user_id: spiffyUserId,
+					email,
+					customer_service_provider: customerServiceProvider
+				} });
+			} catch (err) {
+				require_logger.default.logError("Failed to add note to latest conversation", { err });
+			}
+		};
+	}
+	static {
+		this.getCustomerServiceApi = () => CommerceApiClient.getInstance().customerServiceApi;
+	}
+};
+var commerce_api_default = CommerceApiClient;
+
+//#endregion
+exports.default = commerce_api_default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"commerce-api.cjs","names":["ResponseError","UnsupportedProductException","SessionRestartRequired","getAtomStore","baseUrlAtom","config: Configuration","Configuration","DefaultApi","InferenceApi","CustomerServiceApi","orgShortNameAtom","orgIdAtom","userIdAtom","chatIdAtom","contextSourceAtom","envAtom","featureFlagServiceAtom","ContextSourceEnum","ContextEnvEnum","messageRequestToCommerceMessageRequest","validateResponse","messageFromResponse","err: unknown","error: unknown","validateSuggestion","data: V1GetSessionMessages200Response","responses: Response[][]","suggestions: Suggestion[]","userEvents: UserEvent[]","validateUserEvent","UserEventCategory","assistantMessages: Message[][]","ResponseCategory","userMessages: Message[][]","messageFromQueryEvent","messageFromSuggestionEvent","FormType","messageFromFormSubmittedEvent","coreSupportedEventRequestToApiRequest","V1OrgConfigGetSourceEnum","reactAppNameAtom","request: V1OrgConfigGetRequest","ProductExperiment","validateOrgConfigResults"],"sources":["../../src/application/commerce-api.ts"],"sourcesContent":["import Logger from 'src/application/logging/logger';\nimport {\n  Configuration,\n  CustomerServiceApi,\n  DefaultApi,\n  InferenceApi,\n  ReportSessionRequest,\n  ResponseError,\n  UserEventCategory,\n  V1GetSessionMessages200Response,\n  V1OrgConfigGetRequest,\n  ContextSourceEnum,\n  V1OrgConfigGetSourceEnum,\n  CustomerServiceProvider,\n  ResponseCategory,\n  FormType,\n} from '@spiffy-ai/commerce-api-client';\nimport { validateSuggestion } from 'src/application/models/validators/validateSuggestion';\nimport { validateUserEvent } from 'src/application/models/validators/validateUserEvent';\nimport {\n  messageFromQueryEvent,\n  messageFromResponse,\n  messageFromSuggestionEvent,\n} from 'src/application/utils';\nimport {\n  Message,\n  NextMessageRequest,\n  Response,\n  Suggestion,\n  SupportedEventRequest,\n  UserEvent,\n} from 'src/application/models';\nimport { messageRequestToCommerceMessageRequest } from 'src/application/utils/nextMessageRequestToApiRequest';\nimport { validateResponse } from 'src/application/models/validators/validateResponse';\nimport { coreSupportedEventRequestToApiRequest } from 'src/application/utils/supportedEventRequestToApiRequest';\nimport { SessionRestartRequired } from 'src/types/exceptions/sessionExceptions';\nimport { UnsupportedProductException } from 'src/types/exceptions/unsupportedProductExceptions';\nimport { ClientDetails } from 'src/application/models/clientDetails';\nimport { getAtomStore } from 'src/atoms/atomStore/atomStore';\nimport { ProductExperiment } from 'src/application/models/productExperiment';\nimport { FeatureGates } from 'src/application/models/featureGates';\nimport { validateOrgConfigResults } from 'src/application/models/validators/validateOrgConfigResults';\nimport { OrgConfig } from 'src/application/models/api/orgConfigResults';\nimport { SupportedEvent } from 'src/atoms/app/variant';\nimport { messageFromFormSubmittedEvent } from 'src/application/utils/messageFromFormSubmittedEvent';\nimport type { Context } from '@spiffy-ai/commerce-api-client/dist/models/Context';\nimport { ContextEnvEnum } from '@spiffy-ai/commerce-api-client'; // Import ContextEnvEnum\nimport {\n  baseUrlAtom,\n  reactAppNameAtom,\n  contextSourceAtom,\n  orgShortNameAtom,\n  envAtom, // Import envAtom\n} from 'src/atoms/envive/enviveConfig';\nimport { userIdAtom, chatIdAtom } from 'src/atoms/app'; // Import userIdAtom and chatIdAtom\nimport { orgIdAtom, featureFlagServiceAtom } from 'src/atoms/org/graphqlConfig'; // Import new orgIdAtom and featureFlagServiceAtom\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 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 path = basePath || baseUrl;\n    // API Key is now handled at the EnviveConfigProvider level\n    const config: Configuration = new Configuration({\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  }\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 featureGates = featureFlagService?.featureFlagService?.getFeatureFlags() || {};\n    const urlResolvingRequest = {\n      url,\n      context,\n      feature_gates: featureGates,\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('[spiffy-ai] 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('[spiffy-ai] 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('[spiffy-ai] 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  /**\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  static identifyUser = async (\n    spiffyUserId: string,\n    merchantUserId: string,\n    uaDetails: ClientDetails,\n  ): Promise<void> => {\n    try {\n      await CommerceApiClient.getInstance().defaultApi.v1AnalyticsIdentifyPost({\n        AnalyticsIdentifyRequest: {\n          user_id: spiffyUserId,\n          os_name: uaDetails.os,\n          os_version: uaDetails.osVersion,\n          platform: uaDetails.os,\n          device_id: uaDetails.deviceModel,\n          device_brand: uaDetails.deviceBrand,\n          device_manufacturer: uaDetails.deviceManufacturer,\n          device_model: uaDetails.deviceModel,\n          user_properties: {\n            cdp_user_id: merchantUserId,\n            browser: uaDetails.browser,\n            browser_version: uaDetails.browserVersion,\n            user_agent: uaDetails.userAgent,\n          },\n        },\n      });\n    } catch (err) {\n      Logger.logError('Failed to identify user', err);\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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"}