@envive-ai/react-hooks 0.3.1 → 0.3.3

package/dist/contexts/salesAgentContext/chatAPI.js

@@ -0,0 +1,44 @@
+import { queueUserEventAtom } from "../../atoms/chat/messageQueue.js";
+import { UserEventCategory } from "@spiffy-ai/commerce-api-client";
+import { useCallback } from "react";
+import { v4 } from "uuid";
+import { useSetAtom } from "jotai";
+
+//#region src/contexts/salesAgentContext/chatAPI.ts
+const useSalesAgentChatAPI = () => {
+	const queueUserEvent = useSetAtom(queueUserEventAtom);
+	return {
+		logPageVisit: useCallback(({ pageVisitCategory }) => {
+			queueUserEvent({
+				eventId: v4(),
+				category: UserEventCategory.PageVisit,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				attributes: {
+					url: window.location.href,
+					pageVisitCategory
+				}
+			});
+		}, [queueUserEvent]),
+		onSuggestionClicked: useCallback((suggestion) => {
+			queueUserEvent({
+				eventId: v4(),
+				category: UserEventCategory.SuggestionClicked,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				attributes: { suggestionId: suggestion.id }
+			});
+		}, [queueUserEvent]),
+		onTypedMessageSubmitted: useCallback(({ query }) => {
+			queueUserEvent({
+				eventId: v4(),
+				category: UserEventCategory.QueryTyped,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				attributes: { query }
+			});
+		}, [queueUserEvent]),
+		onFormResponseSubmitted: useCallback(() => {}, [])
+	};
+};
+
+//#endregion
+export { useSalesAgentChatAPI };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/contexts/salesAgentContext/index.cjs

@@ -0,0 +1,20 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_chatAPI = require('./chatAPI.cjs');
+const require_salesAgentContext = require('./salesAgentContext.cjs');
+let __spiffy_ai_commerce_api_client = require("@spiffy-ai/commerce-api-client");
+
+Object.defineProperty(exports, 'PageVisitCategory', {
+  enumerable: true,
+  get: function () {
+    return __spiffy_ai_commerce_api_client.PageVisitCategory;
+  }
+});
+exports.SalesAgentProvider = require_salesAgentContext.SalesAgentProvider;
+Object.defineProperty(exports, 'SuggestionCategory', {
+  enumerable: true,
+  get: function () {
+    return __spiffy_ai_commerce_api_client.SuggestionCategory;
+  }
+});
+exports.useSalesAgent = require_salesAgentContext.useSalesAgent;
+exports.useSalesAgentChatAPI = require_chatAPI.useSalesAgentChatAPI;

package/dist/contexts/salesAgentContext/index.d.cts

@@ -0,0 +1,4 @@
+import { SalesAgentChatAPI, useSalesAgentChatAPI } from "./chatAPI.cjs";
+import { SalesAgentProvider, useSalesAgent } from "./salesAgentContext.cjs";
+import { PageVisitCategory, SuggestionCategory } from "@spiffy-ai/commerce-api-client";
+export { PageVisitCategory, SalesAgentChatAPI, SalesAgentProvider, SuggestionCategory, useSalesAgent, useSalesAgentChatAPI };

package/dist/contexts/salesAgentContext/index.d.ts

@@ -0,0 +1,4 @@
+import { SalesAgentChatAPI, useSalesAgentChatAPI } from "./chatAPI.js";
+import { SalesAgentProvider, useSalesAgent } from "./salesAgentContext.js";
+import { PageVisitCategory, SuggestionCategory } from "@spiffy-ai/commerce-api-client";
+export { PageVisitCategory, SalesAgentChatAPI, SalesAgentProvider, SuggestionCategory, useSalesAgent, useSalesAgentChatAPI };

package/dist/contexts/salesAgentContext/index.js

@@ -0,0 +1,5 @@
+import { useSalesAgentChatAPI } from "./chatAPI.js";
+import { SalesAgentProvider, useSalesAgent } from "./salesAgentContext.js";
+import { PageVisitCategory, SuggestionCategory } from "@spiffy-ai/commerce-api-client";
+
+export { PageVisitCategory, SalesAgentProvider, SuggestionCategory, useSalesAgent, useSalesAgentChatAPI };

package/dist/contexts/salesAgentContext/salesAgentContext.cjs

