@envive-ai/react-hooks 0.3.1 → 0.3.3

package/src/contexts/chatContext/chatContext.tsx

@@ -1,463 +0,0 @@
-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, userIdAtom, 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';
-
-/**
- * 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 userId = useAtomValue(userIdAtom);
-  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/contexts/chatContext/index.ts

@@ -1 +0,0 @@
-export * from './chatContext';