@envive-ai/react-hooks 0.2.10 → 0.2.11

package/dist/application/commerce-api.js

@@ -0,0 +1,318 @@
+import { ProductExperiment } from "./models/productExperiment.js";
+import logger_default from "./logging/logger.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 { baseUrlAtom, contextSourceAtom, envAtom, orgShortNameAtom, reactAppNameAtom } from "../atoms/envive/enviveConfig.js";
+import { getAtomStore } from "../atoms/atomStore/atomStore.js";
+import { chatIdAtom, userIdAtom } from "../atoms/app/index.js";
+import { messageFromFormSubmittedEvent } from "./utils/messageFromFormSubmittedEvent.js";
+import { messageFromQueryEvent } from "./utils/messageFromQueryEvent.js";
+import { messageFromResponse } from "./utils/messageFromResponse.js";
+import { messageFromSuggestionEvent } from "./utils/messageFromSuggestionEvent.js";
+import { messageRequestToCommerceMessageRequest } from "./utils/nextMessageRequestToApiRequest.js";
+import { coreSupportedEventRequestToApiRequest } from "./utils/supportedEventRequestToApiRequest.js";
+import "./utils/index.js";
+import { featureFlagServiceAtom, orgIdAtom } from "../atoms/org/graphqlConfig.js";
+import { SessionRestartRequired } from "../types/exceptions/sessionExceptions.js";
+import { UnsupportedProductException } from "../types/exceptions/unsupportedProductExceptions.js";
+import { Configuration, ContextEnvEnum, ContextSourceEnum, CustomerServiceApi, DefaultApi, FormType, InferenceApi, ResponseCategory, ResponseError, UserEventCategory, V1OrgConfigGetSourceEnum } from "@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 ResponseError)) {
+		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 UnsupportedProductException();
+	else if (errorResponse?.app_code?.toUpperCase() === "RESTART_SESSION" || errorResponse?.sub_code?.toUpperCase() === "NOT_FOUND") {
+		logger_default.logInfo("Session does not exist. Re-start session", error, error.response, errorResponse);
+		throw new SessionRestartRequired();
+	}
+	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 = getAtomStore().get(baseUrlAtom);
+		const config = new Configuration({
+			basePath: basePath || baseUrl,
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json"
+			}
+		});
+		this.defaultApi = new DefaultApi(config);
+		this.inferenceApi = new InferenceApi(config);
+		this.customerServiceApi = new CustomerServiceApi(config);
+	}
+	static {
+		this.resolveUrl = async (url) => {
+			const atomStore = getAtomStore();
+			const orgShortName = atomStore.get(orgShortNameAtom);
+			const orgId = atomStore.get(orgIdAtom);
+			const userId = atomStore.get(userIdAtom);
+			const chatId = atomStore.get(chatIdAtom);
+			const source = atomStore.get(contextSourceAtom);
+			const env = atomStore.get(envAtom);
+			const featureFlagService = atomStore.get(featureFlagServiceAtom);
+			const urlResolvingRequest = {
+				url,
+				context: {
+					user_id: userId ?? "",
+					org_id: orgId ?? "",
+					org_short_name: orgShortName ?? "",
+					chat_id: chatId ?? "",
+					source: source ?? ContextSourceEnum.App,
+					env: env ?? 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: messageRequestToCommerceMessageRequest(payload) })).map((resp) => validateResponse(resp)).map((resp) => messageFromResponse(resp)).filter((m) => m != null);
+			} catch (err) {
+				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: messageRequestToCommerceMessageRequest(payload) }, { signal: abortController.signal });
+					if (!response.raw.body) {
+						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) {
+							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 = validateResponse(parsedLine);
+							if (validatedResponse) yield validatedResponse;
+						}
+					}
+				} catch (error) {
+					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: messageRequestToCommerceMessageRequest(payload) }, { signal: CommerceApiClient.getInstance().suggestionsAbortController.signal })).map((resp) => validateSuggestion(resp)).filter((suggestion) => suggestion != null);
+			} catch (error) {
+				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) => validateResponse(response)).filter((response) => response != null));
+			const suggestions = data?.suggestions.map((suggestion) => validateSuggestion(suggestion)).filter((suggestion) => suggestion != null);
+			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) => {
+				if ([UserEventCategory.QueryTyped, UserEventCategory.Search].includes(event.category)) return [messageFromQueryEvent(event)];
+				if (event.category === UserEventCategory.SuggestionClicked) return [messageFromSuggestionEvent(event, suggestions)];
+				if (event.category === UserEventCategory.FormSubmitted) {
+					const formResponse = responses.flat().find((response) => response.id === event.attributes.formResponseId && event.attributes.formType !== FormType.Escalation);
+					if (formResponse && formResponse.category === ResponseCategory.Form) return [messageFromFormSubmittedEvent(event, formResponse.attributes)];
+				}
+				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: coreSupportedEventRequestToApiRequest(payload) })).raw.text();
+				const httpResponseJson = JSON.parse(httpResponseText);
+				return {
+					...httpResponseJson,
+					numberOfReviews: httpResponseJson.num_of_reviews,
+					merchant_tags: httpResponseJson.merchant_tags || []
+				};
+			} catch (err) {
+				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) {
+				logger_default.logError("Failed to identify user", err);
+			}
+		};
+	}
+	static {
+		this.mapContextSourceToV1OrgConfigGetSource = (source) => {
+			if (source === void 0) return void 0;
+			switch (source) {
+				case ContextSourceEnum.Fork: return V1OrgConfigGetSourceEnum.Fork;
+				case ContextSourceEnum.Playground: return V1OrgConfigGetSourceEnum.Playground;
+				case ContextSourceEnum.App: return V1OrgConfigGetSourceEnum.App;
+				case ContextSourceEnum.Test: return V1OrgConfigGetSourceEnum.Test;
+				case ContextSourceEnum.Eval: return V1OrgConfigGetSourceEnum.Test;
+				default: return source;
+			}
+		};
+	}
+	static {
+		this.getOrgConfig = async (user_id) => {
+			try {
+				const atomStore = getAtomStore();
+				const reactAppName = atomStore.get(reactAppNameAtom);
+				const contextSource = atomStore.get(contextSourceAtom);
+				const featureFlagService = atomStore.get(featureFlagServiceAtom);
+				const request = {
+					namespace: reactAppName,
+					user_id,
+					source: this.mapContextSourceToV1OrgConfigGetSource(contextSource),
+					include_experiments: Object.values(ProductExperiment),
+					include_feature_gates: Object.entries(featureFlagService?.featureFlagService?.getFeatureFlags() || {}).filter(([, isEnabled]) => isEnabled).map(([featureGateName]) => featureGateName)
+				};
+				return validateOrgConfigResults(await CommerceApiClient.getInstance().defaultApi.v1OrgConfigGet(request));
+			} catch (err) {
+				logger_default.logError(`Failed to get org config`, err, { err });
+				return;
+			}
+		};
+	}
+	static {
+		this.addNoteToLatestConversation = async (spiffyUserId, email, customerServiceProvider) => {
+			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) {
+				logger_default.logError("Failed to add note to latest conversation", { err });
+			}
+		};
+	}
+	static {
+		this.getCustomerServiceApi = () => CommerceApiClient.getInstance().customerServiceApi;
+	}
+};
+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":["config: Configuration","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 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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"}