@@ -0,0 +1,90 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_chatState = require('../../atoms/chat/chatState.cjs');
+const require_messageQueue = require('../../atoms/chat/messageQueue.cjs');
+const require_useSystemSettingsContext = require('../../hooks/SystemSettingsContext/useSystemSettingsContext.cjs');
+require('../../hooks/SystemSettingsContext/index.cjs');
+const require_chatAPI = require('./chatAPI.cjs');
+const require_salesAgentService = require('./salesAgentService.cjs');
+let react = require("react");
+let jotai = require("jotai");
+let react_jsx_runtime = require("react/jsx-runtime");
+
+//#region src/contexts/salesAgentContext/salesAgentContext.tsx
+const SalesAgentContext = (0, react.createContext)(void 0);
+const SalesAgentProvider = ({ children }) => {
+	const userEvents = (0, jotai.useAtomValue)(require_messageQueue.userEventQueueAtom);
+	const userQueueEventCount = (0, jotai.useAtomValue)(require_messageQueue.userQueueEventCountAtom);
+	const markUserEventsProcessed = (0, jotai.useSetAtom)(require_messageQueue.processUserEventAtom);
+	const settingsContext = require_useSystemSettingsContext.useSystemSettingsContext();
+	const { getStreamingResponses, createResponsePayload } = require_salesAgentService.useSalesAgentService();
+	const sendMessagesToBackend = (0, react.useCallback)(async () => {
+		if (userEvents.length === 0) return;
+		const [pendingMessage] = userEvents.slice(0, userQueueEventCount);
+		try {
+			const response = await getStreamingResponses(createResponsePayload({
+				userEvents: [pendingMessage],
+				generationParams: settingsContext.generationParams
+			}));
+			console.log("response", response);
+			markUserEventsProcessed([pendingMessage.eventId]);
+		} catch (error) {
+			console.error("error sending message");
+		}
+	}, [
+		userEvents,
+		userQueueEventCount,
+		createResponsePayload,
+		settingsContext.generationParams,
+		getStreamingResponses,
+		markUserEventsProcessed
+	]);
+	console.log("userQueueEventCount", userQueueEventCount);
+	console.log("userEvents", userEvents);
+	(0, react.useEffect)(() => {
+		if (userQueueEventCount > 0) sendMessagesToBackend();
+		console.log("SalesAgentProvider useEffect");
+	}, [sendMessagesToBackend, userQueueEventCount]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SalesAgentContext.Provider, {
+		value: void 0,
+		children
+	});
+};
+const useSalesAgent = () => {
+	const messages = (0, jotai.useAtomValue)(require_chatState.messagesAtom);
+	const suggestions = (0, jotai.useAtomValue)(require_chatState.suggestionsAtom);
+	const pendingMessages = (0, jotai.useAtomValue)(require_messageQueue.userEventQueueAtom);
+	const isResponseStreaming = false;
+	const isPendingResponse = false;
+	const isInitialized = false;
+	const { logPageVisit, onSuggestionClicked, onTypedMessageSubmitted, onFormResponseSubmitted } = require_chatAPI.useSalesAgentChatAPI();
+	return (0, react.useMemo)(() => {
+		return {
+			messages,
+			suggestions,
+			pendingMessages,
+			isResponseStreaming,
+			isPendingResponse,
+			isInitialized,
+			logPageVisit,
+			onSuggestionClicked,
+			onTypedMessageSubmitted,
+			onFormResponseSubmitted
+		};
+	}, [
+		messages,
+		suggestions,
+		pendingMessages,
+		isResponseStreaming,
+		isPendingResponse,
+		isInitialized,
+		logPageVisit,
+		onSuggestionClicked,
+		onTypedMessageSubmitted,
+		onFormResponseSubmitted
+	]);
+};
+
+//#endregion
+exports.SalesAgentProvider = SalesAgentProvider;
+exports.useSalesAgent = useSalesAgent;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"salesAgentContext.cjs","names":["SalesAgentProvider: React.FC<{ children: ReactNode }>","userEventQueueAtom","userQueueEventCountAtom","processUserEventAtom","useSystemSettingsContext","useSalesAgentService","messagesAtom","suggestionsAtom","useSalesAgentChatAPI"],"sources":["../../../src/contexts/salesAgentContext/salesAgentContext.tsx"],"sourcesContent":["import { useAtomValue, useSetAtom } from 'jotai';\nimport { ReactNode, createContext, useCallback, useEffect, useMemo } from 'react';\nimport { Message } from 'src/application/models/message';\nimport { Suggestion, UserEvent } from 'src/application/models';\nimport { messagesAtom, suggestionsAtom } from 'src/atoms/chat/chatState';\nimport {\n  processUserEventAtom,\n  userEventQueueAtom,\n  userQueueEventCountAtom,\n} from 'src/atoms/chat/messageQueue';\nimport { useSystemSettingsContext } from 'src/hooks/SystemSettingsContext';\nimport { SalesAgentChatAPI, useSalesAgentChatAPI } from './chatAPI';\nimport { useSalesAgentService } from './salesAgentService';\n\ninterface SalesAgent extends SalesAgentChatAPI {\n  // Messages are the full list of all turns\n  messages: Message[][];\n  // Pending messages are messages that the user has clicked/typed but have not yet been sent to the backend.\n  pendingMessages: UserEvent[];\n  // Suggestions are the list of suggestions that the user can click on in response to the most recent message from the backend\n  suggestions: Suggestion[];\n  // True while the response is streaming from the backend\n  isResponseStreaming: boolean;\n  // True while the response is pending from the backend\n  isPendingResponse: boolean;\n  // True when the sales agent is initialized\n  isInitialized: boolean;\n}\n\nconst SalesAgentContext = createContext<SalesAgent | undefined>(undefined);\n\nexport const SalesAgentProvider: React.FC<{ children: ReactNode }> = ({ children }) => {\n  const userEvents = useAtomValue(userEventQueueAtom);\n  const userQueueEventCount = useAtomValue(userQueueEventCountAtom);\n  const markUserEventsProcessed = useSetAtom(processUserEventAtom);\n  const settingsContext = useSystemSettingsContext();\n\n  const { getStreamingResponses, createResponsePayload } = useSalesAgentService();\n\n  // TODO: Ensure that amplitude events are being emitted\n\n  // TODO: Add support for the streaming responses to function\n\n  // TODO: Add support for the hydration of the messages from the backend on initialization\n  const sendMessagesToBackend = useCallback(async () => {\n    // Fast exit if there are no pending messages\n    if (userEvents.length === 0) {\n      return;\n    }\n    // TODO: Support sending multiple messages to the backend in one request\n    const [pendingMessage] = userEvents.slice(0, userQueueEventCount);\n    try {\n      const requestPayload = createResponsePayload({\n        userEvents: [pendingMessage],\n        generationParams: settingsContext.generationParams,\n      });\n      const response = await getStreamingResponses(requestPayload);\n\n      console.log('response', response);\n      // Remove the pending message from the user events\n      markUserEventsProcessed([pendingMessage.eventId]);\n    } catch (error) {\n      console.error('error sending message');\n    }\n  }, [\n    userEvents,\n    userQueueEventCount,\n    createResponsePayload,\n    settingsContext.generationParams,\n    getStreamingResponses,\n    markUserEventsProcessed,\n  ]);\n\n  console.log('userQueueEventCount', userQueueEventCount);\n  console.log('userEvents', userEvents);\n\n  // This is the primary event loop for communicating with the backend API\n  // It will be triggered when there are pending messages to be sent to the backend\n  // It will be responsible for sending the messages to the backend and receiving the responses\n  useEffect(() => {\n    if (userQueueEventCount > 0) {\n      sendMessagesToBackend();\n    }\n    // TODO: Add a suggestion retrieval here (don't get suggestions unless the event queue is empty)\n    console.log('SalesAgentProvider useEffect');\n  }, [sendMessagesToBackend, userQueueEventCount]);\n\n  return <SalesAgentContext.Provider value={undefined}>{children}</SalesAgentContext.Provider>;\n};\n\nexport const useSalesAgent = (): SalesAgent => {\n  const messages = useAtomValue(messagesAtom);\n  const suggestions = useAtomValue(suggestionsAtom);\n  const pendingMessages = useAtomValue(userEventQueueAtom);\n  const isResponseStreaming = false; // useAtomValue(isResponseStreamingAtom);\n  const isPendingResponse = false; // useAtomValue(isPendingResponseAtom);\n  const isInitialized = false; // useAtomValue(isInitializedAtom);\n\n  const { logPageVisit, onSuggestionClicked, onTypedMessageSubmitted, onFormResponseSubmitted } =\n    useSalesAgentChatAPI();\n\n  const salesAgent: SalesAgent = useMemo(() => {\n    return {\n      messages,\n      suggestions,\n      pendingMessages,\n      isResponseStreaming,\n      isPendingResponse,\n      isInitialized,\n      logPageVisit,\n      onSuggestionClicked,\n      onTypedMessageSubmitted,\n      onFormResponseSubmitted,\n    };\n  }, [\n    messages,\n    suggestions,\n    pendingMessages,\n    isResponseStreaming,\n    isPendingResponse,\n    isInitialized,\n    logPageVisit,\n    onSuggestionClicked,\n    onTypedMessageSubmitted,\n    onFormResponseSubmitted,\n  ]);\n  return salesAgent;\n};\n"],"mappings":";;;;;;;;;;;;AA6BA,MAAM,6CAA0D,OAAU;AAE1E,MAAaA,sBAAyD,EAAE,eAAe;CACrF,MAAM,qCAA0BC,wCAAmB;CACnD,MAAM,8CAAmCC,6CAAwB;CACjE,MAAM,gDAAqCC,0CAAqB;CAChE,MAAM,kBAAkBC,2DAA0B;CAElD,MAAM,EAAE,uBAAuB,0BAA0BC,gDAAsB;CAO/E,MAAM,+CAAoC,YAAY;AAEpD,MAAI,WAAW,WAAW,EACxB;EAGF,MAAM,CAAC,kBAAkB,WAAW,MAAM,GAAG,oBAAoB;AACjE,MAAI;GAKF,MAAM,WAAW,MAAM,sBAJA,sBAAsB;IAC3C,YAAY,CAAC,eAAe;IAC5B,kBAAkB,gBAAgB;IACnC,CAAC,CAC0D;AAE5D,WAAQ,IAAI,YAAY,SAAS;AAEjC,2BAAwB,CAAC,eAAe,QAAQ,CAAC;WAC1C,OAAO;AACd,WAAQ,MAAM,wBAAwB;;IAEvC;EACD;EACA;EACA;EACA,gBAAgB;EAChB;EACA;EACD,CAAC;AAEF,SAAQ,IAAI,uBAAuB,oBAAoB;AACvD,SAAQ,IAAI,cAAc,WAAW;AAKrC,4BAAgB;AACd,MAAI,sBAAsB,EACxB,wBAAuB;AAGzB,UAAQ,IAAI,+BAA+B;IAC1C,CAAC,uBAAuB,oBAAoB,CAAC;AAEhD,QAAO,2CAAC,kBAAkB;EAAS,OAAO;EAAY;GAAsC;;AAG9F,MAAa,sBAAkC;CAC7C,MAAM,mCAAwBC,+BAAa;CAC3C,MAAM,sCAA2BC,kCAAgB;CACjD,MAAM,0CAA+BN,wCAAmB;CACxD,MAAM,sBAAsB;CAC5B,MAAM,oBAAoB;CAC1B,MAAM,gBAAgB;CAEtB,MAAM,EAAE,cAAc,qBAAqB,yBAAyB,4BAClEO,sCAAsB;AA2BxB,iCAzB6C;AAC3C,SAAO;GACL;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACD;IACA;EACD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD,CAAC"}

