@envive-ai/react-hooks 0.2.6-alpha-arthur-3 → 0.2.6-alpha-arthur-4

package/src/contexts/chatContext/chatContext.tsx

@@ -0,0 +1,512 @@
+import { UserEventCategory } from "@spiffy-ai/commerce-api-client";
+import { useAtom, useAtomValue, useSetAtom } from "jotai";
+import {
+  createContext,
+  useEffect,
+  useState,
+  ReactNode,
+  useCallback,
+  useMemo,
+} from "react";
+import CommerceApiClient from "src/application/commerce-api";
+import { v4 as uuid } from "uuid";
+import { SessionRestartRequired } from "src/types/exceptions/sessionExceptions";
+import Logger from "src/application/logging/logger";
+import {
+  Message,
+  MessageRole,
+  MessageType,
+  NextMessageRequest,
+  Response,
+} from "src/application/models";
+import { SpiffyMetricsEventName } from "src/contexts/amplitudeContext/amplitudeContext";
+import { messageFromResponse } from "src/application/utils";
+import { chatIdAtom, variantInfoAtom } from "src/atoms/app";
+import {
+  messagesAtom,
+  requestFailureAtom,
+  responseStreamingAtom,
+  userHasRepliedAtom,
+  PerfMetricsEvents,
+  logPerfMetricAtom,
+  userEventsAtom,
+  suggestionsLoadingAtom,
+  suggestionsAtom,
+} from "src/atoms/chat";
+import {
+  chatSearchProductSortingAtom,
+  chatSearchProducts,
+  chatSearchStateAtom,
+  handleSearchResultsAtom,
+  chatSearchIsLoadingAtom,
+} from "src/atoms/search/chatSearch";
+import { createAppLoadedEvent, createVisitUserEvent } from "src/hooks/utils";
+import { useMessageInterceptor } from "src/interceptors/useMessageInterceptor";
+import { supportedEventAtom } from "src/atoms/app/variant";
+import { chatAtom } from "src/atoms/chat";
+import { getAtomStore } from "src/atoms/atomStore";
+import {
+  clearUserEventAtom,
+  createResponsePayload,
+  processUserEventAtom,
+  userEventQueueAtom,
+  userQueueEventCountAtom,
+} from "src/atoms/chat/messageQueue";
+import { useAmplitudeTracking } from "src/hooks/AmplitudeOperations/useAmplitudeOperations";
+import { useSystemSettingsContext } from "src/hooks/SystemSettingsContext";
+import { useUserIdentity } from "../userIdentityContext";
+
+/**
+ * Record the chat assistant response in Amplitude
+ *
+ * @param startTimeMs The start time of the assistant response
+ * @param payload The payload used to generate the response
+ */
+const recordAssistantResponse = (
+  startTimeMs: number,
+  payload: NextMessageRequest,
+  track: (
+    eventName: SpiffyMetricsEventName,
+    eventProps?: Record<string, unknown>
+  ) => void
+) => {
+  const atomStore = getAtomStore();
+  const chatState = atomStore.get(chatAtom);
+  const chatSearchState = atomStore.get(chatSearchStateAtom);
+  const searchProducts = atomStore.get(chatSearchProducts);
+  const searchProductsSort = atomStore.get(chatSearchProductSortingAtom);
+  const assistantResponseTimeMs = { start: startTimeMs, end: Date.now() };
+  let userQueryProperty: string | undefined;
+
+  if (
+    chatState.replyEventCategory === UserEventCategory.SuggestionClicked &&
+    chatState.suggestion
+  ) {
+    userQueryProperty = chatState.suggestion.content;
+  } else if (chatState.userQuery && chatState.userQuery.length > 0) {
+    userQueryProperty = chatState.userQuery;
+  }
+
+  const eventProps: Record<string, unknown> = {
+    response_time_ms:
+      assistantResponseTimeMs.end - assistantResponseTimeMs.start,
+    user_event_type: chatState.replyEventCategory,
+    user_query: userQueryProperty,
+  };
+
+  if (chatState.replyEventCategory === UserEventCategory.FormSubmitted) {
+    const lastAssistantTurn = chatState.messages
+      .filter(
+        (turn) => turn.length > 0 && turn[0].role === MessageRole.Assistant
+      )
+      .pop();
+    const formType = payload.userEvents?.find(
+      (event) => event.category === UserEventCategory.FormSubmitted
+    )?.attributes.formType;
+    const formStatus = lastAssistantTurn?.some(
+      (response) => response.type === MessageType.Order
+    );
+    eventProps.form_submitted_attributes = {
+      form_type: formType,
+      status: formStatus ? "success" : "failed",
+    };
+  }
+
+  if (chatSearchState === "product-page") {
+    eventProps.search_products_returned = searchProducts.length;
+    eventProps.search_products_sort_type = searchProductsSort;
+  }
+
+  track(SpiffyMetricsEventName.ChatAssistantResponse, {
+    eventProps,
+  });
+};
+
+interface ChatContextParams {}
+
+const ChatContext = createContext<ChatContextParams | undefined>(undefined);
+
+const updateMessageState = (
+  message: Message,
+  lastMessage: Message,
+  setMessages: (updater: (prev: Message[][]) => Message[][]) => void
+): Message => {
+  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 handleStreamingError = (
+  _error: unknown,
+  setRequestFailure: (failed: boolean) => void,
+  setMessages: (updater: (prev: Message[][]) => Message[][]) => void
+) => {
+  setRequestFailure(true);
+  setMessages((prev) => [
+    ...prev,
+    [
+      {
+        id: uuid(),
+        role: MessageRole.Assistant,
+        type: MessageType.Text,
+        createdAt: new Date().toISOString(),
+        metadata: {
+          content:
+            "I'm sorry! I'm having trouble right now. Please refresh the page or try again in a moment.",
+        },
+      },
+    ],
+  ]);
+};
+
+const processStreamingResponse = async (
+  stream: AsyncIterable<Response>,
+  messageInterceptor: {
+    intercept: (response?: Response) => boolean | undefined;
+  },
+  handleSearchResults: (message: Message) => void,
+  setMessages: (updater: (prev: Message[][]) => Message[][]) => void,
+  setSearchIsLoading: (loading: boolean) => void,
+  chatId: string
+): Promise<{ hasSearchResults: boolean }> => {
+  let lastMessage: Message | undefined;
+  let hasSearchResults = false;
+
+  for await (const response of stream) {
+    try {
+      if (messageInterceptor.intercept(response)) {
+        return { hasSearchResults };
+      }
+
+      const message = messageFromResponse(response);
+      if (!message) {
+        throw new Error("Failed to transform API response to client message");
+      }
+
+      if (message.type === MessageType.ProductSearch) {
+        handleSearchResults(message);
+        hasSearchResults = true;
+        setSearchIsLoading(false); // Update search loading immediately when results are detected
+      }
+
+      lastMessage = updateMessageState(message, lastMessage!, setMessages);
+    } catch (error: unknown) {
+      Logger.logWarn(
+        `[spiffy-ai] Failed to generate responses from stream chat_id=${chatId}`,
+        error,
+        {
+          lastResponse: lastMessage,
+          response,
+        }
+      );
+    }
+  }
+
+  return { hasSearchResults };
+};
+
+const ChatContextProvider = ({ children }: { children: ReactNode }) => {
+  const logPerfMetric = useSetAtom(logPerfMetricAtom);
+  const [widgetInitialized, setWidgetInitialized] = useState(false);
+  const setUserHasReplied = useSetAtom(userHasRepliedAtom);
+  // TODO: create atoms for setting/getting the last message turn
+  const [messages, setMessages] = useAtom<Message[][]>(messagesAtom);
+  const setUserEvents = useSetAtom(userEventsAtom);
+  const setSuggestions = useSetAtom(suggestionsAtom);
+  const [suggestionsLoading, setSuggestionsLoading] = useAtom<boolean>(
+    suggestionsLoadingAtom
+  );
+  const [responseStreaming, setResponseStreaming] = useAtom<boolean>(
+    responseStreamingAtom
+  );
+  const setRequestFailure = useSetAtom(requestFailureAtom);
+  const userEvents = useAtomValue(userEventQueueAtom);
+  const userQueueEventCount = useAtomValue(userQueueEventCountAtom);
+  const markUserEventsProcessed = useSetAtom(processUserEventAtom);
+  const clearUserEventQueue = useSetAtom(clearUserEventAtom);
+  const { getUserIdOrDefault } = useUserIdentity();
+  const userId = getUserIdOrDefault();
+  
+  const chatId = useAtomValue(chatIdAtom);
+  const supportedEvent = useAtomValue(supportedEventAtom);
+  // TODO: Replace with actual orgId from useEnviveConfig or NewOrgConfigContext when available
+  const orgId = "mock-org-id";
+
+  const variantInfo = useAtomValue(variantInfoAtom);
+  const settingsContext = useSystemSettingsContext();
+  const messageInterceptor = useMessageInterceptor();
+  const handleSearchResults = useSetAtom(handleSearchResultsAtom);
+  const setSearchIsLoading = useSetAtom(chatSearchIsLoadingAtom);
+  const { track } = useAmplitudeTracking();
+
+  const getStreamingResponses = useCallback(
+    async (
+      payload: NextMessageRequest
+    ): Promise<{ hasSearchResults: boolean }> => {
+      logPerfMetric(PerfMetricsEvents.FirstResponseStarted);
+      const stream = CommerceApiClient.getNextResponseStreaming(payload);
+
+      try {
+        setRequestFailure(false);
+
+        const { hasSearchResults } = await processStreamingResponse(
+          stream,
+          messageInterceptor,
+          handleSearchResults,
+          setMessages,
+          setSearchIsLoading,
+          chatId
+        );
+
+        return { hasSearchResults };
+      } catch (e) {
+        handleStreamingError(e, setRequestFailure, setMessages);
+        throw e;
+      } finally {
+        logPerfMetric(PerfMetricsEvents.FirstResponseCompleted);
+      }
+    },
+    [
+      logPerfMetric,
+      setRequestFailure,
+      messageInterceptor,
+      handleSearchResults,
+      setMessages,
+      setSearchIsLoading,
+      chatId,
+    ]
+  );
+
+  const getSuggestions = useCallback(async () => {
+    logPerfMetric(PerfMetricsEvents.FirstSuggestionsStarted);
+    setSuggestionsLoading(true);
+    setSuggestions([]);
+
+    const payloadWithoutAppLoaded = createResponsePayload({
+      userEvents: [],
+      generationParams: settingsContext.generationParams,
+    });
+    const response = await CommerceApiClient.getNextSuggestions(
+      payloadWithoutAppLoaded
+    );
+
+    // sort the suggestions by shortest length so the pills can be stacked horizontally
+    setSuggestions(
+      response.sort((a, b) => a.content.length - b.content.length)
+    );
+    setSuggestionsLoading(false);
+    logPerfMetric(PerfMetricsEvents.FirstSuggestionsCompleted);
+  }, [
+    logPerfMetric,
+    setSuggestionsLoading,
+    setSuggestions,
+    settingsContext.generationParams,
+  ]);
+
+  const getResponses = useCallback(
+    async (payload?: NextMessageRequest) => {
+      try {
+        const requestPayload =
+          payload ??
+          createResponsePayload({
+            userEvents,
+            generationParams: settingsContext.generationParams,
+          });
+
+        setResponseStreaming(true);
+        setSuggestions([]);
+        const startTimeMs = Date.now();
+
+        await getStreamingResponses(requestPayload);
+
+        recordAssistantResponse(startTimeMs, requestPayload, track);
+        await getSuggestions();
+      } catch (error) {
+        Logger.logError("[spiffy-ai] getResponses error", error);
+      } finally {
+        // Remove search loading management from here - it's now handled independently
+        // in the processStreamingResponse function when search results are detected
+        markUserEventsProcessed(userEvents.map(({ eventId }) => eventId));
+        setUserHasReplied(false);
+        setResponseStreaming(false);
+      }
+    },
+    [
+      userEvents,
+      settingsContext.generationParams,
+      setResponseStreaming,
+      setSuggestions,
+      getStreamingResponses,
+      markUserEventsProcessed,
+      getSuggestions,
+      setUserHasReplied,
+      track,
+    ]
+  );
+
+  useEffect(() => {
+    const processUserEvents = async () => {
+      if (responseStreaming || !widgetInitialized) {
+        return;
+      }
+
+      if (
+        (variantInfo.variant === "pdp" && !variantInfo.productId) ||
+        (variantInfo.variant === "plp" && !variantInfo.plpId) ||
+        (variantInfo.variant === "page_visit" && !variantInfo.url)
+      ) {
+        Logger.logDebug(
+          "[spiffy-ai] variantInfo has invalid values, skipping...",
+          {
+            variantInfo,
+            supportedEvent,
+          }
+        );
+        return;
+      }
+
+      Logger.logDebug(
+        `Assistants Turn is_currently_streaming=${responseStreaming} initialized=${widgetInitialized}`
+      );
+      try {
+        await getResponses();
+        Logger.logInfo(`Assistants Turn [finished]`);
+      } catch (error: unknown) {
+        Logger.logError("[spiffy-ai] Assistants Turn error", error);
+      }
+    };
+    if (userQueueEventCount > 0) {
+      processUserEvents();
+    }
+  }, [
+    getResponses,
+    responseStreaming,
+    userQueueEventCount,
+    widgetInitialized,
+    variantInfo,
+    supportedEvent,
+  ]);
+
+  useEffect(() => {
+    if (widgetInitialized || responseStreaming) {
+      Logger.logDebug(
+        `[spiffy-ai] initializeWidget [skipped] is_currently_streaming=${responseStreaming} is_initialized=${widgetInitialized}`
+      );
+      return;
+    }
+
+    const hydrateChat = async () => {
+      try {
+        Logger.logDebug(
+          `[spiffy-ai] initializeWidget is_currently_streaming=${responseStreaming} is_initialized=${widgetInitialized}`
+        );
+        // on mount, try to get the responses from an active session if one exists
+        if (!orgId) {
+          throw new Error("orgId is not available");
+        }
+        const { messages: existingMessages, userEvents } =
+          await CommerceApiClient.getResponses(orgId, chatId, userId);
+        setMessages([...existingMessages]);
+        setUserEvents([...userEvents]);
+        getResponses();
+      } catch (error) {
+        // no active chat session was found, start a new one
+        Logger.logInfo(
+          `Init chat [exception] chat_id=${chatId} error=${error}`,
+          error
+        );
+        if (error instanceof SessionRestartRequired) {
+          const appLoadedEvent = createAppLoadedEvent();
+          const visitEvent = createVisitUserEvent({ variantInfo });
+          setMessages([]);
+          clearUserEventQueue();
+          if (visitEvent) {
+            const payload = createResponsePayload({
+              userEvents: [appLoadedEvent, visitEvent],
+              generationParams: settingsContext.generationParams,
+            });
+            getResponses(payload);
+          }
+        }
+      } finally {
+        setWidgetInitialized(true);
+      }
+    };
+
+    hydrateChat();
+  }, []);
+
+  const onFocus = useCallback(async () => {
+    try {
+      if (!responseStreaming && !suggestionsLoading && orgId) {
+        const { messages: existingMessages } =
+          await CommerceApiClient.getResponses(orgId, chatId, userId);
+
+        if (existingMessages.length > messages.length) {
+          setMessages([...existingMessages]);
+          // TODO: Is this bug hack still necessary?
+          // If it is, come up with a better solution for it
+          // } else if (existingMessages.length === 0) {
+          //   // if there was an error during the initialization of a new session, the session would be
+          //   // created in the backend but without any messages. Retry the next_responses request with
+          //   // the current set of parameters to "jumpstart" the session
+          //   triggerGetResponseCall('onFocus');
+        }
+      }
+    } catch (error: unknown) {
+      Logger.logError("[spiffy-ai] onFocus error", error);
+    }
+  }, [
+    responseStreaming,
+    suggestionsLoading,
+    orgId,
+    chatId,
+    userId,
+    messages.length,
+    setMessages,
+  ]);
+
+  // listen for page focus to get latest messages from the server
+  useEffect(() => {
+    window.addEventListener("focus", onFocus);
+
+    return () => {
+      window.removeEventListener("focus", onFocus);
+    };
+  }, [onFocus]);
+
+  const chatContext = useMemo(() => ({}), []);
+
+  return (
+    <ChatContext.Provider value={chatContext}>{children}</ChatContext.Provider>
+  );
+};
+
+export { ChatContext, ChatContextProvider };
+export type { ChatContextParams };

package/src/hooks/AppDetails/useAppDetails.ts

@@ -6,9 +6,20 @@ import {
   envAtom as enviveEnvAtom,
   orgShortNameAtom as enviveOrgShortNameAtom,
 } from 'src/atoms/envive/enviveConfig';
-import { chatIdAtom, userIdAtom } from 'src/atoms/app/index';
 import { useOrgId } from 'src/hooks/GraphQLConfig/useGraphQLConfig';
 import { AppDetails } from '@envive-ai/types';
+import { chatIdAtom } from "src/atoms/app/index";
+import { useUserIdentity } from "src/contexts/userIdentityContext/userIdentityContext";
+
+export interface AppDetails {
+  orgId: string;
+  orgShortName: string;
+  chatId: string;
+  userId: string;
+  source: ContextSourceEnum;
+  env: ContextEnvEnum;
+  variantInfo: VariantInfo;
+}
 
 export const useAppDetails = (): AppDetails => {
   const { orgId: fetchedOrgId } = useOrgId(); // Get orgId from useOrgId hook
@@ -16,7 +27,9 @@ export const useAppDetails = (): AppDetails => {
 
   const orgShortName = useAtomValue(enviveOrgShortNameAtom) ?? 'spiffy-ai';
   const chatId = useAtomValue(chatIdAtom);
-  const userId = useAtomValue(userIdAtom);
+  
+  const { getUserIdOrDefault } = useUserIdentity();
+  const userId = getUserIdOrDefault();
   const source = useAtomValue(contextSourceAtom) ?? ContextSourceEnum.App;
   const env = (useAtomValue(enviveEnvAtom) as ContextEnvEnum) ?? ContextEnvEnum.Dev; // Cast to ContextEnvEnum
   const variantInfo = useAtomValue(variantInfoAtom);