package/dist/application/logging/logger.cjs

@@ -0,0 +1,21 @@
+
+//#region src/application/logging/logger.ts
+var Logger = class {
+	static logInfo(message, ...args) {
+		console.info(`INFO: ${message}`, ...args);
+	}
+	static logDebug(message, ...args) {
+		console.debug(`DEBUG: ${message}`, ...args);
+	}
+	static logError(message, error, ...args) {
+		console.error(`ERROR: ${message} error=${error}`, args);
+	}
+	static logWarn(message, error, ...args) {
+		console.warn(`WARN: ${message} error=${error}`, args);
+	}
+};
+var logger_default = Logger;
+
+//#endregion
+exports.default = logger_default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmNqcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBwbGljYXRpb24vbG9nZ2luZy9sb2dnZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUgbm8tY29uc29sZSAqL1xuXG5jbGFzcyBMb2dnZXIge1xuICBzdGF0aWMgbG9nSW5mbyhtZXNzYWdlOiBzdHJpbmcsIC4uLmFyZ3M6IHVua25vd25bXSk6IHZvaWQge1xuICAgIGNvbnNvbGUuaW5mbyhgSU5GTzogJHttZXNzYWdlfWAsIC4uLmFyZ3MpO1xuICB9XG5cbiAgc3RhdGljIGxvZ0RlYnVnKG1lc3NhZ2U6IHN0cmluZywgLi4uYXJnczogdW5rbm93bltdKTogdm9pZCB7XG4gICAgY29uc29sZS5kZWJ1ZyhgREVCVUc6ICR7bWVzc2FnZX1gLCAuLi5hcmdzKTtcbiAgfVxuXG4gIHN0YXRpYyBsb2dFcnJvcihtZXNzYWdlOiBzdHJpbmcsIGVycm9yOiB1bmtub3duIHwgdW5kZWZpbmVkLCAuLi5hcmdzOiB1bmtub3duW10pOiB2b2lkIHtcbiAgICBjb25zb2xlLmVycm9yKGBFUlJPUjogJHttZXNzYWdlfSBlcnJvcj0ke2Vycm9yfWAsIGFyZ3MpO1xuICB9XG5cbiAgc3RhdGljIGxvZ1dhcm4obWVzc2FnZTogc3RyaW5nLCBlcnJvcjogdW5rbm93biB8IHVuZGVmaW5lZCwgLi4uYXJnczogdW5rbm93bltdKTogdm9pZCB7XG4gICAgY29uc29sZS53YXJuKGBXQVJOOiAke21lc3NhZ2V9IGVycm9yPSR7ZXJyb3J9YCwgYXJncyk7XG4gIH1cbn1cblxuZXhwb3J0IGRlZmF1bHQgTG9nZ2VyO1xuIl0sIm1hcHBpbmdzIjoiOztBQUVBLElBQU0sU0FBTixNQUFhO0NBQ1gsT0FBTyxRQUFRLFNBQWlCLEdBQUcsTUFBdUI7QUFDeEQsVUFBUSxLQUFLLFNBQVMsV0FBVyxHQUFHLEtBQUs7O0NBRzNDLE9BQU8sU0FBUyxTQUFpQixHQUFHLE1BQXVCO0FBQ3pELFVBQVEsTUFBTSxVQUFVLFdBQVcsR0FBRyxLQUFLOztDQUc3QyxPQUFPLFNBQVMsU0FBaUIsT0FBNEIsR0FBRyxNQUF1QjtBQUNyRixVQUFRLE1BQU0sVUFBVSxRQUFRLFNBQVMsU0FBUyxLQUFLOztDQUd6RCxPQUFPLFFBQVEsU0FBaUIsT0FBNEIsR0FBRyxNQUF1QjtBQUNwRixVQUFRLEtBQUssU0FBUyxRQUFRLFNBQVMsU0FBUyxLQUFLOzs7QUFJekQscUJBQWUifQ==