package/dist/contexts/salesAgentContext/salesAgentContext.d.cts

@@ -0,0 +1,22 @@
+import { Message } from "../../application/models/message.cjs";
+import { UserEvent } from "../../application/models/api/userEvent.cjs";
+import { Suggestion } from "../../application/models/api/suggestion.cjs";
+import { SalesAgentChatAPI } from "./chatAPI.cjs";
+import { ReactNode } from "react";
+
+//#region src/contexts/salesAgentContext/salesAgentContext.d.ts
+interface SalesAgent extends SalesAgentChatAPI {
+  messages: Message[][];
+  pendingMessages: UserEvent[];
+  suggestions: Suggestion[];
+  isResponseStreaming: boolean;
+  isPendingResponse: boolean;
+  isInitialized: boolean;
+}
+declare const SalesAgentProvider: React.FC<{
+  children: ReactNode;
+}>;
+declare const useSalesAgent: () => SalesAgent;
+//#endregion
+export { SalesAgentProvider, useSalesAgent };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FsZXNBZ2VudENvbnRleHQuZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbnRleHRzL3NhbGVzQWdlbnRDb250ZXh0L3NhbGVzQWdlbnRDb250ZXh0LmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVhY3ROb2RlIH0gZnJvbSAncmVhY3QnO1xuaW1wb3J0IHsgTWVzc2FnZSB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMvbWVzc2FnZSc7XG5pbXBvcnQgeyBTdWdnZXN0aW9uLCBVc2VyRXZlbnQgfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzJztcbmltcG9ydCB7IFNhbGVzQWdlbnRDaGF0QVBJIH0gZnJvbSAnLi9jaGF0QVBJJztcbmludGVyZmFjZSBTYWxlc0FnZW50IGV4dGVuZHMgU2FsZXNBZ2VudENoYXRBUEkge1xuICAgIG1lc3NhZ2VzOiBNZXNzYWdlW11bXTtcbiAgICBwZW5kaW5nTWVzc2FnZXM6IFVzZXJFdmVudFtdO1xuICAgIHN1Z2dlc3Rpb25zOiBTdWdnZXN0aW9uW107XG4gICAgaXNSZXNwb25zZVN0cmVhbWluZzogYm9vbGVhbjtcbiAgICBpc1BlbmRpbmdSZXNwb25zZTogYm9vbGVhbjtcbiAgICBpc0luaXRpYWxpemVkOiBib29sZWFuO1xufVxuZXhwb3J0IGRlY2xhcmUgY29uc3QgU2FsZXNBZ2VudFByb3ZpZGVyOiBSZWFjdC5GQzx7XG4gICAgY2hpbGRyZW46IFJlYWN0Tm9kZTtcbn0+O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgdXNlU2FsZXNBZ2VudDogKCkgPT4gU2FsZXNBZ2VudDtcbmV4cG9ydCB7fTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7OztBQUlBLElBQUksYUFBYTtDQUFDO09BQVc7T0FBZTtPQUFHO09BQUE7Q0FBQTtBQUMvQyxJQUFXLHFCQUFjO0NBQUE7T0FBQTtPQUFBLE1BQUE7Q0FBQTtBQUN6QixJQUFXLGdCQUFnQixDQUFDLFdBQUksV0FBQSJ9

package/dist/contexts/salesAgentContext/salesAgentContext.d.ts

@@ -0,0 +1,22 @@
+import { Message } from "../../application/models/message.js";
+import { UserEvent } from "../../application/models/api/userEvent.js";
+import { Suggestion } from "../../application/models/api/suggestion.js";
+import { SalesAgentChatAPI } from "./chatAPI.js";
+import { ReactNode } from "react";
+
+//#region src/contexts/salesAgentContext/salesAgentContext.d.ts
+interface SalesAgent extends SalesAgentChatAPI {
+  messages: Message[][];
+  pendingMessages: UserEvent[];
+  suggestions: Suggestion[];
+  isResponseStreaming: boolean;
+  isPendingResponse: boolean;
+  isInitialized: boolean;
+}
+declare const SalesAgentProvider: React.FC<{
+  children: ReactNode;
+}>;
+declare const useSalesAgent: () => SalesAgent;
+//#endregion
+export { SalesAgentProvider, useSalesAgent };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FsZXNBZ2VudENvbnRleHQuZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29udGV4dHMvc2FsZXNBZ2VudENvbnRleHQvc2FsZXNBZ2VudENvbnRleHQuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZWFjdE5vZGUgfSBmcm9tICdyZWFjdCc7XG5pbXBvcnQgeyBNZXNzYWdlIH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscy9tZXNzYWdlJztcbmltcG9ydCB7IFN1Z2dlc3Rpb24sIFVzZXJFdmVudCB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMnO1xuaW1wb3J0IHsgU2FsZXNBZ2VudENoYXRBUEkgfSBmcm9tICcuL2NoYXRBUEknO1xuaW50ZXJmYWNlIFNhbGVzQWdlbnQgZXh0ZW5kcyBTYWxlc0FnZW50Q2hhdEFQSSB7XG4gICAgbWVzc2FnZXM6IE1lc3NhZ2VbXVtdO1xuICAgIHBlbmRpbmdNZXNzYWdlczogVXNlckV2ZW50W107XG4gICAgc3VnZ2VzdGlvbnM6IFN1Z2dlc3Rpb25bXTtcbiAgICBpc1Jlc3BvbnNlU3RyZWFtaW5nOiBib29sZWFuO1xuICAgIGlzUGVuZGluZ1Jlc3BvbnNlOiBib29sZWFuO1xuICAgIGlzSW5pdGlhbGl6ZWQ6IGJvb2xlYW47XG59XG5leHBvcnQgZGVjbGFyZSBjb25zdCBTYWxlc0FnZW50UHJvdmlkZXI6IFJlYWN0LkZDPHtcbiAgICBjaGlsZHJlbjogUmVhY3ROb2RlO1xufT47XG5leHBvcnQgZGVjbGFyZSBjb25zdCB1c2VTYWxlc0FnZW50OiAoKSA9PiBTYWxlc0FnZW50O1xuZXhwb3J0IHt9O1xuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBSUEsSUFBSSxhQUFhO0NBQUM7T0FBVztPQUFlO09BQUc7T0FBQTtDQUFBO0FBQy9DLElBQVcscUJBQWM7Q0FBQTtPQUFBO09BQUEsTUFBQTtDQUFBO0FBQ3pCLElBQVcsZ0JBQWdCLENBQUMsV0FBSSxXQUFBIn0=

package/dist/contexts/salesAgentContext/salesAgentContext.js

@@ -0,0 +1,88 @@
+import { messagesAtom, suggestionsAtom } from "../../atoms/chat/chatState.js";
+import { processUserEventAtom, userEventQueueAtom, userQueueEventCountAtom } from "../../atoms/chat/messageQueue.js";
+import { useSystemSettingsContext } from "../../hooks/SystemSettingsContext/useSystemSettingsContext.js";
+import "../../hooks/SystemSettingsContext/index.js";
+import { useSalesAgentChatAPI } from "./chatAPI.js";
+import { useSalesAgentService } from "./salesAgentService.js";
+import { createContext, useCallback, useEffect, useMemo } from "react";
+import { useAtomValue, useSetAtom } from "jotai";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/contexts/salesAgentContext/salesAgentContext.tsx
+const SalesAgentContext = createContext(void 0);
+const SalesAgentProvider = ({ children }) => {
+	const userEvents = useAtomValue(userEventQueueAtom);
+	const userQueueEventCount = useAtomValue(userQueueEventCountAtom);
+	const markUserEventsProcessed = useSetAtom(processUserEventAtom);
+	const settingsContext = useSystemSettingsContext();
+	const { getStreamingResponses, createResponsePayload } = useSalesAgentService();
+	const sendMessagesToBackend = useCallback(async () => {
+		if (userEvents.length === 0) return;
+		const [pendingMessage] = userEvents.slice(0, userQueueEventCount);
+		try {
+			const response = await getStreamingResponses(createResponsePayload({
+				userEvents: [pendingMessage],
+				generationParams: settingsContext.generationParams
+			}));
+			console.log("response", response);
+			markUserEventsProcessed([pendingMessage.eventId]);
+		} catch (error) {
+			console.error("error sending message");
+		}
+	}, [
+		userEvents,
+		userQueueEventCount,
+		createResponsePayload,
+		settingsContext.generationParams,
+		getStreamingResponses,
+		markUserEventsProcessed
+	]);
+	console.log("userQueueEventCount", userQueueEventCount);
+	console.log("userEvents", userEvents);
+	useEffect(() => {
+		if (userQueueEventCount > 0) sendMessagesToBackend();
+		console.log("SalesAgentProvider useEffect");
+	}, [sendMessagesToBackend, userQueueEventCount]);
+	return /* @__PURE__ */ jsx(SalesAgentContext.Provider, {
+		value: void 0,
+		children
+	});
+};
+const useSalesAgent = () => {
+	const messages = useAtomValue(messagesAtom);
+	const suggestions = useAtomValue(suggestionsAtom);
+	const pendingMessages = useAtomValue(userEventQueueAtom);
+	const isResponseStreaming = false;
+	const isPendingResponse = false;
+	const isInitialized = false;
+	const { logPageVisit, onSuggestionClicked, onTypedMessageSubmitted, onFormResponseSubmitted } = useSalesAgentChatAPI();
+	return useMemo(() => {
+		return {
+			messages,
+			suggestions,
+			pendingMessages,
+			isResponseStreaming,
+			isPendingResponse,
+			isInitialized,
+			logPageVisit,
+			onSuggestionClicked,
+			onTypedMessageSubmitted,
+			onFormResponseSubmitted
+		};
+	}, [
+		messages,
+		suggestions,
+		pendingMessages,
+		isResponseStreaming,
+		isPendingResponse,
+		isInitialized,
+		logPageVisit,
+		onSuggestionClicked,
+		onTypedMessageSubmitted,
+		onFormResponseSubmitted
+	]);
+};
+
+//#endregion
+export { SalesAgentProvider, useSalesAgent };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"salesAgentContext.js","names":["SalesAgentProvider: React.FC<{ children: ReactNode }>"],"sources":["../../../src/contexts/salesAgentContext/salesAgentContext.tsx"],"sourcesContent":["import { useAtomValue, useSetAtom } from 'jotai';\nimport { ReactNode, createContext, useCallback, useEffect, useMemo } from 'react';\nimport { Message } from 'src/application/models/message';\nimport { Suggestion, UserEvent } from 'src/application/models';\nimport { messagesAtom, suggestionsAtom } from 'src/atoms/chat/chatState';\nimport {\n  processUserEventAtom,\n  userEventQueueAtom,\n  userQueueEventCountAtom,\n} from 'src/atoms/chat/messageQueue';\nimport { useSystemSettingsContext } from 'src/hooks/SystemSettingsContext';\nimport { SalesAgentChatAPI, useSalesAgentChatAPI } from './chatAPI';\nimport { useSalesAgentService } from './salesAgentService';\n\ninterface SalesAgent extends SalesAgentChatAPI {\n  // Messages are the full list of all turns\n  messages: Message[][];\n  // Pending messages are messages that the user has clicked/typed but have not yet been sent to the backend.\n  pendingMessages: UserEvent[];\n  // Suggestions are the list of suggestions that the user can click on in response to the most recent message from the backend\n  suggestions: Suggestion[];\n  // True while the response is streaming from the backend\n  isResponseStreaming: boolean;\n  // True while the response is pending from the backend\n  isPendingResponse: boolean;\n  // True when the sales agent is initialized\n  isInitialized: boolean;\n}\n\nconst SalesAgentContext = createContext<SalesAgent | undefined>(undefined);\n\nexport const SalesAgentProvider: React.FC<{ children: ReactNode }> = ({ children }) => {\n  const userEvents = useAtomValue(userEventQueueAtom);\n  const userQueueEventCount = useAtomValue(userQueueEventCountAtom);\n  const markUserEventsProcessed = useSetAtom(processUserEventAtom);\n  const settingsContext = useSystemSettingsContext();\n\n  const { getStreamingResponses, createResponsePayload } = useSalesAgentService();\n\n  // TODO: Ensure that amplitude events are being emitted\n\n  // TODO: Add support for the streaming responses to function\n\n  // TODO: Add support for the hydration of the messages from the backend on initialization\n  const sendMessagesToBackend = useCallback(async () => {\n    // Fast exit if there are no pending messages\n    if (userEvents.length === 0) {\n      return;\n    }\n    // TODO: Support sending multiple messages to the backend in one request\n    const [pendingMessage] = userEvents.slice(0, userQueueEventCount);\n    try {\n      const requestPayload = createResponsePayload({\n        userEvents: [pendingMessage],\n        generationParams: settingsContext.generationParams,\n      });\n      const response = await getStreamingResponses(requestPayload);\n\n      console.log('response', response);\n      // Remove the pending message from the user events\n      markUserEventsProcessed([pendingMessage.eventId]);\n    } catch (error) {\n      console.error('error sending message');\n    }\n  }, [\n    userEvents,\n    userQueueEventCount,\n    createResponsePayload,\n    settingsContext.generationParams,\n    getStreamingResponses,\n    markUserEventsProcessed,\n  ]);\n\n  console.log('userQueueEventCount', userQueueEventCount);\n  console.log('userEvents', userEvents);\n\n  // This is the primary event loop for communicating with the backend API\n  // It will be triggered when there are pending messages to be sent to the backend\n  // It will be responsible for sending the messages to the backend and receiving the responses\n  useEffect(() => {\n    if (userQueueEventCount > 0) {\n      sendMessagesToBackend();\n    }\n    // TODO: Add a suggestion retrieval here (don't get suggestions unless the event queue is empty)\n    console.log('SalesAgentProvider useEffect');\n  }, [sendMessagesToBackend, userQueueEventCount]);\n\n  return <SalesAgentContext.Provider value={undefined}>{children}</SalesAgentContext.Provider>;\n};\n\nexport const useSalesAgent = (): SalesAgent => {\n  const messages = useAtomValue(messagesAtom);\n  const suggestions = useAtomValue(suggestionsAtom);\n  const pendingMessages = useAtomValue(userEventQueueAtom);\n  const isResponseStreaming = false; // useAtomValue(isResponseStreamingAtom);\n  const isPendingResponse = false; // useAtomValue(isPendingResponseAtom);\n  const isInitialized = false; // useAtomValue(isInitializedAtom);\n\n  const { logPageVisit, onSuggestionClicked, onTypedMessageSubmitted, onFormResponseSubmitted } =\n    useSalesAgentChatAPI();\n\n  const salesAgent: SalesAgent = useMemo(() => {\n    return {\n      messages,\n      suggestions,\n      pendingMessages,\n      isResponseStreaming,\n      isPendingResponse,\n      isInitialized,\n      logPageVisit,\n      onSuggestionClicked,\n      onTypedMessageSubmitted,\n      onFormResponseSubmitted,\n    };\n  }, [\n    messages,\n    suggestions,\n    pendingMessages,\n    isResponseStreaming,\n    isPendingResponse,\n    isInitialized,\n    logPageVisit,\n    onSuggestionClicked,\n    onTypedMessageSubmitted,\n    onFormResponseSubmitted,\n  ]);\n  return salesAgent;\n};\n"],"mappings":";;;;;;;;;;;AA6BA,MAAM,oBAAoB,cAAsC,OAAU;AAE1E,MAAaA,sBAAyD,EAAE,eAAe;CACrF,MAAM,aAAa,aAAa,mBAAmB;CACnD,MAAM,sBAAsB,aAAa,wBAAwB;CACjE,MAAM,0BAA0B,WAAW,qBAAqB;CAChE,MAAM,kBAAkB,0BAA0B;CAElD,MAAM,EAAE,uBAAuB,0BAA0B,sBAAsB;CAO/E,MAAM,wBAAwB,YAAY,YAAY;AAEpD,MAAI,WAAW,WAAW,EACxB;EAGF,MAAM,CAAC,kBAAkB,WAAW,MAAM,GAAG,oBAAoB;AACjE,MAAI;GAKF,MAAM,WAAW,MAAM,sBAJA,sBAAsB;IAC3C,YAAY,CAAC,eAAe;IAC5B,kBAAkB,gBAAgB;IACnC,CAAC,CAC0D;AAE5D,WAAQ,IAAI,YAAY,SAAS;AAEjC,2BAAwB,CAAC,eAAe,QAAQ,CAAC;WAC1C,OAAO;AACd,WAAQ,MAAM,wBAAwB;;IAEvC;EACD;EACA;EACA;EACA,gBAAgB;EAChB;EACA;EACD,CAAC;AAEF,SAAQ,IAAI,uBAAuB,oBAAoB;AACvD,SAAQ,IAAI,cAAc,WAAW;AAKrC,iBAAgB;AACd,MAAI,sBAAsB,EACxB,wBAAuB;AAGzB,UAAQ,IAAI,+BAA+B;IAC1C,CAAC,uBAAuB,oBAAoB,CAAC;AAEhD,QAAO,oBAAC,kBAAkB;EAAS,OAAO;EAAY;GAAsC;;AAG9F,MAAa,sBAAkC;CAC7C,MAAM,WAAW,aAAa,aAAa;CAC3C,MAAM,cAAc,aAAa,gBAAgB;CACjD,MAAM,kBAAkB,aAAa,mBAAmB;CACxD,MAAM,sBAAsB;CAC5B,MAAM,oBAAoB;CAC1B,MAAM,gBAAgB;CAEtB,MAAM,EAAE,cAAc,qBAAqB,yBAAyB,4BAClE,sBAAsB;AA2BxB,QAzB+B,cAAc;AAC3C,SAAO;GACL;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACD;IACA;EACD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD,CAAC"}