package/dist/application/logging/logger.js

@@ -0,0 +1,20 @@
+//#region src/application/logging/logger.ts
+var Logger = class {
+	static logInfo(message, ...args) {
+		console.info(`INFO: ${message}`, ...args);
+	}
+	static logDebug(message, ...args) {
+		console.debug(`DEBUG: ${message}`, ...args);
+	}
+	static logError(message, error, ...args) {
+		console.error(`ERROR: ${message} error=${error}`, args);
+	}
+	static logWarn(message, error, ...args) {
+		console.warn(`WARN: ${message} error=${error}`, args);
+	}
+};
+var logger_default = Logger;
+
+//#endregion
+export { logger_default as default };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcHBsaWNhdGlvbi9sb2dnaW5nL2xvZ2dlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBuby1jb25zb2xlICovXG5cbmNsYXNzIExvZ2dlciB7XG4gIHN0YXRpYyBsb2dJbmZvKG1lc3NhZ2U6IHN0cmluZywgLi4uYXJnczogdW5rbm93bltdKTogdm9pZCB7XG4gICAgY29uc29sZS5pbmZvKGBJTkZPOiAke21lc3NhZ2V9YCwgLi4uYXJncyk7XG4gIH1cblxuICBzdGF0aWMgbG9nRGVidWcobWVzc2FnZTogc3RyaW5nLCAuLi5hcmdzOiB1bmtub3duW10pOiB2b2lkIHtcbiAgICBjb25zb2xlLmRlYnVnKGBERUJVRzogJHttZXNzYWdlfWAsIC4uLmFyZ3MpO1xuICB9XG5cbiAgc3RhdGljIGxvZ0Vycm9yKG1lc3NhZ2U6IHN0cmluZywgZXJyb3I6IHVua25vd24gfCB1bmRlZmluZWQsIC4uLmFyZ3M6IHVua25vd25bXSk6IHZvaWQge1xuICAgIGNvbnNvbGUuZXJyb3IoYEVSUk9SOiAke21lc3NhZ2V9IGVycm9yPSR7ZXJyb3J9YCwgYXJncyk7XG4gIH1cblxuICBzdGF0aWMgbG9nV2FybihtZXNzYWdlOiBzdHJpbmcsIGVycm9yOiB1bmtub3duIHwgdW5kZWZpbmVkLCAuLi5hcmdzOiB1bmtub3duW10pOiB2b2lkIHtcbiAgICBjb25zb2xlLndhcm4oYFdBUk46ICR7bWVzc2FnZX0gZXJyb3I9JHtlcnJvcn1gLCBhcmdzKTtcbiAgfVxufVxuXG5leHBvcnQgZGVmYXVsdCBMb2dnZXI7XG4iXSwibWFwcGluZ3MiOiI7QUFFQSxJQUFNLFNBQU4sTUFBYTtDQUNYLE9BQU8sUUFBUSxTQUFpQixHQUFHLE1BQXVCO0FBQ3hELFVBQVEsS0FBSyxTQUFTLFdBQVcsR0FBRyxLQUFLOztDQUczQyxPQUFPLFNBQVMsU0FBaUIsR0FBRyxNQUF1QjtBQUN6RCxVQUFRLE1BQU0sVUFBVSxXQUFXLEdBQUcsS0FBSzs7Q0FHN0MsT0FBTyxTQUFTLFNBQWlCLE9BQTRCLEdBQUcsTUFBdUI7QUFDckYsVUFBUSxNQUFNLFVBQVUsUUFBUSxTQUFTLFNBQVMsS0FBSzs7Q0FHekQsT0FBTyxRQUFRLFNBQWlCLE9BQTRCLEdBQUcsTUFBdUI7QUFDcEYsVUFBUSxLQUFLLFNBQVMsUUFBUSxTQUFTLFNBQVMsS0FBSzs7O0FBSXpELHFCQUFlIn0=

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