package/dist/contexts/salesAgentContext/salesAgentService.cjs

@@ -0,0 +1,99 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_useMessageInterceptor = require('../../interceptors/useMessageInterceptor.cjs');
+const require_logger = require('../../application/logging/logger.cjs');
+const require_message = require('../../application/models/message.cjs');
+require('../../application/models/index.cjs');
+const require_atoms_app_index = require('../../atoms/app/index.cjs');
+const require_featureFlagServiceContext = require('../featureFlagServiceContext/featureFlagServiceContext.cjs');
+const require_messageFromResponse = require('../../application/utils/messageFromResponse.cjs');
+require('../../application/utils/index.cjs');
+const require_chatState = require('../../atoms/chat/chatState.cjs');
+require('../featureFlagServiceContext/index.cjs');
+const require_commerce_api = require('../../application/commerce-api.cjs');
+let react = require("react");
+let uuid = require("uuid");
+let jotai = require("jotai");
+
+//#region src/contexts/salesAgentContext/salesAgentService.ts
+const getQueryParam = (key) => {
+	return new URL(window.location.href).searchParams.get(key);
+};
+const updateMessageState = (message, lastMessage, setMessages) => {
+	if (lastMessage == null) {
+		setMessages((prev) => [...prev, [message]]);
+		return message;
+	}
+	if (lastMessage.type === require_message.MessageType.Text && message.type === require_message.MessageType.Text) {
+		const newMessage = {
+			...lastMessage,
+			metadata: {
+				...lastMessage.metadata,
+				content: lastMessage.metadata.content + message.metadata.content
+			}
+		};
+		setMessages((prev) => {
+			const lastTurn = prev[prev.length - 1];
+			return [...prev.slice(0, prev.length - 1), [...lastTurn.slice(0, lastTurn.length - 1), newMessage]];
+		});
+		return newMessage;
+	}
+	setMessages((prev) => [...prev.slice(0, prev.length - 1), [...prev[prev.length - 1], message]]);
+	return message;
+};
+const processStreamingResponse = async (stream, messageInterceptor, setMessages) => {
+	let lastMessage;
+	for await (const response of stream) try {
+		if (messageInterceptor.intercept(response)) return;
+		if (!response) throw new Error("No response from stream");
+		const message = require_messageFromResponse.messageFromResponse(response);
+		if (!message) throw new Error("Failed to transform API response to client message");
+		lastMessage = updateMessageState(message, lastMessage, setMessages);
+	} catch (error) {
+		require_logger.default.logWarn(`[spiffy-ai] Failed to generate responses from stream`, error, {
+			lastResponse: lastMessage,
+			response
+		});
+	}
+};
+const useSalesAgentService = () => {
+	const setRequestFailure = (0, jotai.useSetAtom)(require_chatState.requestFailureAtom);
+	const setMessages = (0, jotai.useSetAtom)(require_chatState.messagesAtom);
+	const messageInterceptor = require_useMessageInterceptor.useMessageInterceptor();
+	const featureFlagService = require_featureFlagServiceContext.useFeatureFlagService();
+	const context = (0, jotai.useAtomValue)(require_atoms_app_index.appDetailsAtom);
+	return {
+		createResponsePayload: (0, react.useCallback)(({ userEvents, generationParams }) => {
+			const featureFlags = featureFlagService?.featureFlagService?.getFeatureFlags() || {};
+			const overrideConfigVersion = getQueryParam("spiffy_config_version") || getQueryParam("envive_config_version") || void 0;
+			const overrideModelDatetime = getQueryParam("override_model_datetime") || void 0;
+			return {
+				id: (0, uuid.v4)(),
+				context,
+				userEvents,
+				featureFlags,
+				generationParams,
+				overrideConfigVersion,
+				overrideModelDatetime
+			};
+		}, [context, featureFlagService?.featureFlagService]),
+		getStreamingResponses: (0, react.useCallback)(async (payload) => {
+			console.log("getStreamingResponses payload", JSON.stringify(payload, null, 2));
+			const stream = require_commerce_api.default.getNextResponseStreaming(payload);
+			try {
+				setRequestFailure(false);
+				await processStreamingResponse(stream, messageInterceptor, setMessages);
+			} catch (e) {
+				console.error("error getting streaming responses", e);
+				throw e;
+			}
+		}, [
+			setRequestFailure,
+			messageInterceptor,
+			setMessages
+		])
+	};
+};
+
+//#endregion
+exports.useSalesAgentService = useSalesAgentService;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"salesAgentService.cjs","names":["MessageType","lastMessage: Message | undefined","messageFromResponse","error: unknown","useSalesAgentService: () => SalesAgentService","requestFailureAtom","messagesAtom","useMessageInterceptor","useFeatureFlagService","appDetailsAtom","CommerceApiClient"],"sources":["../../../src/contexts/salesAgentContext/salesAgentService.ts"],"sourcesContent":["import { useAtomValue, useSetAtom } from 'jotai';\nimport { useCallback } from 'react';\nimport { v4 as uuid } from 'uuid';\nimport CommerceApiClient from 'src/application/commerce-api';\nimport { appDetailsAtom } from 'src/atoms/app';\nimport Logger from 'src/application/logging/logger';\nimport {\n  GenerationParams,\n  Message,\n  MessageType,\n  NextMessageRequest,\n  Response,\n  UserEvent,\n} from 'src/application/models';\nimport { messageFromResponse } from 'src/application/utils';\nimport { messagesAtom, requestFailureAtom } from 'src/atoms/chat/chatState';\nimport { useMessageInterceptor } from 'src/interceptors/useMessageInterceptor';\nimport { useFeatureFlagService } from '../featureFlagServiceContext';\n\ninterface SalesAgentService {\n  createResponsePayload: (payload: {\n    userEvents: UserEvent[];\n    generationParams?: GenerationParams;\n  }) => NextMessageRequest;\n  getStreamingResponses: (payload: NextMessageRequest) => Promise<void>;\n}\n\nexport const getQueryParam = (key: string): string | null => {\n  const urlObj = new URL(window.location.href);\n  return urlObj.searchParams.get(key);\n};\n\nconst updateMessageState = (\n  message: Message,\n  lastMessage: Message,\n  setMessages: (updater: (prev: Message[][]) => Message[][]) => void,\n): Message => {\n  if (lastMessage == null) {\n    setMessages(prev => [...prev, [message]]);\n    return message;\n  }\n  if (lastMessage.type === MessageType.Text && message.type === MessageType.Text) {\n    const newMessage = {\n      ...lastMessage,\n      metadata: {\n        ...lastMessage.metadata,\n        content: lastMessage.metadata.content + message.metadata.content,\n      },\n    };\n    setMessages(prev => {\n      const lastTurn = prev[prev.length - 1];\n      return [\n        ...prev.slice(0, prev.length - 1),\n        [...lastTurn.slice(0, lastTurn.length - 1), newMessage],\n      ];\n    });\n    return newMessage;\n  }\n  setMessages(prev => [...prev.slice(0, prev.length - 1), [...prev[prev.length - 1], message]]);\n  return message;\n};\n\nconst processStreamingResponse = async (\n  stream: AsyncIterable<Response>,\n  messageInterceptor: { intercept: (response?: Response) => boolean | undefined },\n  setMessages: (updater: (prev: Message[][]) => Message[][]) => void,\n): Promise<void> => {\n  let lastMessage: Message | undefined;\n\n  for await (const response of stream) {\n    try {\n      if (messageInterceptor.intercept(response)) {\n        return;\n      }\n\n      if (!response) {\n        throw new Error('No response from stream');\n      }\n      const message = messageFromResponse(response);\n      if (!message) {\n        throw new Error('Failed to transform API response to client message');\n      }\n\n      // No support for ChatSearch messages at the current time.\n      // Perhaps we add support back in the future\n      // if (message.type === MessageType.ProductSearch) {\n      //   handleSearchResults(message);\n      //   hasSearchResults = true;\n      //   setSearchIsLoading(false); // Update search loading immediately when results are detected\n      // }\n\n      lastMessage = updateMessageState(message, lastMessage!, setMessages);\n    } catch (error: unknown) {\n      Logger.logWarn(`[spiffy-ai] Failed to generate responses from stream`, error, {\n        lastResponse: lastMessage,\n        response,\n      });\n    }\n  }\n};\n\nexport const useSalesAgentService: () => SalesAgentService = () => {\n  const setRequestFailure = useSetAtom(requestFailureAtom);\n  const setMessages = useSetAtom(messagesAtom);\n  const messageInterceptor = useMessageInterceptor();\n\n  const featureFlagService = useFeatureFlagService();\n  const context = useAtomValue(appDetailsAtom);\n\n  const createResponsePayload = useCallback(\n    ({\n      userEvents,\n      generationParams,\n    }: {\n      userEvents: UserEvent[];\n      generationParams?: GenerationParams;\n    }): NextMessageRequest => {\n      const featureFlags = featureFlagService?.featureFlagService?.getFeatureFlags() || {};\n\n      const overrideConfigVersion =\n        getQueryParam('spiffy_config_version') ||\n        getQueryParam('envive_config_version') ||\n        undefined;\n      const overrideModelDatetime = getQueryParam('override_model_datetime') || undefined;\n      return {\n        id: uuid(),\n        context,\n        userEvents,\n        featureFlags,\n        generationParams,\n        overrideConfigVersion,\n        overrideModelDatetime,\n      };\n    },\n    [context, featureFlagService?.featureFlagService],\n  );\n\n  const getStreamingResponses = useCallback(\n    async (payload: NextMessageRequest): Promise<void> => {\n      // logPerfMetric(PerfMetricsEvents.FirstResponseStarted);\n      // const startTime = Date.now();\n      console.log('getStreamingResponses payload', JSON.stringify(payload, null, 2));\n      const stream = CommerceApiClient.getNextResponseStreaming(payload);\n\n      try {\n        setRequestFailure(false);\n\n        await processStreamingResponse(stream, messageInterceptor, setMessages);\n\n        // TODO: Add support for the Chrome Extension communication\n        // Log successful next_responses call\n        // const responseTime = Date.now() - startTime;\n        // await logBundleEvent({\n        //   level: 'info',\n        //   event: 'NEXT_RESPONSE_SUCCESS',\n        //   context: {\n        //     type: 'next_responses',\n        //     endpoint: '/v1/next_responses',\n        //     statusCode: 200,\n        //     responseTime,\n        //   },\n        // });\n      } catch (e) {\n        console.error('error getting streaming responses', e);\n        // Log failed next_responses call\n        // const responseTime = Date.now() - startTime;\n        // await logBundleEvent({\n        //   level: 'error',\n        //   event: 'NEXT_RESPONSE_FAILED',\n        //   message: `Failed to get streaming response: ${e}`,\n        //   context: {\n        //     type: 'next_responses',\n        //     endpoint: '/v1/next_responses',\n        //     responseTime,\n        //     error: e instanceof Error ? e.message : String(e),\n        //   },\n        // });\n\n        // handleStreamingError(e, setRequestFailure, setMessages);\n        throw e;\n        // } finally {\n        // logPerfMetric(PerfMetricsEvents.FirstResponseCompleted);\n      }\n    },\n    [\n      // logPerfMetric,\n      setRequestFailure,\n      messageInterceptor,\n      setMessages,\n    ],\n  );\n\n  return {\n    createResponsePayload,\n    getStreamingResponses,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AA2BA,MAAa,iBAAiB,QAA+B;AAE3D,QADe,IAAI,IAAI,OAAO,SAAS,KAAK,CAC9B,aAAa,IAAI,IAAI;;AAGrC,MAAM,sBACJ,SACA,aACA,gBACY;AACZ,KAAI,eAAe,MAAM;AACvB,eAAY,SAAQ,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;AACzC,SAAO;;AAET,KAAI,YAAY,SAASA,4BAAY,QAAQ,QAAQ,SAASA,4BAAY,MAAM;EAC9E,MAAM,aAAa;GACjB,GAAG;GACH,UAAU;IACR,GAAG,YAAY;IACf,SAAS,YAAY,SAAS,UAAU,QAAQ,SAAS;IAC1D;GACF;AACD,eAAY,SAAQ;GAClB,MAAM,WAAW,KAAK,KAAK,SAAS;AACpC,UAAO,CACL,GAAG,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,EACjC,CAAC,GAAG,SAAS,MAAM,GAAG,SAAS,SAAS,EAAE,EAAE,WAAW,CACxD;IACD;AACF,SAAO;;AAET,cAAY,SAAQ,CAAC,GAAG,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,EAAE,CAAC,GAAG,KAAK,KAAK,SAAS,IAAI,QAAQ,CAAC,CAAC;AAC7F,QAAO;;AAGT,MAAM,2BAA2B,OAC/B,QACA,oBACA,gBACkB;CAClB,IAAIC;AAEJ,YAAW,MAAM,YAAY,OAC3B,KAAI;AACF,MAAI,mBAAmB,UAAU,SAAS,CACxC;AAGF,MAAI,CAAC,SACH,OAAM,IAAI,MAAM,0BAA0B;EAE5C,MAAM,UAAUC,gDAAoB,SAAS;AAC7C,MAAI,CAAC,QACH,OAAM,IAAI,MAAM,qDAAqD;AAWvE,gBAAc,mBAAmB,SAAS,aAAc,YAAY;UAC7DC,OAAgB;AACvB,yBAAO,QAAQ,wDAAwD,OAAO;GAC5E,cAAc;GACd;GACD,CAAC;;;AAKR,MAAaC,6BAAsD;CACjE,MAAM,0CAA+BC,qCAAmB;CACxD,MAAM,oCAAyBC,+BAAa;CAC5C,MAAM,qBAAqBC,qDAAuB;CAElD,MAAM,qBAAqBC,yDAAuB;CAClD,MAAM,kCAAuBC,uCAAe;AAqF5C,QAAO;EACL,+CAnFC,EACC,YACA,uBAIwB;GACxB,MAAM,eAAe,oBAAoB,oBAAoB,iBAAiB,IAAI,EAAE;GAEpF,MAAM,wBACJ,cAAc,wBAAwB,IACtC,cAAc,wBAAwB,IACtC;GACF,MAAM,wBAAwB,cAAc,0BAA0B,IAAI;AAC1E,UAAO;IACL,kBAAU;IACV;IACA;IACA;IACA;IACA;IACA;IACD;KAEH,CAAC,SAAS,oBAAoB,mBAAmB,CAClD;EA2DC,8CAxDA,OAAO,YAA+C;AAGpD,WAAQ,IAAI,iCAAiC,KAAK,UAAU,SAAS,MAAM,EAAE,CAAC;GAC9E,MAAM,SAASC,6BAAkB,yBAAyB,QAAQ;AAElE,OAAI;AACF,sBAAkB,MAAM;AAExB,UAAM,yBAAyB,QAAQ,oBAAoB,YAAY;YAehE,GAAG;AACV,YAAQ,MAAM,qCAAqC,EAAE;AAgBrD,UAAM;;KAKV;GAEE;GACA;GACA;GACD,CACF;EAKA"}