@@ -0,0 +1,8 @@
+import { CamelCasedPropertiesDeep } from "../utilityTypes/camelCasedPropertiesDeep.cjs";
+import { Context } from "@spiffy-ai/commerce-api-client";
+
+//#region src/application/models/api/context.d.ts
+interface Context$1 extends CamelCasedPropertiesDeep<Context> {}
+//#endregion
+export { Context$1 as Context };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC5kLmN0cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXBwbGljYXRpb24vbW9kZWxzL2FwaS9jb250ZXh0LmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29udGV4dCBhcyBBcGlDb250ZXh0IH0gZnJvbSAnQHNwaWZmeS1haS9jb21tZXJjZS1hcGktY2xpZW50JztcbmltcG9ydCB7IENhbWVsQ2FzZWRQcm9wZXJ0aWVzRGVlcCB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMvdXRpbGl0eVR5cGVzJztcbmV4cG9ydCBpbnRlcmZhY2UgQ29udGV4dCBleHRlbmRzIENhbWVsQ2FzZWRQcm9wZXJ0aWVzRGVlcDxBcGlDb250ZXh0PiB7XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7QUFFQSxJQUFXLFlBQVU7Q0FBQztPQUFXO09BQWtCO0NBQW1CIn0=

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

@@ -0,0 +1,8 @@
+import { CamelCasedPropertiesDeep } from "../utilityTypes/camelCasedPropertiesDeep.js";
+import { Context } from "@spiffy-ai/commerce-api-client";
+
+//#region src/application/models/api/context.d.ts
+interface Context$1 extends CamelCasedPropertiesDeep<Context> {}
+//#endregion
+export { Context$1 as Context };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC5kLnRzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMvYXBpL2NvbnRleHQuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb250ZXh0IGFzIEFwaUNvbnRleHQgfSBmcm9tICdAc3BpZmZ5LWFpL2NvbW1lcmNlLWFwaS1jbGllbnQnO1xuaW1wb3J0IHsgQ2FtZWxDYXNlZFByb3BlcnRpZXNEZWVwIH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscy91dGlsaXR5VHlwZXMnO1xuZXhwb3J0IGludGVyZmFjZSBDb250ZXh0IGV4dGVuZHMgQ2FtZWxDYXNlZFByb3BlcnRpZXNEZWVwPEFwaUNvbnRleHQ+IHtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7OztBQUVBLElBQVcsWUFBVTtDQUFDO09BQVc7T0FBa0I7Q0FBbUIifQ==

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

@@ -0,0 +1,8 @@
+import { CamelCasedPropertiesDeep } from "../utilityTypes/camelCasedPropertiesDeep.cjs";
+import { GenerationParams } from "@spiffy-ai/commerce-api-client";
+
+//#region src/application/models/api/generationParams.d.ts
+interface GenerationParams$1 extends CamelCasedPropertiesDeep<GenerationParams> {}
+//#endregion
+export { GenerationParams$1 as GenerationParams };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdGlvblBhcmFtcy5kLmN0cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXBwbGljYXRpb24vbW9kZWxzL2FwaS9nZW5lcmF0aW9uUGFyYW1zLmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgR2VuZXJhdGlvblBhcmFtcyBhcyBBcGlHZW5lcmF0aW9uUGFyYW1zIH0gZnJvbSAnQHNwaWZmeS1haS9jb21tZXJjZS1hcGktY2xpZW50JztcbmltcG9ydCB7IENhbWVsQ2FzZWRQcm9wZXJ0aWVzRGVlcCB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMvdXRpbGl0eVR5cGVzJztcbmV4cG9ydCBpbnRlcmZhY2UgR2VuZXJhdGlvblBhcmFtcyBleHRlbmRzIENhbWVsQ2FzZWRQcm9wZXJ0aWVzRGVlcDxBcGlHZW5lcmF0aW9uUGFyYW1zPiB7XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7QUFFQSxJQUFXLHFCQUFtQjtDQUFDO09BQVc7T0FBMkI7Q0FBbUIifQ==

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

@@ -0,0 +1,8 @@
+import { CamelCasedPropertiesDeep } from "../utilityTypes/camelCasedPropertiesDeep.js";
+import { GenerationParams } from "@spiffy-ai/commerce-api-client";
+
+//#region src/application/models/api/generationParams.d.ts
+interface GenerationParams$1 extends CamelCasedPropertiesDeep<GenerationParams> {}
+//#endregion
+export { GenerationParams$1 as GenerationParams };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdGlvblBhcmFtcy5kLnRzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMvYXBpL2dlbmVyYXRpb25QYXJhbXMuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBHZW5lcmF0aW9uUGFyYW1zIGFzIEFwaUdlbmVyYXRpb25QYXJhbXMgfSBmcm9tICdAc3BpZmZ5LWFpL2NvbW1lcmNlLWFwaS1jbGllbnQnO1xuaW1wb3J0IHsgQ2FtZWxDYXNlZFByb3BlcnRpZXNEZWVwIH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscy91dGlsaXR5VHlwZXMnO1xuZXhwb3J0IGludGVyZmFjZSBHZW5lcmF0aW9uUGFyYW1zIGV4dGVuZHMgQ2FtZWxDYXNlZFByb3BlcnRpZXNEZWVwPEFwaUdlbmVyYXRpb25QYXJhbXM+IHtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7OztBQUVBLElBQVcscUJBQW1CO0NBQUM7T0FBVztPQUEyQjtDQUFtQiJ9

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