package/dist/contexts/salesAgentContext/salesAgentService.js

@@ -0,0 +1,98 @@
+import { useMessageInterceptor } from "../../interceptors/useMessageInterceptor.js";
+import logger_default from "../../application/logging/logger.js";
+import { MessageType } from "../../application/models/message.js";
+import "../../application/models/index.js";
+import { appDetailsAtom } from "../../atoms/app/index.js";
+import { useFeatureFlagService } from "../featureFlagServiceContext/featureFlagServiceContext.js";
+import { messageFromResponse } from "../../application/utils/messageFromResponse.js";
+import "../../application/utils/index.js";
+import { messagesAtom, requestFailureAtom } from "../../atoms/chat/chatState.js";
+import "../featureFlagServiceContext/index.js";
+import commerce_api_default from "../../application/commerce-api.js";
+import { useCallback } from "react";
+import { v4 } from "uuid";
+import { useAtomValue, useSetAtom } from "jotai";
+
+//#region src/contexts/salesAgentContext/salesAgentService.ts
+const getQueryParam = (key) => {
+	return new URL(window.location.href).searchParams.get(key);
+};
+const updateMessageState = (message, lastMessage, setMessages) => {
+	if (lastMessage == null) {
+		setMessages((prev) => [...prev, [message]]);
+		return message;
+	}
+	if (lastMessage.type === MessageType.Text && message.type === MessageType.Text) {
+		const newMessage = {
+			...lastMessage,
+			metadata: {
+				...lastMessage.metadata,
+				content: lastMessage.metadata.content + message.metadata.content
+			}
+		};
+		setMessages((prev) => {
+			const lastTurn = prev[prev.length - 1];
+			return [...prev.slice(0, prev.length - 1), [...lastTurn.slice(0, lastTurn.length - 1), newMessage]];
+		});
+		return newMessage;
+	}
+	setMessages((prev) => [...prev.slice(0, prev.length - 1), [...prev[prev.length - 1], message]]);
+	return message;
+};
+const processStreamingResponse = async (stream, messageInterceptor, setMessages) => {
+	let lastMessage;
+	for await (const response of stream) try {
+		if (messageInterceptor.intercept(response)) return;
+		if (!response) throw new Error("No response from stream");
+		const message = messageFromResponse(response);
+		if (!message) throw new Error("Failed to transform API response to client message");
+		lastMessage = updateMessageState(message, lastMessage, setMessages);
+	} catch (error) {
+		logger_default.logWarn(`[spiffy-ai] Failed to generate responses from stream`, error, {
+			lastResponse: lastMessage,
+			response
+		});
+	}
+};
+const useSalesAgentService = () => {
+	const setRequestFailure = useSetAtom(requestFailureAtom);
+	const setMessages = useSetAtom(messagesAtom);
+	const messageInterceptor = useMessageInterceptor();
+	const featureFlagService = useFeatureFlagService();
+	const context = useAtomValue(appDetailsAtom);
+	return {
+		createResponsePayload: useCallback(({ userEvents, generationParams }) => {
+			const featureFlags = featureFlagService?.featureFlagService?.getFeatureFlags() || {};
+			const overrideConfigVersion = getQueryParam("spiffy_config_version") || getQueryParam("envive_config_version") || void 0;
+			const overrideModelDatetime = getQueryParam("override_model_datetime") || void 0;
+			return {
+				id: v4(),
+				context,
+				userEvents,
+				featureFlags,
+				generationParams,
+				overrideConfigVersion,
+				overrideModelDatetime
+			};
+		}, [context, featureFlagService?.featureFlagService]),
+		getStreamingResponses: useCallback(async (payload) => {
+			console.log("getStreamingResponses payload", JSON.stringify(payload, null, 2));
+			const stream = commerce_api_default.getNextResponseStreaming(payload);
+			try {
+				setRequestFailure(false);
+				await processStreamingResponse(stream, messageInterceptor, setMessages);
+			} catch (e) {
+				console.error("error getting streaming responses", e);
+				throw e;
+			}
+		}, [
+			setRequestFailure,
+			messageInterceptor,
+			setMessages
+		])
+	};
+};
+
+//#endregion
+export { useSalesAgentService };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"salesAgentService.js","names":["lastMessage: Message | undefined","error: unknown","useSalesAgentService: () => SalesAgentService","uuid","CommerceApiClient"],"sources":["../../../src/contexts/salesAgentContext/salesAgentService.ts"],"sourcesContent":["import { useAtomValue, useSetAtom } from 'jotai';\nimport { useCallback } from 'react';\nimport { v4 as uuid } from 'uuid';\nimport CommerceApiClient from 'src/application/commerce-api';\nimport { appDetailsAtom } from 'src/atoms/app';\nimport Logger from 'src/application/logging/logger';\nimport {\n  GenerationParams,\n  Message,\n  MessageType,\n  NextMessageRequest,\n  Response,\n  UserEvent,\n} from 'src/application/models';\nimport { messageFromResponse } from 'src/application/utils';\nimport { messagesAtom, requestFailureAtom } from 'src/atoms/chat/chatState';\nimport { useMessageInterceptor } from 'src/interceptors/useMessageInterceptor';\nimport { useFeatureFlagService } from '../featureFlagServiceContext';\n\ninterface SalesAgentService {\n  createResponsePayload: (payload: {\n    userEvents: UserEvent[];\n    generationParams?: GenerationParams;\n  }) => NextMessageRequest;\n  getStreamingResponses: (payload: NextMessageRequest) => Promise<void>;\n}\n\nexport const getQueryParam = (key: string): string | null => {\n  const urlObj = new URL(window.location.href);\n  return urlObj.searchParams.get(key);\n};\n\nconst updateMessageState = (\n  message: Message,\n  lastMessage: Message,\n  setMessages: (updater: (prev: Message[][]) => Message[][]) => void,\n): Message => {\n  if (lastMessage == null) {\n    setMessages(prev => [...prev, [message]]);\n    return message;\n  }\n  if (lastMessage.type === MessageType.Text && message.type === MessageType.Text) {\n    const newMessage = {\n      ...lastMessage,\n      metadata: {\n        ...lastMessage.metadata,\n        content: lastMessage.metadata.content + message.metadata.content,\n      },\n    };\n    setMessages(prev => {\n      const lastTurn = prev[prev.length - 1];\n      return [\n        ...prev.slice(0, prev.length - 1),\n        [...lastTurn.slice(0, lastTurn.length - 1), newMessage],\n      ];\n    });\n    return newMessage;\n  }\n  setMessages(prev => [...prev.slice(0, prev.length - 1), [...prev[prev.length - 1], message]]);\n  return message;\n};\n\nconst processStreamingResponse = async (\n  stream: AsyncIterable<Response>,\n  messageInterceptor: { intercept: (response?: Response) => boolean | undefined },\n  setMessages: (updater: (prev: Message[][]) => Message[][]) => void,\n): Promise<void> => {\n  let lastMessage: Message | undefined;\n\n  for await (const response of stream) {\n    try {\n      if (messageInterceptor.intercept(response)) {\n        return;\n      }\n\n      if (!response) {\n        throw new Error('No response from stream');\n      }\n      const message = messageFromResponse(response);\n      if (!message) {\n        throw new Error('Failed to transform API response to client message');\n      }\n\n      // No support for ChatSearch messages at the current time.\n      // Perhaps we add support back in the future\n      // if (message.type === MessageType.ProductSearch) {\n      //   handleSearchResults(message);\n      //   hasSearchResults = true;\n      //   setSearchIsLoading(false); // Update search loading immediately when results are detected\n      // }\n\n      lastMessage = updateMessageState(message, lastMessage!, setMessages);\n    } catch (error: unknown) {\n      Logger.logWarn(`[spiffy-ai] Failed to generate responses from stream`, error, {\n        lastResponse: lastMessage,\n        response,\n      });\n    }\n  }\n};\n\nexport const useSalesAgentService: () => SalesAgentService = () => {\n  const setRequestFailure = useSetAtom(requestFailureAtom);\n  const setMessages = useSetAtom(messagesAtom);\n  const messageInterceptor = useMessageInterceptor();\n\n  const featureFlagService = useFeatureFlagService();\n  const context = useAtomValue(appDetailsAtom);\n\n  const createResponsePayload = useCallback(\n    ({\n      userEvents,\n      generationParams,\n    }: {\n      userEvents: UserEvent[];\n      generationParams?: GenerationParams;\n    }): NextMessageRequest => {\n      const featureFlags = featureFlagService?.featureFlagService?.getFeatureFlags() || {};\n\n      const overrideConfigVersion =\n        getQueryParam('spiffy_config_version') ||\n        getQueryParam('envive_config_version') ||\n        undefined;\n      const overrideModelDatetime = getQueryParam('override_model_datetime') || undefined;\n      return {\n        id: uuid(),\n        context,\n        userEvents,\n        featureFlags,\n        generationParams,\n        overrideConfigVersion,\n        overrideModelDatetime,\n      };\n    },\n    [context, featureFlagService?.featureFlagService],\n  );\n\n  const getStreamingResponses = useCallback(\n    async (payload: NextMessageRequest): Promise<void> => {\n      // logPerfMetric(PerfMetricsEvents.FirstResponseStarted);\n      // const startTime = Date.now();\n      console.log('getStreamingResponses payload', JSON.stringify(payload, null, 2));\n      const stream = CommerceApiClient.getNextResponseStreaming(payload);\n\n      try {\n        setRequestFailure(false);\n\n        await processStreamingResponse(stream, messageInterceptor, setMessages);\n\n        // TODO: Add support for the Chrome Extension communication\n        // Log successful next_responses call\n        // const responseTime = Date.now() - startTime;\n        // await logBundleEvent({\n        //   level: 'info',\n        //   event: 'NEXT_RESPONSE_SUCCESS',\n        //   context: {\n        //     type: 'next_responses',\n        //     endpoint: '/v1/next_responses',\n        //     statusCode: 200,\n        //     responseTime,\n        //   },\n        // });\n      } catch (e) {\n        console.error('error getting streaming responses', e);\n        // Log failed next_responses call\n        // const responseTime = Date.now() - startTime;\n        // await logBundleEvent({\n        //   level: 'error',\n        //   event: 'NEXT_RESPONSE_FAILED',\n        //   message: `Failed to get streaming response: ${e}`,\n        //   context: {\n        //     type: 'next_responses',\n        //     endpoint: '/v1/next_responses',\n        //     responseTime,\n        //     error: e instanceof Error ? e.message : String(e),\n        //   },\n        // });\n\n        // handleStreamingError(e, setRequestFailure, setMessages);\n        throw e;\n        // } finally {\n        // logPerfMetric(PerfMetricsEvents.FirstResponseCompleted);\n      }\n    },\n    [\n      // logPerfMetric,\n      setRequestFailure,\n      messageInterceptor,\n      setMessages,\n    ],\n  );\n\n  return {\n    createResponsePayload,\n    getStreamingResponses,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;AA2BA,MAAa,iBAAiB,QAA+B;AAE3D,QADe,IAAI,IAAI,OAAO,SAAS,KAAK,CAC9B,aAAa,IAAI,IAAI;;AAGrC,MAAM,sBACJ,SACA,aACA,gBACY;AACZ,KAAI,eAAe,MAAM;AACvB,eAAY,SAAQ,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;AACzC,SAAO;;AAET,KAAI,YAAY,SAAS,YAAY,QAAQ,QAAQ,SAAS,YAAY,MAAM;EAC9E,MAAM,aAAa;GACjB,GAAG;GACH,UAAU;IACR,GAAG,YAAY;IACf,SAAS,YAAY,SAAS,UAAU,QAAQ,SAAS;IAC1D;GACF;AACD,eAAY,SAAQ;GAClB,MAAM,WAAW,KAAK,KAAK,SAAS;AACpC,UAAO,CACL,GAAG,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,EACjC,CAAC,GAAG,SAAS,MAAM,GAAG,SAAS,SAAS,EAAE,EAAE,WAAW,CACxD;IACD;AACF,SAAO;;AAET,cAAY,SAAQ,CAAC,GAAG,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,EAAE,CAAC,GAAG,KAAK,KAAK,SAAS,IAAI,QAAQ,CAAC,CAAC;AAC7F,QAAO;;AAGT,MAAM,2BAA2B,OAC/B,QACA,oBACA,gBACkB;CAClB,IAAIA;AAEJ,YAAW,MAAM,YAAY,OAC3B,KAAI;AACF,MAAI,mBAAmB,UAAU,SAAS,CACxC;AAGF,MAAI,CAAC,SACH,OAAM,IAAI,MAAM,0BAA0B;EAE5C,MAAM,UAAU,oBAAoB,SAAS;AAC7C,MAAI,CAAC,QACH,OAAM,IAAI,MAAM,qDAAqD;AAWvE,gBAAc,mBAAmB,SAAS,aAAc,YAAY;UAC7DC,OAAgB;AACvB,iBAAO,QAAQ,wDAAwD,OAAO;GAC5E,cAAc;GACd;GACD,CAAC;;;AAKR,MAAaC,6BAAsD;CACjE,MAAM,oBAAoB,WAAW,mBAAmB;CACxD,MAAM,cAAc,WAAW,aAAa;CAC5C,MAAM,qBAAqB,uBAAuB;CAElD,MAAM,qBAAqB,uBAAuB;CAClD,MAAM,UAAU,aAAa,eAAe;AAqF5C,QAAO;EACL,uBApF4B,aAC3B,EACC,YACA,uBAIwB;GACxB,MAAM,eAAe,oBAAoB,oBAAoB,iBAAiB,IAAI,EAAE;GAEpF,MAAM,wBACJ,cAAc,wBAAwB,IACtC,cAAc,wBAAwB,IACtC;GACF,MAAM,wBAAwB,cAAc,0BAA0B,IAAI;AAC1E,UAAO;IACL,IAAIC,IAAM;IACV;IACA;IACA;IACA;IACA;IACA;IACD;KAEH,CAAC,SAAS,oBAAoB,mBAAmB,CAClD;EA2DC,uBAzD4B,YAC5B,OAAO,YAA+C;AAGpD,WAAQ,IAAI,iCAAiC,KAAK,UAAU,SAAS,MAAM,EAAE,CAAC;GAC9E,MAAM,SAASC,qBAAkB,yBAAyB,QAAQ;AAElE,OAAI;AACF,sBAAkB,MAAM;AAExB,UAAM,yBAAyB,QAAQ,oBAAoB,YAAY;YAehE,GAAG;AACV,YAAQ,MAAM,qCAAqC,EAAE;AAgBrD,UAAM;;KAKV;GAEE;GACA;GACA;GACD,CACF;EAKA"}