@@ -0,0 +1,15 @@
+import { Context } from "./context.cjs";
+import { GenerationParams } from "./generationParams.cjs";
+import { UserEvent } from "./userEvent.cjs";
+
+//#region src/application/models/api/nextMessageRequest.d.ts
+interface NextMessageRequest {
+  id: string;
+  context: Context;
+  userEvents?: UserEvent[];
+  featureFlags?: Record<string, boolean>;
+  generationParams?: GenerationParams;
+}
+//#endregion
+export { NextMessageRequest };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV4dE1lc3NhZ2VSZXF1ZXN0LmQuY3RzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMvYXBpL25leHRNZXNzYWdlUmVxdWVzdC5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbnRleHQgfSBmcm9tICcuL2NvbnRleHQnO1xuaW1wb3J0IHsgVXNlckV2ZW50IH0gZnJvbSAnLi91c2VyRXZlbnQnO1xuaW1wb3J0IHsgR2VuZXJhdGlvblBhcmFtcyB9IGZyb20gJy4vZ2VuZXJhdGlvblBhcmFtcyc7XG5leHBvcnQgaW50ZXJmYWNlIE5leHRNZXNzYWdlUmVxdWVzdCB7XG4gICAgaWQ6IHN0cmluZztcbiAgICBjb250ZXh0OiBDb250ZXh0O1xuICAgIHVzZXJFdmVudHM/OiBVc2VyRXZlbnRbXTtcbiAgICBmZWF0dXJlRmxhZ3M/OiBSZWNvcmQ8c3RyaW5nLCBib29sZWFuPjtcbiAgICBnZW5lcmF0aW9uUGFyYW1zPzogR2VuZXJhdGlvblBhcmFtcztcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFHQSxJQUFXLHFCQUFxQjtDQUFDO09BQUc7T0FBQTtPQUFBO09BQUE7Q0FBQSJ9

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

@@ -0,0 +1,15 @@
+import { Context } from "./context.js";
+import { GenerationParams } from "./generationParams.js";
+import { UserEvent } from "./userEvent.js";
+
+//#region src/application/models/api/nextMessageRequest.d.ts
+interface NextMessageRequest {
+  id: string;
+  context: Context;
+  userEvents?: UserEvent[];
+  featureFlags?: Record<string, boolean>;
+  generationParams?: GenerationParams;
+}
+//#endregion
+export { NextMessageRequest };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV4dE1lc3NhZ2VSZXF1ZXN0LmQudHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL21vZGVscy9hcGkvbmV4dE1lc3NhZ2VSZXF1ZXN0LmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29udGV4dCB9IGZyb20gJy4vY29udGV4dCc7XG5pbXBvcnQgeyBVc2VyRXZlbnQgfSBmcm9tICcuL3VzZXJFdmVudCc7XG5pbXBvcnQgeyBHZW5lcmF0aW9uUGFyYW1zIH0gZnJvbSAnLi9nZW5lcmF0aW9uUGFyYW1zJztcbmV4cG9ydCBpbnRlcmZhY2UgTmV4dE1lc3NhZ2VSZXF1ZXN0IHtcbiAgICBpZDogc3RyaW5nO1xuICAgIGNvbnRleHQ6IENvbnRleHQ7XG4gICAgdXNlckV2ZW50cz86IFVzZXJFdmVudFtdO1xuICAgIGZlYXR1cmVGbGFncz86IFJlY29yZDxzdHJpbmcsIGJvb2xlYW4+O1xuICAgIGdlbmVyYXRpb25QYXJhbXM/OiBHZW5lcmF0aW9uUGFyYW1zO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7OztBQUdBLElBQVcscUJBQXFCO0NBQUM7T0FBRztPQUFBO09BQUE7T0FBQTtDQUFBIn0=

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

@@ -0,0 +1,20 @@
+//#region src/application/models/api/orgAnalyticsConfig.d.ts
+interface OrgAnalyticsConfig {
+  amplitude?: OrgAnalyticsAmplitudeConfig;
+  customerService?: OrgAnalyticsCustomerServiceConfig;
+  googleAnalytics?: OrgAnalyticsGoogleAnalyticsConfig;
+}
+interface OrgAnalyticsAmplitudeConfig {
+  sessionReplayEnabled: boolean;
+  sessionReplaySampleRate: number;
+  trackingEnabled: boolean;
+}
+interface OrgAnalyticsCustomerServiceConfig {
+  provider: string;
+}
+interface OrgAnalyticsGoogleAnalyticsConfig {
+  measurementId?: string;
+}
+//#endregion
+export { OrgAnalyticsAmplitudeConfig, OrgAnalyticsConfig, OrgAnalyticsCustomerServiceConfig, OrgAnalyticsGoogleAnalyticsConfig };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JnQW5hbHl0aWNzQ29uZmlnLmQuY3RzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMvYXBpL29yZ0FuYWx5dGljc0NvbmZpZy5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgT3JnQW5hbHl0aWNzQ29uZmlnIHtcbiAgICBhbXBsaXR1ZGU/OiBPcmdBbmFseXRpY3NBbXBsaXR1ZGVDb25maWc7XG4gICAgY3VzdG9tZXJTZXJ2aWNlPzogT3JnQW5hbHl0aWNzQ3VzdG9tZXJTZXJ2aWNlQ29uZmlnO1xuICAgIGdvb2dsZUFuYWx5dGljcz86IE9yZ0FuYWx5dGljc0dvb2dsZUFuYWx5dGljc0NvbmZpZztcbn1cbmV4cG9ydCBpbnRlcmZhY2UgT3JnQW5hbHl0aWNzQW1wbGl0dWRlQ29uZmlnIHtcbiAgICBzZXNzaW9uUmVwbGF5RW5hYmxlZDogYm9vbGVhbjtcbiAgICBzZXNzaW9uUmVwbGF5U2FtcGxlUmF0ZTogbnVtYmVyO1xuICAgIHRyYWNraW5nRW5hYmxlZDogYm9vbGVhbjtcbn1cbmV4cG9ydCBpbnRlcmZhY2UgT3JnQW5hbHl0aWNzQ3VzdG9tZXJTZXJ2aWNlQ29uZmlnIHtcbiAgICBwcm92aWRlcjogc3RyaW5nO1xufVxuZXhwb3J0IGludGVyZmFjZSBPcmdBbmFseXRpY3NHb29nbGVBbmFseXRpY3NDb25maWcge1xuICAgIG1lYXN1cmVtZW50SWQ/OiBzdHJpbmc7XG59XG4iXSwibWFwcGluZ3MiOiI7QUFBQSxJQUFXLHFCQUFxQjtDQUFDO09BQUc7T0FBQTtPQUFBO0NBQUE7QUFDcEMsSUFBVyw4QkFBOEIsQ0FBQyxJQUFDO0FBQzNDLElBQVcsb0NBQW9DLENBQUMsSUFBSTtBQUNwRCxJQUFXLG9DQUFvQyxDQUFDLElBQUkifQ==

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

@@ -0,0 +1,20 @@
+//#region src/application/models/api/orgAnalyticsConfig.d.ts
+interface OrgAnalyticsConfig {
+  amplitude?: OrgAnalyticsAmplitudeConfig;
+  customerService?: OrgAnalyticsCustomerServiceConfig;
+  googleAnalytics?: OrgAnalyticsGoogleAnalyticsConfig;
+}
+interface OrgAnalyticsAmplitudeConfig {
+  sessionReplayEnabled: boolean;
+  sessionReplaySampleRate: number;
+  trackingEnabled: boolean;
+}
+interface OrgAnalyticsCustomerServiceConfig {
+  provider: string;
+}
+interface OrgAnalyticsGoogleAnalyticsConfig {
+  measurementId?: string;
+}
+//#endregion
+export { OrgAnalyticsAmplitudeConfig, OrgAnalyticsConfig, OrgAnalyticsCustomerServiceConfig, OrgAnalyticsGoogleAnalyticsConfig };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JnQW5hbHl0aWNzQ29uZmlnLmQudHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL21vZGVscy9hcGkvb3JnQW5hbHl0aWNzQ29uZmlnLmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBPcmdBbmFseXRpY3NDb25maWcge1xuICAgIGFtcGxpdHVkZT86IE9yZ0FuYWx5dGljc0FtcGxpdHVkZUNvbmZpZztcbiAgICBjdXN0b21lclNlcnZpY2U/OiBPcmdBbmFseXRpY3NDdXN0b21lclNlcnZpY2VDb25maWc7XG4gICAgZ29vZ2xlQW5hbHl0aWNzPzogT3JnQW5hbHl0aWNzR29vZ2xlQW5hbHl0aWNzQ29uZmlnO1xufVxuZXhwb3J0IGludGVyZmFjZSBPcmdBbmFseXRpY3NBbXBsaXR1ZGVDb25maWcge1xuICAgIHNlc3Npb25SZXBsYXlFbmFibGVkOiBib29sZWFuO1xuICAgIHNlc3Npb25SZXBsYXlTYW1wbGVSYXRlOiBudW1iZXI7XG4gICAgdHJhY2tpbmdFbmFibGVkOiBib29sZWFuO1xufVxuZXhwb3J0IGludGVyZmFjZSBPcmdBbmFseXRpY3NDdXN0b21lclNlcnZpY2VDb25maWcge1xuICAgIHByb3ZpZGVyOiBzdHJpbmc7XG59XG5leHBvcnQgaW50ZXJmYWNlIE9yZ0FuYWx5dGljc0dvb2dsZUFuYWx5dGljc0NvbmZpZyB7XG4gICAgbWVhc3VyZW1lbnRJZD86IHN0cmluZztcbn1cbiJdLCJtYXBwaW5ncyI6IjtBQUFBLElBQVcscUJBQXFCO0NBQUM7T0FBRztPQUFBO09BQUE7Q0FBQTtBQUNwQyxJQUFXLDhCQUE4QixDQUFDLElBQUM7QUFDM0MsSUFBVyxvQ0FBb0MsQ0FBQyxJQUFJO0FBQ3BELElBQVcsb0NBQW9DLENBQUMsSUFBSSJ9

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

@@ -0,0 +1,43 @@
+import { ColorMapping } from "../colorsConfig.cjs";
+import { OrganizationConfig as OrganizationConfig$1 } from "./organizationConfig.cjs";
+import { FrontendConfig } from "../frontendConfig.cjs";
+import { OrganizationStatusEnum } from "@spiffy-ai/commerce-api-client";
+
+//#region src/application/models/api/orgConfigResults.d.ts
+interface OrgConfigExperiment {
+  group?: string;
+  groupName?: string;
+  name?: string;
+  ruleId?: string;
+  value?: Record<string, unknown>;
+}
+interface OrgConfigFeatureGate {
+  groupName?: string;
+  name?: string;
+  ruleId?: string;
+  value?: boolean;
+}
+interface Organization {
+  id: string;
+  displayName: string;
+  domain: string;
+  shortName: string;
+  status: OrganizationStatusEnum;
+  createdAt?: string;
+  updatedAt?: string;
+}
+interface OrganizationSettings$1 {
+  org: Organization;
+  settings: Record<string, unknown>;
+}
+interface OrgConfig {
+  configs: OrganizationConfig$1[];
+  experiments: OrgConfigExperiment[];
+  gates: OrgConfigFeatureGate[];
+  org: OrganizationSettings$1;
+  colorsConfig?: ColorMapping;
+  frontendConfig?: FrontendConfig;
+}
+//#endregion
+export { OrgConfig, OrgConfigExperiment, OrgConfigFeatureGate, Organization, OrganizationSettings$1 as OrganizationSettings };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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